mirror of
https://github.com/aykhans/AzSuicideDataVisualization.git
synced 2025-04-21 18:23:35 +00:00
1021 lines
33 KiB
Python
1021 lines
33 KiB
Python
from plotly.basedatatypes import BaseTraceType as _BaseTraceType
|
|
import copy as _copy
|
|
|
|
|
|
class Indicator(_BaseTraceType):
|
|
|
|
# class properties
|
|
# --------------------
|
|
_parent_path_str = ""
|
|
_path_str = "indicator"
|
|
_valid_props = {
|
|
"align",
|
|
"customdata",
|
|
"customdatasrc",
|
|
"delta",
|
|
"domain",
|
|
"gauge",
|
|
"ids",
|
|
"idssrc",
|
|
"legendgrouptitle",
|
|
"legendrank",
|
|
"meta",
|
|
"metasrc",
|
|
"mode",
|
|
"name",
|
|
"number",
|
|
"stream",
|
|
"title",
|
|
"type",
|
|
"uid",
|
|
"uirevision",
|
|
"value",
|
|
"visible",
|
|
}
|
|
|
|
# align
|
|
# -----
|
|
@property
|
|
def align(self):
|
|
"""
|
|
Sets the horizontal alignment of the `text` within the box.
|
|
Note that this attribute has no effect if an angular gauge is
|
|
displayed: in this case, it is always centered
|
|
|
|
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
|
|
|
|
# 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 Chart Studio Cloud 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
|
|
|
|
# delta
|
|
# -----
|
|
@property
|
|
def delta(self):
|
|
"""
|
|
The 'delta' property is an instance of Delta
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.indicator.Delta`
|
|
- A dict of string/value properties that will be passed
|
|
to the Delta constructor
|
|
|
|
Supported dict properties:
|
|
|
|
decreasing
|
|
:class:`plotly.graph_objects.indicator.delta.De
|
|
creasing` instance or dict with compatible
|
|
properties
|
|
font
|
|
Set the font used to display the delta
|
|
increasing
|
|
:class:`plotly.graph_objects.indicator.delta.In
|
|
creasing` instance or dict with compatible
|
|
properties
|
|
position
|
|
Sets the position of delta with respect to the
|
|
number.
|
|
reference
|
|
Sets the reference value to compute the delta.
|
|
By default, it is set to the current value.
|
|
relative
|
|
Show relative change
|
|
valueformat
|
|
Sets the value 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/tree/v1.4.5#d3-f
|
|
ormat.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.indicator.Delta
|
|
"""
|
|
return self["delta"]
|
|
|
|
@delta.setter
|
|
def delta(self, val):
|
|
self["delta"] = val
|
|
|
|
# domain
|
|
# ------
|
|
@property
|
|
def domain(self):
|
|
"""
|
|
The 'domain' property is an instance of Domain
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.indicator.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 indicator
|
|
trace .
|
|
row
|
|
If there is a layout grid, use the domain for
|
|
this row in the grid for this indicator trace .
|
|
x
|
|
Sets the horizontal domain of this indicator
|
|
trace (in plot fraction).
|
|
y
|
|
Sets the vertical domain of this indicator
|
|
trace (in plot fraction).
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.indicator.Domain
|
|
"""
|
|
return self["domain"]
|
|
|
|
@domain.setter
|
|
def domain(self, val):
|
|
self["domain"] = val
|
|
|
|
# gauge
|
|
# -----
|
|
@property
|
|
def gauge(self):
|
|
"""
|
|
The gauge of the Indicator plot.
|
|
|
|
The 'gauge' property is an instance of Gauge
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.indicator.Gauge`
|
|
- A dict of string/value properties that will be passed
|
|
to the Gauge constructor
|
|
|
|
Supported dict properties:
|
|
|
|
axis
|
|
:class:`plotly.graph_objects.indicator.gauge.Ax
|
|
is` instance or dict with compatible properties
|
|
bar
|
|
Set the appearance of the gauge's value
|
|
bgcolor
|
|
Sets the gauge background color.
|
|
bordercolor
|
|
Sets the color of the border enclosing the
|
|
gauge.
|
|
borderwidth
|
|
Sets the width (in px) of the border enclosing
|
|
the gauge.
|
|
shape
|
|
Set the shape of the gauge
|
|
steps
|
|
A tuple of :class:`plotly.graph_objects.indicat
|
|
or.gauge.Step` instances or dicts with
|
|
compatible properties
|
|
stepdefaults
|
|
When used in a template (as layout.template.dat
|
|
a.indicator.gauge.stepdefaults), sets the
|
|
default property values to use for elements of
|
|
indicator.gauge.steps
|
|
threshold
|
|
:class:`plotly.graph_objects.indicator.gauge.Th
|
|
reshold` instance or dict with compatible
|
|
properties
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.indicator.Gauge
|
|
"""
|
|
return self["gauge"]
|
|
|
|
@gauge.setter
|
|
def gauge(self, val):
|
|
self["gauge"] = 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 Chart Studio Cloud 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
|
|
|
|
# legendgrouptitle
|
|
# ----------------
|
|
@property
|
|
def legendgrouptitle(self):
|
|
"""
|
|
The 'legendgrouptitle' property is an instance of Legendgrouptitle
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.indicator.Legendgrouptitle`
|
|
- A dict of string/value properties that will be passed
|
|
to the Legendgrouptitle constructor
|
|
|
|
Supported dict properties:
|
|
|
|
font
|
|
Sets this legend group's title font.
|
|
text
|
|
Sets the title of the legend group.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.indicator.Legendgrouptitle
|
|
"""
|
|
return self["legendgrouptitle"]
|
|
|
|
@legendgrouptitle.setter
|
|
def legendgrouptitle(self, val):
|
|
self["legendgrouptitle"] = val
|
|
|
|
# legendrank
|
|
# ----------
|
|
@property
|
|
def legendrank(self):
|
|
"""
|
|
Sets the legend rank for this trace. Items and groups with
|
|
smaller ranks are presented on top/left side while with
|
|
`*reversed* `legend.traceorder` they are on bottom/right side.
|
|
The default legendrank is 1000, so that you can use ranks less
|
|
than 1000 to place certain items before all unranked items, and
|
|
ranks greater than 1000 to go after all unranked items.
|
|
|
|
The 'legendrank' property is a number and may be specified as:
|
|
- An int or float
|
|
|
|
Returns
|
|
-------
|
|
int|float
|
|
"""
|
|
return self["legendrank"]
|
|
|
|
@legendrank.setter
|
|
def legendrank(self, val):
|
|
self["legendrank"] = val
|
|
|
|
# meta
|
|
# ----
|
|
@property
|
|
def meta(self):
|
|
"""
|
|
Assigns extra meta information associated with this trace that
|
|
can be used in various text attributes. Attributes such as
|
|
trace `name`, graph, axis and colorbar `title.text`, annotation
|
|
`text` `rangeselector`, `updatemenues` and `sliders` `label`
|
|
text all support `meta`. To access the trace `meta` values in
|
|
an attribute in the same trace, simply use `%{meta[i]}` where
|
|
`i` is the index or key of the `meta` item in question. To
|
|
access trace `meta` in layout attributes, use
|
|
`%{data[n[.meta[i]}` where `i` is the index or key of the
|
|
`meta` and `n` is the trace index.
|
|
|
|
The 'meta' property accepts values of any type
|
|
|
|
Returns
|
|
-------
|
|
Any|numpy.ndarray
|
|
"""
|
|
return self["meta"]
|
|
|
|
@meta.setter
|
|
def meta(self, val):
|
|
self["meta"] = val
|
|
|
|
# metasrc
|
|
# -------
|
|
@property
|
|
def metasrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `meta`.
|
|
|
|
The 'metasrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["metasrc"]
|
|
|
|
@metasrc.setter
|
|
def metasrc(self, val):
|
|
self["metasrc"] = val
|
|
|
|
# mode
|
|
# ----
|
|
@property
|
|
def mode(self):
|
|
"""
|
|
Determines how the value is displayed on the graph. `number`
|
|
displays the value numerically in text. `delta` displays the
|
|
difference to a reference value in text. Finally, `gauge`
|
|
displays the value graphically on an axis.
|
|
|
|
The 'mode' property is a flaglist and may be specified
|
|
as a string containing:
|
|
- Any combination of ['number', 'delta', 'gauge'] joined with '+' characters
|
|
(e.g. 'number+delta')
|
|
|
|
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
|
|
|
|
# number
|
|
# ------
|
|
@property
|
|
def number(self):
|
|
"""
|
|
The 'number' property is an instance of Number
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.indicator.Number`
|
|
- A dict of string/value properties that will be passed
|
|
to the Number constructor
|
|
|
|
Supported dict properties:
|
|
|
|
font
|
|
Set the font used to display main number
|
|
prefix
|
|
Sets a prefix appearing before the number.
|
|
suffix
|
|
Sets a suffix appearing next to the number.
|
|
valueformat
|
|
Sets the value 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/tree/v1.4.5#d3-f
|
|
ormat.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.indicator.Number
|
|
"""
|
|
return self["number"]
|
|
|
|
@number.setter
|
|
def number(self, val):
|
|
self["number"] = val
|
|
|
|
# stream
|
|
# ------
|
|
@property
|
|
def stream(self):
|
|
"""
|
|
The 'stream' property is an instance of Stream
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.indicator.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://chart-
|
|
studio.plotly.com/settings for more details.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.indicator.Stream
|
|
"""
|
|
return self["stream"]
|
|
|
|
@stream.setter
|
|
def stream(self, val):
|
|
self["stream"] = val
|
|
|
|
# title
|
|
# -----
|
|
@property
|
|
def title(self):
|
|
"""
|
|
The 'title' property is an instance of Title
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.indicator.Title`
|
|
- A dict of string/value properties that will be passed
|
|
to the Title constructor
|
|
|
|
Supported dict properties:
|
|
|
|
align
|
|
Sets the horizontal alignment of the title. It
|
|
defaults to `center` except for bullet charts
|
|
for which it defaults to right.
|
|
font
|
|
Set the font used to display the title
|
|
text
|
|
Sets the title of this indicator.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.indicator.Title
|
|
"""
|
|
return self["title"]
|
|
|
|
@title.setter
|
|
def title(self, val):
|
|
self["title"] = val
|
|
|
|
# uid
|
|
# ---
|
|
@property
|
|
def uid(self):
|
|
"""
|
|
Assign an id to this trace, Use this to provide object
|
|
constancy between traces during animations and transitions.
|
|
|
|
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
|
|
|
|
# uirevision
|
|
# ----------
|
|
@property
|
|
def uirevision(self):
|
|
"""
|
|
Controls persistence of some user-driven changes to the trace:
|
|
`constraintrange` in `parcoords` traces, as well as some
|
|
`editable: true` modifications such as `name` and
|
|
`colorbar.title`. Defaults to `layout.uirevision`. Note that
|
|
other user-driven trace attribute changes are controlled by
|
|
`layout` attributes: `trace.visible` is controlled by
|
|
`layout.legend.uirevision`, `selectedpoints` is controlled by
|
|
`layout.selectionrevision`, and `colorbar.(x|y)` (accessible
|
|
with `config: {editable: true}`) is controlled by
|
|
`layout.editrevision`. Trace changes are tracked by `uid`,
|
|
which only falls back on trace index if no `uid` is provided.
|
|
So if your app can add/remove traces before the end of the
|
|
`data` array, such that the same trace has a different index,
|
|
you can still preserve user-driven changes if you give each
|
|
trace a `uid` that stays with it as it moves.
|
|
|
|
The 'uirevision' property accepts values of any type
|
|
|
|
Returns
|
|
-------
|
|
Any
|
|
"""
|
|
return self["uirevision"]
|
|
|
|
@uirevision.setter
|
|
def uirevision(self, val):
|
|
self["uirevision"] = val
|
|
|
|
# value
|
|
# -----
|
|
@property
|
|
def value(self):
|
|
"""
|
|
Sets the number to be displayed.
|
|
|
|
The 'value' property is a number and may be specified as:
|
|
- An int or float
|
|
|
|
Returns
|
|
-------
|
|
int|float
|
|
"""
|
|
return self["value"]
|
|
|
|
@value.setter
|
|
def value(self, val):
|
|
self["value"] = 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"]
|
|
|
|
# Self properties description
|
|
# ---------------------------
|
|
@property
|
|
def _prop_descriptions(self):
|
|
return """\
|
|
align
|
|
Sets the horizontal alignment of the `text` within the
|
|
box. Note that this attribute has no effect if an
|
|
angular gauge is displayed: in this case, it is always
|
|
centered
|
|
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 Chart Studio Cloud for
|
|
`customdata`.
|
|
delta
|
|
:class:`plotly.graph_objects.indicator.Delta` instance
|
|
or dict with compatible properties
|
|
domain
|
|
:class:`plotly.graph_objects.indicator.Domain` instance
|
|
or dict with compatible properties
|
|
gauge
|
|
The gauge of the Indicator plot.
|
|
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 Chart Studio Cloud for
|
|
`ids`.
|
|
legendgrouptitle
|
|
:class:`plotly.graph_objects.indicator.Legendgrouptitle
|
|
` instance or dict with compatible properties
|
|
legendrank
|
|
Sets the legend rank for this trace. Items and groups
|
|
with smaller ranks are presented on top/left side while
|
|
with `*reversed* `legend.traceorder` they are on
|
|
bottom/right side. The default legendrank is 1000, so
|
|
that you can use ranks less than 1000 to place certain
|
|
items before all unranked items, and ranks greater than
|
|
1000 to go after all unranked items.
|
|
meta
|
|
Assigns extra meta information associated with this
|
|
trace that can be used in various text attributes.
|
|
Attributes such as trace `name`, graph, axis and
|
|
colorbar `title.text`, annotation `text`
|
|
`rangeselector`, `updatemenues` and `sliders` `label`
|
|
text all support `meta`. To access the trace `meta`
|
|
values in an attribute in the same trace, simply use
|
|
`%{meta[i]}` where `i` is the index or key of the
|
|
`meta` item in question. To access trace `meta` in
|
|
layout attributes, use `%{data[n[.meta[i]}` where `i`
|
|
is the index or key of the `meta` and `n` is the trace
|
|
index.
|
|
metasrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`meta`.
|
|
mode
|
|
Determines how the value is displayed on the graph.
|
|
`number` displays the value numerically in text.
|
|
`delta` displays the difference to a reference value in
|
|
text. Finally, `gauge` displays the value graphically
|
|
on an axis.
|
|
name
|
|
Sets the trace name. The trace name appear as the
|
|
legend item and on hover.
|
|
number
|
|
:class:`plotly.graph_objects.indicator.Number` instance
|
|
or dict with compatible properties
|
|
stream
|
|
:class:`plotly.graph_objects.indicator.Stream` instance
|
|
or dict with compatible properties
|
|
title
|
|
:class:`plotly.graph_objects.indicator.Title` instance
|
|
or dict with compatible properties
|
|
uid
|
|
Assign an id to this trace, Use this to provide object
|
|
constancy between traces during animations and
|
|
transitions.
|
|
uirevision
|
|
Controls persistence of some user-driven changes to the
|
|
trace: `constraintrange` in `parcoords` traces, as well
|
|
as some `editable: true` modifications such as `name`
|
|
and `colorbar.title`. Defaults to `layout.uirevision`.
|
|
Note that other user-driven trace attribute changes are
|
|
controlled by `layout` attributes: `trace.visible` is
|
|
controlled by `layout.legend.uirevision`,
|
|
`selectedpoints` is controlled by
|
|
`layout.selectionrevision`, and `colorbar.(x|y)`
|
|
(accessible with `config: {editable: true}`) is
|
|
controlled by `layout.editrevision`. Trace changes are
|
|
tracked by `uid`, which only falls back on trace index
|
|
if no `uid` is provided. So if your app can add/remove
|
|
traces before the end of the `data` array, such that
|
|
the same trace has a different index, you can still
|
|
preserve user-driven changes if you give each trace a
|
|
`uid` that stays with it as it moves.
|
|
value
|
|
Sets the number to be displayed.
|
|
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,
|
|
align=None,
|
|
customdata=None,
|
|
customdatasrc=None,
|
|
delta=None,
|
|
domain=None,
|
|
gauge=None,
|
|
ids=None,
|
|
idssrc=None,
|
|
legendgrouptitle=None,
|
|
legendrank=None,
|
|
meta=None,
|
|
metasrc=None,
|
|
mode=None,
|
|
name=None,
|
|
number=None,
|
|
stream=None,
|
|
title=None,
|
|
uid=None,
|
|
uirevision=None,
|
|
value=None,
|
|
visible=None,
|
|
**kwargs,
|
|
):
|
|
"""
|
|
Construct a new Indicator object
|
|
|
|
An indicator is used to visualize a single `value` along with
|
|
some contextual information such as `steps` or a `threshold`,
|
|
using a combination of three visual elements: a number, a
|
|
delta, and/or a gauge. Deltas are taken with respect to a
|
|
`reference`. Gauges can be either angular or bullet (aka
|
|
linear) gauges.
|
|
|
|
Parameters
|
|
----------
|
|
arg
|
|
dict of properties compatible with this constructor or
|
|
an instance of :class:`plotly.graph_objs.Indicator`
|
|
align
|
|
Sets the horizontal alignment of the `text` within the
|
|
box. Note that this attribute has no effect if an
|
|
angular gauge is displayed: in this case, it is always
|
|
centered
|
|
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 Chart Studio Cloud for
|
|
`customdata`.
|
|
delta
|
|
:class:`plotly.graph_objects.indicator.Delta` instance
|
|
or dict with compatible properties
|
|
domain
|
|
:class:`plotly.graph_objects.indicator.Domain` instance
|
|
or dict with compatible properties
|
|
gauge
|
|
The gauge of the Indicator plot.
|
|
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 Chart Studio Cloud for
|
|
`ids`.
|
|
legendgrouptitle
|
|
:class:`plotly.graph_objects.indicator.Legendgrouptitle
|
|
` instance or dict with compatible properties
|
|
legendrank
|
|
Sets the legend rank for this trace. Items and groups
|
|
with smaller ranks are presented on top/left side while
|
|
with `*reversed* `legend.traceorder` they are on
|
|
bottom/right side. The default legendrank is 1000, so
|
|
that you can use ranks less than 1000 to place certain
|
|
items before all unranked items, and ranks greater than
|
|
1000 to go after all unranked items.
|
|
meta
|
|
Assigns extra meta information associated with this
|
|
trace that can be used in various text attributes.
|
|
Attributes such as trace `name`, graph, axis and
|
|
colorbar `title.text`, annotation `text`
|
|
`rangeselector`, `updatemenues` and `sliders` `label`
|
|
text all support `meta`. To access the trace `meta`
|
|
values in an attribute in the same trace, simply use
|
|
`%{meta[i]}` where `i` is the index or key of the
|
|
`meta` item in question. To access trace `meta` in
|
|
layout attributes, use `%{data[n[.meta[i]}` where `i`
|
|
is the index or key of the `meta` and `n` is the trace
|
|
index.
|
|
metasrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`meta`.
|
|
mode
|
|
Determines how the value is displayed on the graph.
|
|
`number` displays the value numerically in text.
|
|
`delta` displays the difference to a reference value in
|
|
text. Finally, `gauge` displays the value graphically
|
|
on an axis.
|
|
name
|
|
Sets the trace name. The trace name appear as the
|
|
legend item and on hover.
|
|
number
|
|
:class:`plotly.graph_objects.indicator.Number` instance
|
|
or dict with compatible properties
|
|
stream
|
|
:class:`plotly.graph_objects.indicator.Stream` instance
|
|
or dict with compatible properties
|
|
title
|
|
:class:`plotly.graph_objects.indicator.Title` instance
|
|
or dict with compatible properties
|
|
uid
|
|
Assign an id to this trace, Use this to provide object
|
|
constancy between traces during animations and
|
|
transitions.
|
|
uirevision
|
|
Controls persistence of some user-driven changes to the
|
|
trace: `constraintrange` in `parcoords` traces, as well
|
|
as some `editable: true` modifications such as `name`
|
|
and `colorbar.title`. Defaults to `layout.uirevision`.
|
|
Note that other user-driven trace attribute changes are
|
|
controlled by `layout` attributes: `trace.visible` is
|
|
controlled by `layout.legend.uirevision`,
|
|
`selectedpoints` is controlled by
|
|
`layout.selectionrevision`, and `colorbar.(x|y)`
|
|
(accessible with `config: {editable: true}`) is
|
|
controlled by `layout.editrevision`. Trace changes are
|
|
tracked by `uid`, which only falls back on trace index
|
|
if no `uid` is provided. So if your app can add/remove
|
|
traces before the end of the `data` array, such that
|
|
the same trace has a different index, you can still
|
|
preserve user-driven changes if you give each trace a
|
|
`uid` that stays with it as it moves.
|
|
value
|
|
Sets the number to be displayed.
|
|
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
|
|
-------
|
|
Indicator
|
|
"""
|
|
super(Indicator, self).__init__("indicator")
|
|
|
|
if "_parent" in kwargs:
|
|
self._parent = kwargs["_parent"]
|
|
return
|
|
|
|
# Validate arg
|
|
# ------------
|
|
if arg is None:
|
|
arg = {}
|
|
elif isinstance(arg, self.__class__):
|
|
arg = arg.to_plotly_json()
|
|
elif isinstance(arg, dict):
|
|
arg = _copy.copy(arg)
|
|
else:
|
|
raise ValueError(
|
|
"""\
|
|
The first argument to the plotly.graph_objs.Indicator
|
|
constructor must be a dict or
|
|
an instance of :class:`plotly.graph_objs.Indicator`"""
|
|
)
|
|
|
|
# Handle skip_invalid
|
|
# -------------------
|
|
self._skip_invalid = kwargs.pop("skip_invalid", False)
|
|
self._validate = kwargs.pop("_validate", True)
|
|
|
|
# Populate data dict with properties
|
|
# ----------------------------------
|
|
_v = arg.pop("align", None)
|
|
_v = align if align is not None else _v
|
|
if _v is not None:
|
|
self["align"] = _v
|
|
_v = arg.pop("customdata", None)
|
|
_v = customdata if customdata is not None else _v
|
|
if _v is not None:
|
|
self["customdata"] = _v
|
|
_v = arg.pop("customdatasrc", None)
|
|
_v = customdatasrc if customdatasrc is not None else _v
|
|
if _v is not None:
|
|
self["customdatasrc"] = _v
|
|
_v = arg.pop("delta", None)
|
|
_v = delta if delta is not None else _v
|
|
if _v is not None:
|
|
self["delta"] = _v
|
|
_v = arg.pop("domain", None)
|
|
_v = domain if domain is not None else _v
|
|
if _v is not None:
|
|
self["domain"] = _v
|
|
_v = arg.pop("gauge", None)
|
|
_v = gauge if gauge is not None else _v
|
|
if _v is not None:
|
|
self["gauge"] = _v
|
|
_v = arg.pop("ids", None)
|
|
_v = ids if ids is not None else _v
|
|
if _v is not None:
|
|
self["ids"] = _v
|
|
_v = arg.pop("idssrc", None)
|
|
_v = idssrc if idssrc is not None else _v
|
|
if _v is not None:
|
|
self["idssrc"] = _v
|
|
_v = arg.pop("legendgrouptitle", None)
|
|
_v = legendgrouptitle if legendgrouptitle is not None else _v
|
|
if _v is not None:
|
|
self["legendgrouptitle"] = _v
|
|
_v = arg.pop("legendrank", None)
|
|
_v = legendrank if legendrank is not None else _v
|
|
if _v is not None:
|
|
self["legendrank"] = _v
|
|
_v = arg.pop("meta", None)
|
|
_v = meta if meta is not None else _v
|
|
if _v is not None:
|
|
self["meta"] = _v
|
|
_v = arg.pop("metasrc", None)
|
|
_v = metasrc if metasrc is not None else _v
|
|
if _v is not None:
|
|
self["metasrc"] = _v
|
|
_v = arg.pop("mode", None)
|
|
_v = mode if mode is not None else _v
|
|
if _v is not None:
|
|
self["mode"] = _v
|
|
_v = arg.pop("name", None)
|
|
_v = name if name is not None else _v
|
|
if _v is not None:
|
|
self["name"] = _v
|
|
_v = arg.pop("number", None)
|
|
_v = number if number is not None else _v
|
|
if _v is not None:
|
|
self["number"] = _v
|
|
_v = arg.pop("stream", None)
|
|
_v = stream if stream is not None else _v
|
|
if _v is not None:
|
|
self["stream"] = _v
|
|
_v = arg.pop("title", None)
|
|
_v = title if title is not None else _v
|
|
if _v is not None:
|
|
self["title"] = _v
|
|
_v = arg.pop("uid", None)
|
|
_v = uid if uid is not None else _v
|
|
if _v is not None:
|
|
self["uid"] = _v
|
|
_v = arg.pop("uirevision", None)
|
|
_v = uirevision if uirevision is not None else _v
|
|
if _v is not None:
|
|
self["uirevision"] = _v
|
|
_v = arg.pop("value", None)
|
|
_v = value if value is not None else _v
|
|
if _v is not None:
|
|
self["value"] = _v
|
|
_v = arg.pop("visible", None)
|
|
_v = visible if visible is not None else _v
|
|
if _v is not None:
|
|
self["visible"] = _v
|
|
|
|
# Read-only literals
|
|
# ------------------
|
|
|
|
self._props["type"] = "indicator"
|
|
arg.pop("type", None)
|
|
|
|
# Process unknown kwargs
|
|
# ----------------------
|
|
self._process_kwargs(**dict(arg, **kwargs))
|
|
|
|
# Reset skip_invalid
|
|
# ------------------
|
|
self._skip_invalid = False
|