_sunburst.py

fromplotly.basedatatypesimportBaseTraceTypeas_BaseTraceType
importcopyas_copy


classSunburst(_BaseTraceType):

# class properties
# --------------------
_parent_path_str=""
_path_str="sunburst"
_valid_props= {
"branchvalues",
"count",
"customdata",
"customdatasrc",
"domain",
"hoverinfo",
"hoverinfosrc",
"hoverlabel",
"hovertemplate",
"hovertemplatesrc",
"hovertext",
"hovertextsrc",
"ids",
"idssrc",
"insidetextfont",
"insidetextorientation",
"labels",
"labelssrc",
"leaf",
"legend",
"legendgrouptitle",
"legendrank",
"legendwidth",
"level",
"marker",
"maxdepth",
"meta",
"metasrc",
"name",
"opacity",
"outsidetextfont",
"parents",
"parentssrc",
"root",
"rotation",
"sort",
"stream",
"text",
"textfont",
"textinfo",
"textsrc",
"texttemplate",
"texttemplatesrc",
"type",
"uid",
"uirevision",
"values",
"valuessrc",
"visible",
 }

# branchvalues
# ------------
@property
defbranchvalues(self):
"""
 Determines how the items in `values` are summed. When set to
 "total", items in `values` are taken to be value of all its
 descendants. When set to "remainder", items in `values`
 corresponding to the root and the branches sectors are taken to
 be the extra part not part of the sum of the values at their
 leaves.

 The 'branchvalues' property is an enumeration that may be specified as:
 - One of the following enumeration values:
 ['remainder', 'total']

 Returns
 -------
 Any
 """
returnself["branchvalues"]

@branchvalues.setter
defbranchvalues(self, val):
self["branchvalues"] =val

# count
# -----
@property
defcount(self):
"""
 Determines default for `values` when it is not provided, by
 inferring a 1 for each of the "leaves" and/or "branches",
 otherwise 0.

 The 'count' property is a flaglist and may be specified
 as a string containing:
 - Any combination of ['branches', 'leaves'] joined with '+' characters
 (e.g. 'branches+leaves')

 Returns
 -------
 Any
 """
returnself["count"]

@count.setter
defcount(self, val):
self["count"] =val

# customdata
# ----------
@property
defcustomdata(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
 """
returnself["customdata"]

@customdata.setter
defcustomdata(self, val):
self["customdata"] =val

# customdatasrc
# -------------
@property
defcustomdatasrc(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
 """
returnself["customdatasrc"]

@customdatasrc.setter
defcustomdatasrc(self, val):
self["customdatasrc"] =val

# domain
# ------
@property
defdomain(self):
"""
 The 'domain' property is an instance of Domain
 that may be specified as:
 - An instance of :class:`plotly.graph_objs.sunburst.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 sunburst trace
 .
 row
 If there is a layout grid, use the domain for
 this row in the grid for this sunburst trace .
 x
 Sets the horizontal domain of this sunburst
 trace (in plot fraction).
 y
 Sets the vertical domain of this sunburst trace
 (in plot fraction).

 Returns
 -------
 plotly.graph_objs.sunburst.Domain
 """
returnself["domain"]

@domain.setter
defdomain(self, val):
self["domain"] =val

# hoverinfo
# ---------
@property
defhoverinfo(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', 'name', 'current path', 'percent root', 'percent entry', 'percent parent'] 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
 """
returnself["hoverinfo"]

@hoverinfo.setter
defhoverinfo(self, val):
self["hoverinfo"] =val

# hoverinfosrc
# ------------
@property
defhoverinfosrc(self):
"""
 Sets the source reference on Chart Studio Cloud for
 `hoverinfo`.

 The 'hoverinfosrc' property must be specified as a string or
 as a plotly.grid_objs.Column object

 Returns
 -------
 str
 """
returnself["hoverinfosrc"]

@hoverinfosrc.setter
defhoverinfosrc(self, val):
self["hoverinfosrc"] =val

# hoverlabel
# ----------
@property
defhoverlabel(self):
"""
 The 'hoverlabel' property is an instance of Hoverlabel
 that may be specified as:
 - An instance of :class:`plotly.graph_objs.sunburst.Hoverlabel`
 - A dict of string/value properties that will be passed
 to the Hoverlabel constructor

 Supported dict properties:

 align
 Sets the horizontal alignment of the text
 content within hover label box. Has an effect
 only if the hover label text spans more two or
 more lines
 alignsrc
 Sets the source reference on Chart Studio Cloud
 for `align`.
 bgcolor
 Sets the background color of the hover labels
 for this trace
 bgcolorsrc
 Sets the source reference on Chart Studio Cloud
 for `bgcolor`.
 bordercolor
 Sets the border color of the hover labels for
 this trace.
 bordercolorsrc
 Sets the source reference on Chart Studio Cloud
 for `bordercolor`.
 font
 Sets the font used in hover labels.
 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.
 namelengthsrc
 Sets the source reference on Chart Studio Cloud
 for `namelength`.

 Returns
 -------
 plotly.graph_objs.sunburst.Hoverlabel
 """
returnself["hoverlabel"]

@hoverlabel.setter
defhoverlabel(self, val):
self["hoverlabel"] =val

# hovertemplate
# -------------
@property
defhovertemplate(self):
"""
 Template string used for rendering the information that appear
 on hover box. Note that this will override `hoverinfo`.
 Variables are inserted using %{variable}, for example "y: %{y}"
 as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When
 showing info for several points, "xother" will be added to
 those with different x positions from the first point. An
 underscore before or after "(x|y)other" will add a space on
 that side, only when this field is shown. Numbers are formatted
 using d3-format's syntax %{variable:d3-format}, for example
 "Price: %{y:$.2f}".
 https://github.com/d3/d3-format/tree/v1.4.5#d3-format for
 details on the formatting syntax. Dates are formatted using
 d3-time-format's syntax %{variable|d3-time-format}, for example
 "Day: %{2019-01-01|%A}". https://github.com/d3/d3-time-
 format/tree/v2.2.3#locale_format for details on the date
 formatting syntax. The variables available in `hovertemplate`
 are the ones emitted as event data described at this link
 https://plotly.com/javascript/plotlyjs-events/#event-data.
 Additionally, every attributes that can be specified per-point
 (the ones that are `arrayOk: true`) are available. Finally, the
 template string has access to variables `currentPath`, `root`,
 `entry`, `percentRoot`, `percentEntry` and `percentParent`.
 Anything contained in tag `<extra>` is displayed in the
 secondary box, for example "<extra>{fullData.name}</extra>". To
 hide the secondary box completely, use an empty tag
 `<extra></extra>`.

 The 'hovertemplate' 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
 """
returnself["hovertemplate"]

@hovertemplate.setter
defhovertemplate(self, val):
self["hovertemplate"] =val

# hovertemplatesrc
# ----------------
@property
defhovertemplatesrc(self):
"""
 Sets the source reference on Chart Studio Cloud for
 `hovertemplate`.

 The 'hovertemplatesrc' property must be specified as a string or
 as a plotly.grid_objs.Column object

 Returns
 -------
 str
 """
returnself["hovertemplatesrc"]

@hovertemplatesrc.setter
defhovertemplatesrc(self, val):
self["hovertemplatesrc"] =val

# hovertext
# ---------
@property
defhovertext(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
 """
returnself["hovertext"]

@hovertext.setter
defhovertext(self, val):
self["hovertext"] =val

# hovertextsrc
# ------------
@property
defhovertextsrc(self):
"""
 Sets the source reference on Chart Studio Cloud for
 `hovertext`.

 The 'hovertextsrc' property must be specified as a string or
 as a plotly.grid_objs.Column object

 Returns
 -------
 str
 """
returnself["hovertextsrc"]

@hovertextsrc.setter
defhovertextsrc(self, val):
self["hovertextsrc"] =val

# ids
# ---
@property
defids(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
 """
returnself["ids"]

@ids.setter
defids(self, val):
self["ids"] =val

# idssrc
# ------
@property
defidssrc(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
 """
returnself["idssrc"]

@idssrc.setter
defidssrc(self, val):
self["idssrc"] =val

# insidetextfont
# --------------
@property
definsidetextfont(self):
"""
 Sets the font used for `textinfo` lying inside the sector.

 The 'insidetextfont' property is an instance of Insidetextfont
 that may be specified as:
 - An instance of :class:`plotly.graph_objs.sunburst.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 Chart Studio Cloud
 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 Chart Studio Cloud (at
 https://chart-studio.plotly.com or on-premise)
 generates images on a server, where only a
 select number of fonts are installed and
 supported. These include "Arial", "Balto",
 "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 Chart Studio Cloud
 for `family`.
 lineposition
 Sets the kind of decoration line(s) with text,
 such as an "under", "over" or "through" as well
 as combinations e.g. "under+over", etc.
 linepositionsrc
 Sets the source reference on Chart Studio Cloud
 for `lineposition`.
 shadow
 Sets the shape and color of the shadow behind
 text. "auto" places minimal shadow and applies
 contrast text font color. See
 https://developer.mozilla.org/en-
 US/docs/Web/CSS/text-shadow for additional
 options.
 shadowsrc
 Sets the source reference on Chart Studio Cloud
 for `shadow`.
 size

 sizesrc
 Sets the source reference on Chart Studio Cloud
 for `size`.
 style
 Sets whether a font should be styled with a
 normal or italic face from its family.
 stylesrc
 Sets the source reference on Chart Studio Cloud
 for `style`.
 textcase
 Sets capitalization of text. It can be used to
 make text appear in all-uppercase or all-
 lowercase, or with each word capitalized.
 textcasesrc
 Sets the source reference on Chart Studio Cloud
 for `textcase`.
 variant
 Sets the variant of the font.
 variantsrc
 Sets the source reference on Chart Studio Cloud
 for `variant`.
 weight
 Sets the weight (or boldness) of the font.
 weightsrc
 Sets the source reference on Chart Studio Cloud
 for `weight`.

 Returns
 -------
 plotly.graph_objs.sunburst.Insidetextfont
 """
returnself["insidetextfont"]

@insidetextfont.setter
definsidetextfont(self, val):
self["insidetextfont"] =val

# insidetextorientation
# ---------------------
@property
definsidetextorientation(self):
"""
 Controls the orientation of the text inside chart sectors. When
 set to "auto", text may be oriented in any direction in order
 to be as big as possible in the middle of a sector. The
 "horizontal" option orients text to be parallel with the bottom
 of the chart, and may make text smaller in order to achieve
 that goal. The "radial" option orients text along the radius of
 the sector. The "tangential" option orients text perpendicular
 to the radius of the sector.

 The 'insidetextorientation' property is an enumeration that may be specified as:
 - One of the following enumeration values:
 ['horizontal', 'radial', 'tangential', 'auto']

 Returns
 -------
 Any
 """
returnself["insidetextorientation"]

@insidetextorientation.setter
definsidetextorientation(self, val):
self["insidetextorientation"] =val

# labels
# ------
@property
deflabels(self):
"""
 Sets the labels of each of the sectors.

 The 'labels' property is an array that may be specified as a tuple,
 list, numpy array, or pandas Series

 Returns
 -------
 numpy.ndarray
 """
returnself["labels"]

@labels.setter
deflabels(self, val):
self["labels"] =val

# labelssrc
# ---------
@property
deflabelssrc(self):
"""
 Sets the source reference on Chart Studio Cloud for `labels`.

 The 'labelssrc' property must be specified as a string or
 as a plotly.grid_objs.Column object

 Returns
 -------
 str
 """
returnself["labelssrc"]

@labelssrc.setter
deflabelssrc(self, val):
self["labelssrc"] =val

# leaf
# ----
@property
defleaf(self):
"""
 The 'leaf' property is an instance of Leaf
 that may be specified as:
 - An instance of :class:`plotly.graph_objs.sunburst.Leaf`
 - A dict of string/value properties that will be passed
 to the Leaf constructor

 Supported dict properties:

 opacity
 Sets the opacity of the leaves. With colorscale
 it is defaulted to 1; otherwise it is defaulted
 to 0.7

 Returns
 -------
 plotly.graph_objs.sunburst.Leaf
 """
returnself["leaf"]

@leaf.setter
defleaf(self, val):
self["leaf"] =val

# legend
# ------
@property
deflegend(self):
"""
 Sets the reference to a legend to show this trace in.
 References to these legends are "legend", "legend2", "legend3",
 etc. Settings for these legends are set in the layout, under
 `layout.legend`, `layout.legend2`, etc.

 The 'legend' property is an identifier of a particular
 subplot, of type 'legend', that may be specified as the string 'legend'
 optionally followed by an integer >= 1
 (e.g. 'legend', 'legend1', 'legend2', 'legend3', etc.)

 Returns
 -------
 str
 """
returnself["legend"]

@legend.setter
deflegend(self, val):
self["legend"] =val

# legendgrouptitle
# ----------------
@property
deflegendgrouptitle(self):
"""
 The 'legendgrouptitle' property is an instance of Legendgrouptitle
 that may be specified as:
 - An instance of :class:`plotly.graph_objs.sunburst.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.sunburst.Legendgrouptitle
 """
returnself["legendgrouptitle"]

@legendgrouptitle.setter
deflegendgrouptitle(self, val):
self["legendgrouptitle"] =val

# legendrank
# ----------
@property
deflegendrank(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. When
 having unranked or equal rank items shapes would be displayed
 after traces i.e. according to their order in data and layout.

 The 'legendrank' property is a number and may be specified as:
 - An int or float

 Returns
 -------
 int|float
 """
returnself["legendrank"]

@legendrank.setter
deflegendrank(self, val):
self["legendrank"] =val

# legendwidth
# -----------
@property
deflegendwidth(self):
"""
 Sets the width (in px or fraction) of the legend for this
 trace.

 The 'legendwidth' property is a number and may be specified as:
 - An int or float in the interval [0, inf]

 Returns
 -------
 int|float
 """
returnself["legendwidth"]

@legendwidth.setter
deflegendwidth(self, val):
self["legendwidth"] =val

# level
# -----
@property
deflevel(self):
"""
 Sets the level from which this trace hierarchy is rendered. Set
 `level` to `''` to start from the root node in the hierarchy.
 Must be an "id" if `ids` is filled in, otherwise plotly
 attempts to find a matching item in `labels`.

 The 'level' property accepts values of any type

 Returns
 -------
 Any
 """
returnself["level"]

@level.setter
deflevel(self, val):
self["level"] =val

# marker
# ------
@property
defmarker(self):
"""
 The 'marker' property is an instance of Marker
 that may be specified as:
 - An instance of :class:`plotly.graph_objs.sunburst.Marker`
 - A dict of string/value properties that will be passed
 to the Marker constructor

 Supported dict properties:

 autocolorscale
 Determines whether the colorscale is a default
 palette (`autocolorscale: true`) or the palette
 determined by `marker.colorscale`. Has an
 effect only if colors is set to a numerical
 array. 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
 Determines whether or not the color domain is
 computed with respect to the input data (here
 colors) or the bounds set in `marker.cmin` and
 `marker.cmax` Has an effect only if colors is
 set to a numerical array. Defaults to `false`
 when `marker.cmin` and `marker.cmax` are set by
 the user.
 cmax
 Sets the upper bound of the color domain. Has
 an effect only if colors is set to a numerical
 array. Value should have the same units as
 colors and if set, `marker.cmin` must be set as
 well.
 cmid
 Sets the mid-point of the color domain by
 scaling `marker.cmin` and/or `marker.cmax` to
 be equidistant to this point. Has an effect
 only if colors is set to a numerical array.
 Value should have the same units as colors. Has
 no effect when `marker.cauto` is `false`.
 cmin
 Sets the lower bound of the color domain. Has
 an effect only if colors is set to a numerical
 array. Value should have the same units as
 colors and if set, `marker.cmax` must be set as
 well.
 coloraxis
 Sets a reference to a shared color axis.
 References to these shared color axes are
 "coloraxis", "coloraxis2", "coloraxis3", etc.
 Settings for these shared color axes are set in
 the layout, under `layout.coloraxis`,
 `layout.coloraxis2`, etc. Note that multiple
 color scales can be linked to the same color
 axis.
 colorbar
 :class:`plotly.graph_objects.sunburst.marker.Co
 lorBar` instance or dict with compatible
 properties
 colors
 Sets the color of each sector of this trace. If
 not specified, the default trace color set is
 used to pick the sector colors.
 colorscale
 Sets the colorscale. Has an effect only if
 colors 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:
 Blackbody,Bluered,Blues,Cividis,Earth,Electric,
 Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,Rd
 Bu,Reds,Viridis,YlGnBu,YlOrRd.
 colorssrc
 Sets the source reference on Chart Studio Cloud
 for `colors`.
 line
 :class:`plotly.graph_objects.sunburst.marker.Li
 ne` instance or dict with compatible properties
 pattern
 Sets the pattern within the marker.
 reversescale
 Reverses the color mapping if true. Has an
 effect only if colors is set to a numerical
 array. If true, `marker.cmin` will correspond
 to the last color in the array and
 `marker.cmax` will correspond to the first
 color.
 showscale
 Determines whether or not a colorbar is
 displayed for this trace. Has an effect only if
 colors is set to a numerical array.

 Returns
 -------
 plotly.graph_objs.sunburst.Marker
 """
returnself["marker"]

@marker.setter
defmarker(self, val):
self["marker"] =val

# maxdepth
# --------
@property
defmaxdepth(self):
"""
 Sets the number of rendered sectors from any given `level`. Set
 `maxdepth` to "-1" to render all the levels in the hierarchy.

 The 'maxdepth' property is a integer and may be specified as:
 - An int (or float that will be cast to an int)

 Returns
 -------
 int
 """
returnself["maxdepth"]

@maxdepth.setter
defmaxdepth(self, val):
self["maxdepth"] =val

# meta
# ----
@property
defmeta(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
 """
returnself["meta"]

@meta.setter
defmeta(self, val):
self["meta"] =val

# metasrc
# -------
@property
defmetasrc(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
 """
returnself["metasrc"]

@metasrc.setter
defmetasrc(self, val):
self["metasrc"] =val

# name
# ----
@property
defname(self):
"""
 Sets the trace name. The trace name appears 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
 """
returnself["name"]

@name.setter
defname(self, val):
self["name"] =val

# opacity
# -------
@property
defopacity(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
 """
returnself["opacity"]

@opacity.setter
defopacity(self, val):
self["opacity"] =val

# outsidetextfont
# ---------------
@property
defoutsidetextfont(self):
"""