Files

3508 lines
124 KiB
Python
Raw Permalink Normal View History

2025-09-07 22:09:54 +02:00
# --- THIS FILE IS AUTO-GENERATED ---
# Modifications will be overwitten the next time code generation run.
from plotly.basedatatypes import BaseLayoutType as _BaseLayoutType
import copy as _copy
class Layout(_BaseLayoutType):
_subplotid_prop_names = [
"coloraxis",
"geo",
"legend",
"map",
"mapbox",
"polar",
"scene",
"smith",
"ternary",
"xaxis",
"yaxis",
]
import re
_subplotid_prop_re = re.compile("^(" + "|".join(_subplotid_prop_names) + r")(\d+)$")
@property
def _subplotid_validators(self):
"""
dict of validator classes for each subplot type
Returns
-------
dict
"""
from plotly.validator_cache import ValidatorCache
return {
"coloraxis": ValidatorCache.get_validator("layout", "coloraxis"),
"geo": ValidatorCache.get_validator("layout", "geo"),
"legend": ValidatorCache.get_validator("layout", "legend"),
"map": ValidatorCache.get_validator("layout", "map"),
"mapbox": ValidatorCache.get_validator("layout", "mapbox"),
"polar": ValidatorCache.get_validator("layout", "polar"),
"scene": ValidatorCache.get_validator("layout", "scene"),
"smith": ValidatorCache.get_validator("layout", "smith"),
"ternary": ValidatorCache.get_validator("layout", "ternary"),
"xaxis": ValidatorCache.get_validator("layout", "xaxis"),
"yaxis": ValidatorCache.get_validator("layout", "yaxis"),
}
def _subplot_re_match(self, prop):
return self._subplotid_prop_re.match(prop)
_parent_path_str = ""
_path_str = "layout"
_valid_props = {
"activeselection",
"activeshape",
"annotationdefaults",
"annotations",
"autosize",
"autotypenumbers",
"barcornerradius",
"bargap",
"bargroupgap",
"barmode",
"barnorm",
"boxgap",
"boxgroupgap",
"boxmode",
"calendar",
"clickmode",
"coloraxis",
"colorscale",
"colorway",
"computed",
"datarevision",
"dragmode",
"editrevision",
"extendfunnelareacolors",
"extendiciclecolors",
"extendpiecolors",
"extendsunburstcolors",
"extendtreemapcolors",
"font",
"funnelareacolorway",
"funnelgap",
"funnelgroupgap",
"funnelmode",
"geo",
"grid",
"height",
"hiddenlabels",
"hiddenlabelssrc",
"hidesources",
"hoverdistance",
"hoverlabel",
"hovermode",
"hoversubplots",
"iciclecolorway",
"imagedefaults",
"images",
"legend",
"map",
"mapbox",
"margin",
"meta",
"metasrc",
"minreducedheight",
"minreducedwidth",
"modebar",
"newselection",
"newshape",
"paper_bgcolor",
"piecolorway",
"plot_bgcolor",
"polar",
"scattergap",
"scattermode",
"scene",
"selectdirection",
"selectiondefaults",
"selectionrevision",
"selections",
"separators",
"shapedefaults",
"shapes",
"showlegend",
"sliderdefaults",
"sliders",
"smith",
"spikedistance",
"sunburstcolorway",
"template",
"ternary",
"title",
"transition",
"treemapcolorway",
"uirevision",
"uniformtext",
"updatemenudefaults",
"updatemenus",
"violingap",
"violingroupgap",
"violinmode",
"waterfallgap",
"waterfallgroupgap",
"waterfallmode",
"width",
"xaxis",
"yaxis",
}
@property
def activeselection(self):
"""
The 'activeselection' property is an instance of Activeselection
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Activeselection`
- A dict of string/value properties that will be passed
to the Activeselection constructor
Returns
-------
plotly.graph_objs.layout.Activeselection
"""
return self["activeselection"]
@activeselection.setter
def activeselection(self, val):
self["activeselection"] = val
@property
def activeshape(self):
"""
The 'activeshape' property is an instance of Activeshape
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Activeshape`
- A dict of string/value properties that will be passed
to the Activeshape constructor
Returns
-------
plotly.graph_objs.layout.Activeshape
"""
return self["activeshape"]
@activeshape.setter
def activeshape(self, val):
self["activeshape"] = val
@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
Returns
-------
tuple[plotly.graph_objs.layout.Annotation]
"""
return self["annotations"]
@annotations.setter
def annotations(self, val):
self["annotations"] = val
@property
def annotationdefaults(self):
"""
When used in a template (as
layout.template.layout.annotationdefaults), sets the default
property values to use for elements of layout.annotations
The 'annotationdefaults' property is an instance of Annotation
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Annotation`
- A dict of string/value properties that will be passed
to the Annotation constructor
Returns
-------
plotly.graph_objs.layout.Annotation
"""
return self["annotationdefaults"]
@annotationdefaults.setter
def annotationdefaults(self, val):
self["annotationdefaults"] = val
@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
@property
def autotypenumbers(self):
"""
Using "strict" a numeric string in trace data is not converted
to a number. Using *convert types* a numeric string in trace
data may be treated as a number during automatic axis `type`
detection. This is the default value; however it could be
overridden for individual axes.
The 'autotypenumbers' property is an enumeration that may be specified as:
- One of the following enumeration values:
['convert types', 'strict']
Returns
-------
Any
"""
return self["autotypenumbers"]
@autotypenumbers.setter
def autotypenumbers(self, val):
self["autotypenumbers"] = val
@property
def barcornerradius(self):
"""
Sets the rounding of bar corners. May be an integer number of
pixels, or a percentage of bar width (as a string ending in %).
The 'barcornerradius' property accepts values of any type
Returns
-------
Any
"""
return self["barcornerradius"]
@barcornerradius.setter
def barcornerradius(self, val):
self["barcornerradius"] = val
@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
@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
@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 reduce
"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
@property
def barnorm(self):
"""
Sets the normalization for bar traces on the graph. With
"fraction", the value of each bar is divided by the sum of all
values at that location coordinate. "percent" is the same but
multiplied by 100 to show percentages.
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
@property
def boxgap(self):
"""
Sets the gap (in plot fraction) between boxes of adjacent
location coordinates. Has no effect on traces that have "width"
set.
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
@property
def boxgroupgap(self):
"""
Sets the gap (in plot fraction) between boxes of the same
location coordinate. Has no effect on traces that have "width"
set.
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
@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. Has no effect
on traces that have "width" set.
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
@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:
['chinese', 'coptic', 'discworld', 'ethiopian',
'gregorian', 'hebrew', 'islamic', 'jalali', 'julian',
'mayan', 'nanakshahi', 'nepali', 'persian', 'taiwan',
'thai', 'ummalqura']
Returns
-------
Any
"""
return self["calendar"]
@calendar.setter
def calendar(self, val):
self["calendar"] = val
@property
def clickmode(self):
"""
Determines the mode of single click interactions. "event" is
the default value and emits the `plotly_click` event. In
addition this mode emits the `plotly_selected` event in drag
modes "lasso" and "select", but with no event data attached
(kept for compatibility reasons). The "select" flag enables
selecting single data points via click. This mode also supports
persistent selections, meaning that pressing Shift while
clicking, adds to / subtracts from an existing selection.
"select" with `hovermode`: "x" can be confusing, consider
explicitly setting `hovermode`: "closest" when using this
feature. Selection events are sent accordingly as long as
"event" flag is set as well. When the "event" flag is missing,
`plotly_click` and `plotly_selected` events are not fired.
The 'clickmode' property is a flaglist and may be specified
as a string containing:
- Any combination of ['event', 'select'] joined with '+' characters
(e.g. 'event+select')
OR exactly one of ['none'] (e.g. 'none')
Returns
-------
Any
"""
return self["clickmode"]
@clickmode.setter
def clickmode(self, val):
self["clickmode"] = val
@property
def coloraxis(self):
"""
The 'coloraxis' property is an instance of Coloraxis
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Coloraxis`
- A dict of string/value properties that will be passed
to the Coloraxis constructor
Returns
-------
plotly.graph_objs.layout.Coloraxis
"""
return self["coloraxis"]
@coloraxis.setter
def coloraxis(self, val):
self["coloraxis"] = val
@property
def colorscale(self):
"""
The 'colorscale' property is an instance of Colorscale
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Colorscale`
- A dict of string/value properties that will be passed
to the Colorscale constructor
Returns
-------
plotly.graph_objs.layout.Colorscale
"""
return self["colorscale"]
@colorscale.setter
def colorscale(self, val):
self["colorscale"] = val
@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
@property
def computed(self):
"""
Placeholder for exporting automargin-impacting values namely
`margin.t`, `margin.b`, `margin.l` and `margin.r` in "full-
json" mode.
The 'computed' property accepts values of any type
Returns
-------
Any
"""
return self["computed"]
@computed.setter
def computed(self, val):
self["computed"] = val
@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
@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', 'drawclosedpath',
'drawopenpath', 'drawline', 'drawrect', 'drawcircle',
'orbit', 'turntable', False]
Returns
-------
Any
"""
return self["dragmode"]
@dragmode.setter
def dragmode(self, val):
self["dragmode"] = val
@property
def editrevision(self):
"""
Controls persistence of user-driven changes in `editable: true`
configuration, other than trace names and axis titles. Defaults
to `layout.uirevision`.
The 'editrevision' property accepts values of any type
Returns
-------
Any
"""
return self["editrevision"]
@editrevision.setter
def editrevision(self, val):
self["editrevision"] = val
@property
def extendfunnelareacolors(self):
"""
If `true`, the funnelarea slice colors (whether given by
`funnelareacolorway` or inherited from `colorway`) will be
extended to three times its original length by first repeating
every color 20% lighter then each color 20% darker. This is
intended to reduce the likelihood of reusing the same color
when you have many slices, but you can set `false` to disable.
Colors provided in the trace, using `marker.colors`, are never
extended.
The 'extendfunnelareacolors' property must be specified as a bool
(either True, or False)
Returns
-------
bool
"""
return self["extendfunnelareacolors"]
@extendfunnelareacolors.setter
def extendfunnelareacolors(self, val):
self["extendfunnelareacolors"] = val
@property
def extendiciclecolors(self):
"""
If `true`, the icicle slice colors (whether given by
`iciclecolorway` or inherited from `colorway`) will be extended
to three times its original length by first repeating every
color 20% lighter then each color 20% darker. This is intended
to reduce the likelihood of reusing the same color when you
have many slices, but you can set `false` to disable. Colors
provided in the trace, using `marker.colors`, are never
extended.
The 'extendiciclecolors' property must be specified as a bool
(either True, or False)
Returns
-------
bool
"""
return self["extendiciclecolors"]
@extendiciclecolors.setter
def extendiciclecolors(self, val):
self["extendiciclecolors"] = val
@property
def extendpiecolors(self):
"""
If `true`, the pie slice colors (whether given by `piecolorway`
or inherited from `colorway`) will be extended to three times
its original length by first repeating every color 20% lighter
then each color 20% darker. This is intended to reduce the
likelihood of reusing the same color when you have many slices,
but you can set `false` to disable. Colors provided in the
trace, using `marker.colors`, are never extended.
The 'extendpiecolors' property must be specified as a bool
(either True, or False)
Returns
-------
bool
"""
return self["extendpiecolors"]
@extendpiecolors.setter
def extendpiecolors(self, val):
self["extendpiecolors"] = val
@property
def extendsunburstcolors(self):
"""
If `true`, the sunburst slice colors (whether given by
`sunburstcolorway` or inherited from `colorway`) will be
extended to three times its original length by first repeating
every color 20% lighter then each color 20% darker. This is
intended to reduce the likelihood of reusing the same color
when you have many slices, but you can set `false` to disable.
Colors provided in the trace, using `marker.colors`, are never
extended.
The 'extendsunburstcolors' property must be specified as a bool
(either True, or False)
Returns
-------
bool
"""
return self["extendsunburstcolors"]
@extendsunburstcolors.setter
def extendsunburstcolors(self, val):
self["extendsunburstcolors"] = val
@property
def extendtreemapcolors(self):
"""
If `true`, the treemap slice colors (whether given by
`treemapcolorway` or inherited from `colorway`) will be
extended to three times its original length by first repeating
every color 20% lighter then each color 20% darker. This is
intended to reduce the likelihood of reusing the same color
when you have many slices, but you can set `false` to disable.
Colors provided in the trace, using `marker.colors`, are never
extended.
The 'extendtreemapcolors' property must be specified as a bool
(either True, or False)
Returns
-------
bool
"""
return self["extendtreemapcolors"]
@extendtreemapcolors.setter
def extendtreemapcolors(self, val):
self["extendtreemapcolors"] = val
@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 :class:`plotly.graph_objs.layout.Font`
- A dict of string/value properties that will be passed
to the Font constructor
Returns
-------
plotly.graph_objs.layout.Font
"""
return self["font"]
@font.setter
def font(self, val):
self["font"] = val
@property
def funnelareacolorway(self):
"""
Sets the default funnelarea slice colors. Defaults to the main
`colorway` used for trace colors. If you specify a new list
here it can still be extended with lighter and darker colors,
see `extendfunnelareacolors`.
The 'funnelareacolorway' 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["funnelareacolorway"]
@funnelareacolorway.setter
def funnelareacolorway(self, val):
self["funnelareacolorway"] = val
@property
def funnelgap(self):
"""
Sets the gap (in plot fraction) between bars of adjacent
location coordinates.
The 'funnelgap' property is a number and may be specified as:
- An int or float in the interval [0, 1]
Returns
-------
int|float
"""
return self["funnelgap"]
@funnelgap.setter
def funnelgap(self, val):
self["funnelgap"] = val
@property
def funnelgroupgap(self):
"""
Sets the gap (in plot fraction) between bars of the same
location coordinate.
The 'funnelgroupgap' property is a number and may be specified as:
- An int or float in the interval [0, 1]
Returns
-------
int|float
"""
return self["funnelgroupgap"]
@funnelgroupgap.setter
def funnelgroupgap(self, val):
self["funnelgroupgap"] = val
@property
def funnelmode(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 "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 reduce "opacity" to see multiple bars.
The 'funnelmode' property is an enumeration that may be specified as:
- One of the following enumeration values:
['stack', 'group', 'overlay']
Returns
-------
Any
"""
return self["funnelmode"]
@funnelmode.setter
def funnelmode(self, val):
self["funnelmode"] = val
@property
def geo(self):
"""
The 'geo' property is an instance of Geo
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Geo`
- A dict of string/value properties that will be passed
to the Geo constructor
Returns
-------
plotly.graph_objs.layout.Geo
"""
return self["geo"]
@geo.setter
def geo(self, val):
self["geo"] = val
@property
def grid(self):
"""
The 'grid' property is an instance of Grid
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Grid`
- A dict of string/value properties that will be passed
to the Grid constructor
Returns
-------
plotly.graph_objs.layout.Grid
"""
return self["grid"]
@grid.setter
def grid(self, val):
self["grid"] = val
@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
@property
def hiddenlabels(self):
"""
hiddenlabels is the funnelarea & pie chart analog of
visible:'legendonly' but it can contain many labels, and can
simultaneously hide slices from several pies/funnelarea charts
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
@property
def hiddenlabelssrc(self):
"""
Sets the source reference on Chart Studio Cloud 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
@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 Chart Studio Cloud (at https://chart-
studio.plotly.com 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
@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
@property
def hoverlabel(self):
"""
The 'hoverlabel' property is an instance of Hoverlabel
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Hoverlabel`
- A dict of string/value properties that will be passed
to the Hoverlabel constructor
Returns
-------
plotly.graph_objs.layout.Hoverlabel
"""
return self["hoverlabel"]
@hoverlabel.setter
def hoverlabel(self, val):
self["hoverlabel"] = val
@property
def hovermode(self):
"""
Determines the mode of hover interactions. If "closest", a
single hoverlabel will appear for the "closest" point within
the `hoverdistance`. If "x" (or "y"), multiple hoverlabels will
appear for multiple points at the "closest" x- (or y-)
coordinate within the `hoverdistance`, with the caveat that no
more than one hoverlabel will appear per trace. If *x unified*
(or *y unified*), a single hoverlabel will appear multiple
points at the closest x- (or y-) coordinate within the
`hoverdistance` with the caveat that no more than one
hoverlabel will appear per trace. In this mode, spikelines are
enabled by default perpendicular to the specified axis. If
false, hover interactions are disabled.
The 'hovermode' property is an enumeration that may be specified as:
- One of the following enumeration values:
['x', 'y', 'closest', False, 'x unified', 'y unified']
Returns
-------
Any
"""
return self["hovermode"]
@hovermode.setter
def hovermode(self, val):
self["hovermode"] = val
@property
def hoversubplots(self):
"""
Determines expansion of hover effects to other subplots If
"single" just the axis pair of the primary point is included
without overlaying subplots. If "overlaying" all subplots using
the main axis and occupying the same space are included. If
"axis", also include stacked subplots using the same axis when
`hovermode` is set to "x", *x unified*, "y" or *y unified*.
The 'hoversubplots' property is an enumeration that may be specified as:
- One of the following enumeration values:
['single', 'overlaying', 'axis']
Returns
-------
Any
"""
return self["hoversubplots"]
@hoversubplots.setter
def hoversubplots(self, val):
self["hoversubplots"] = val
@property
def iciclecolorway(self):
"""
Sets the default icicle slice colors. Defaults to the main
`colorway` used for trace colors. If you specify a new list
here it can still be extended with lighter and darker colors,
see `extendiciclecolors`.
The 'iciclecolorway' 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["iciclecolorway"]
@iciclecolorway.setter
def iciclecolorway(self, val):
self["iciclecolorway"] = val
@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
Returns
-------
tuple[plotly.graph_objs.layout.Image]
"""
return self["images"]
@images.setter
def images(self, val):
self["images"] = val
@property
def imagedefaults(self):
"""
When used in a template (as
layout.template.layout.imagedefaults), sets the default
property values to use for elements of layout.images
The 'imagedefaults' property is an instance of Image
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Image`
- A dict of string/value properties that will be passed
to the Image constructor
Returns
-------
plotly.graph_objs.layout.Image
"""
return self["imagedefaults"]
@imagedefaults.setter
def imagedefaults(self, val):
self["imagedefaults"] = val
@property
def legend(self):
"""
The 'legend' property is an instance of Legend
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Legend`
- A dict of string/value properties that will be passed
to the Legend constructor
Returns
-------
plotly.graph_objs.layout.Legend
"""
return self["legend"]
@legend.setter
def legend(self, val):
self["legend"] = val
@property
def map(self):
"""
The 'map' property is an instance of Map
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Map`
- A dict of string/value properties that will be passed
to the Map constructor
Returns
-------
plotly.graph_objs.layout.Map
"""
return self["map"]
@map.setter
def map(self, val):
self["map"] = val
@property
def mapbox(self):
"""
The 'mapbox' property is an instance of Mapbox
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Mapbox`
- A dict of string/value properties that will be passed
to the Mapbox constructor
Returns
-------
plotly.graph_objs.layout.Mapbox
"""
return self["mapbox"]
@mapbox.setter
def mapbox(self, val):
self["mapbox"] = val
@property
def margin(self):
"""
The 'margin' property is an instance of Margin
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Margin`
- A dict of string/value properties that will be passed
to the Margin constructor
Returns
-------
plotly.graph_objs.layout.Margin
"""
return self["margin"]
@margin.setter
def margin(self, val):
self["margin"] = val
@property
def meta(self):
"""
Assigns extra meta information that can be used in various
`text` attributes. Attributes such as the graph, axis and
colorbar `title.text`, annotation `text` `trace.name` in legend
items, `rangeselector`, `updatemenus` and `sliders` `label`
text all support `meta`. One can access `meta` fields using
template strings: `%{meta[i]}` where `i` is the index of the
`meta` item in question. `meta` can also be an object for
example `{key: value}` which can be accessed %{meta[key]}.
The 'meta' property accepts values of any type
Returns
-------
Any|numpy.ndarray
"""
return self["meta"]
@meta.setter
def meta(self, val):
self["meta"] = val
@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
@property
def minreducedheight(self):
"""
Minimum height of the plot with margin.automargin applied (in
px)
The 'minreducedheight' property is a number and may be specified as:
- An int or float in the interval [2, inf]
Returns
-------
int|float
"""
return self["minreducedheight"]
@minreducedheight.setter
def minreducedheight(self, val):
self["minreducedheight"] = val
@property
def minreducedwidth(self):
"""
Minimum width of the plot with margin.automargin applied (in
px)
The 'minreducedwidth' property is a number and may be specified as:
- An int or float in the interval [2, inf]
Returns
-------
int|float
"""
return self["minreducedwidth"]
@minreducedwidth.setter
def minreducedwidth(self, val):
self["minreducedwidth"] = val
@property
def modebar(self):
"""
The 'modebar' property is an instance of Modebar
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Modebar`
- A dict of string/value properties that will be passed
to the Modebar constructor
Returns
-------
plotly.graph_objs.layout.Modebar
"""
return self["modebar"]
@modebar.setter
def modebar(self, val):
self["modebar"] = val
@property
def newselection(self):
"""
The 'newselection' property is an instance of Newselection
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Newselection`
- A dict of string/value properties that will be passed
to the Newselection constructor
Returns
-------
plotly.graph_objs.layout.Newselection
"""
return self["newselection"]
@newselection.setter
def newselection(self, val):
self["newselection"] = val
@property
def newshape(self):
"""
The 'newshape' property is an instance of Newshape
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Newshape`
- A dict of string/value properties that will be passed
to the Newshape constructor
Returns
-------
plotly.graph_objs.layout.Newshape
"""
return self["newshape"]
@newshape.setter
def newshape(self, val):
self["newshape"] = val
@property
def paper_bgcolor(self):
"""
Sets the background color of the 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: see https://plotly.com/python/css-colors/ for a list
Returns
-------
str
"""
return self["paper_bgcolor"]
@paper_bgcolor.setter
def paper_bgcolor(self, val):
self["paper_bgcolor"] = val
@property
def piecolorway(self):
"""
Sets the default pie slice colors. Defaults to the main
`colorway` used for trace colors. If you specify a new list
here it can still be extended with lighter and darker colors,
see `extendpiecolors`.
The 'piecolorway' 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["piecolorway"]
@piecolorway.setter
def piecolorway(self, val):
self["piecolorway"] = val
@property
def plot_bgcolor(self):
"""
Sets the background color of the 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: see https://plotly.com/python/css-colors/ for a list
Returns
-------
str
"""
return self["plot_bgcolor"]
@plot_bgcolor.setter
def plot_bgcolor(self, val):
self["plot_bgcolor"] = val
@property
def polar(self):
"""
The 'polar' property is an instance of Polar
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Polar`
- A dict of string/value properties that will be passed
to the Polar constructor
Returns
-------
plotly.graph_objs.layout.Polar
"""
return self["polar"]
@polar.setter
def polar(self, val):
self["polar"] = val
@property
def scattergap(self):
"""
Sets the gap (in plot fraction) between scatter points of
adjacent location coordinates. Defaults to `bargap`.
The 'scattergap' property is a number and may be specified as:
- An int or float in the interval [0, 1]
Returns
-------
int|float
"""
return self["scattergap"]
@scattergap.setter
def scattergap(self, val):
self["scattergap"] = val
@property
def scattermode(self):
"""
Determines how scatter points at the same location coordinate
are displayed on the graph. With "group", the scatter points
are plotted next to one another centered around the shared
location. With "overlay", the scatter points are plotted over
one another, you might need to reduce "opacity" to see multiple
scatter points.
The 'scattermode' property is an enumeration that may be specified as:
- One of the following enumeration values:
['group', 'overlay']
Returns
-------
Any
"""
return self["scattermode"]
@scattermode.setter
def scattermode(self, val):
self["scattermode"] = val
@property
def scene(self):
"""
The 'scene' property is an instance of Scene
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Scene`
- A dict of string/value properties that will be passed
to the Scene constructor
Returns
-------
plotly.graph_objs.layout.Scene
"""
return self["scene"]
@scene.setter
def scene(self, val):
self["scene"] = val
@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
@property
def selectionrevision(self):
"""
Controls persistence of user-driven changes in selected points
from all traces.
The 'selectionrevision' property accepts values of any type
Returns
-------
Any
"""
return self["selectionrevision"]
@selectionrevision.setter
def selectionrevision(self, val):
self["selectionrevision"] = val
@property
def selections(self):
"""
The 'selections' property is a tuple of instances of
Selection that may be specified as:
- A list or tuple of instances of plotly.graph_objs.layout.Selection
- A list or tuple of dicts of string/value properties that
will be passed to the Selection constructor
Returns
-------
tuple[plotly.graph_objs.layout.Selection]
"""
return self["selections"]
@selections.setter
def selections(self, val):
self["selections"] = val
@property
def selectiondefaults(self):
"""
When used in a template (as
layout.template.layout.selectiondefaults), sets the default
property values to use for elements of layout.selections
The 'selectiondefaults' property is an instance of Selection
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Selection`
- A dict of string/value properties that will be passed
to the Selection constructor
Returns
-------
plotly.graph_objs.layout.Selection
"""
return self["selectiondefaults"]
@selectiondefaults.setter
def selectiondefaults(self, val):
self["selectiondefaults"] = val
@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
@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
Returns
-------
tuple[plotly.graph_objs.layout.Shape]
"""
return self["shapes"]
@shapes.setter
def shapes(self, val):
self["shapes"] = val
@property
def shapedefaults(self):
"""
When used in a template (as
layout.template.layout.shapedefaults), sets the default
property values to use for elements of layout.shapes
The 'shapedefaults' property is an instance of Shape
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Shape`
- A dict of string/value properties that will be passed
to the Shape constructor
Returns
-------
plotly.graph_objs.layout.Shape
"""
return self["shapedefaults"]
@shapedefaults.setter
def shapedefaults(self, val):
self["shapedefaults"] = val
@property
def showlegend(self):
"""
Determines whether or not a legend is drawn. Default is `true`
if there is a trace to show and any of these: a) Two or more
traces would by default be shown in the legend. b) One pie
trace is shown in the legend. c) One trace is explicitly given
with `showlegend: true`.
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
@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
Returns
-------
tuple[plotly.graph_objs.layout.Slider]
"""
return self["sliders"]
@sliders.setter
def sliders(self, val):
self["sliders"] = val
@property
def sliderdefaults(self):
"""
When used in a template (as
layout.template.layout.sliderdefaults), sets the default
property values to use for elements of layout.sliders
The 'sliderdefaults' property is an instance of Slider
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Slider`
- A dict of string/value properties that will be passed
to the Slider constructor
Returns
-------
plotly.graph_objs.layout.Slider
"""
return self["sliderdefaults"]
@sliderdefaults.setter
def sliderdefaults(self, val):
self["sliderdefaults"] = val
@property
def smith(self):
"""
The 'smith' property is an instance of Smith
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Smith`
- A dict of string/value properties that will be passed
to the Smith constructor
Returns
-------
plotly.graph_objs.layout.Smith
"""
return self["smith"]
@smith.setter
def smith(self, val):
self["smith"] = val
@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
@property
def sunburstcolorway(self):
"""
Sets the default sunburst slice colors. Defaults to the main
`colorway` used for trace colors. If you specify a new list
here it can still be extended with lighter and darker colors,
see `extendsunburstcolors`.
The 'sunburstcolorway' 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["sunburstcolorway"]
@sunburstcolorway.setter
def sunburstcolorway(self, val):
self["sunburstcolorway"] = val
@property
def template(self):
"""
Default attributes to be applied to the plot. This should be a
dict with format: `{'layout': layoutTemplate, 'data':
{trace_type: [traceTemplate, ...], ...}}` where
`layoutTemplate` is a dict matching the structure of
`figure.layout` and `traceTemplate` is a dict matching the
structure of the trace with type `trace_type` (e.g. 'scatter').
Alternatively, this may be specified as an instance of
plotly.graph_objs.layout.Template. Trace templates are applied
cyclically to traces of each type. Container arrays (eg
`annotations`) have special handling: An object ending in
`defaults` (eg `annotationdefaults`) is applied to each array
item. But if an item has a `templateitemname` key we look in
the template array for an item with matching `name` and apply
that instead. If no matching `name` is found we mark the item
invisible. Any named template item not referenced is appended
to the end of the array, so this can be used to add a watermark
annotation or a logo image, for example. To omit one of these
items on the plot, make an item with matching
`templateitemname` and `visible: false`.
The 'template' property is an instance of Template
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Template`
- A dict of string/value properties that will be passed
to the Template constructor
- The name of a registered template where current registered templates
are stored in the plotly.io.templates configuration object. The names
of all registered templates can be retrieved with:
>>> import plotly.io as pio
>>> list(pio.templates) # doctest: +ELLIPSIS
['ggplot2', 'seaborn', 'simple_white', 'plotly', 'plotly_white', ...]
- A string containing multiple registered template names, joined on '+'
characters (e.g. 'template1+template2'). In this case the resulting
template is computed by merging together the collection of registered
templates
Returns
-------
plotly.graph_objs.layout.Template
"""
return self["template"]
@template.setter
def template(self, val):
self["template"] = val
@property
def ternary(self):
"""
The 'ternary' property is an instance of Ternary
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Ternary`
- A dict of string/value properties that will be passed
to the Ternary constructor
Returns
-------
plotly.graph_objs.layout.Ternary
"""
return self["ternary"]
@ternary.setter
def ternary(self, val):
self["ternary"] = val
@property
def title(self):
"""
The 'title' property is an instance of Title
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Title`
- A dict of string/value properties that will be passed
to the Title constructor
Returns
-------
plotly.graph_objs.layout.Title
"""
return self["title"]
@title.setter
def title(self, val):
self["title"] = val
@property
def transition(self):
"""
Sets transition options used during Plotly.react updates.
The 'transition' property is an instance of Transition
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Transition`
- A dict of string/value properties that will be passed
to the Transition constructor
Returns
-------
plotly.graph_objs.layout.Transition
"""
return self["transition"]
@transition.setter
def transition(self, val):
self["transition"] = val
@property
def treemapcolorway(self):
"""
Sets the default treemap slice colors. Defaults to the main
`colorway` used for trace colors. If you specify a new list
here it can still be extended with lighter and darker colors,
see `extendtreemapcolors`.
The 'treemapcolorway' 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["treemapcolorway"]
@treemapcolorway.setter
def treemapcolorway(self, val):
self["treemapcolorway"] = val
@property
def uirevision(self):
"""
Used to allow user interactions with the plot to persist after
`Plotly.react` calls that are unaware of these interactions. If
`uirevision` is omitted, or if it is given and it changed from
the previous `Plotly.react` call, the exact new figure is used.
If `uirevision` is truthy and did NOT change, any attribute
that has been affected by user interactions and did not receive
a different value in the new figure will keep the interaction
value. `layout.uirevision` attribute serves as the default for
`uirevision` attributes in various sub-containers. For finer
control you can set these sub-attributes directly. For example,
if your app separately controls the data on the x and y axes
you might set `xaxis.uirevision=*time*` and
`yaxis.uirevision=*cost*`. Then if only the y data is changed,
you can update `yaxis.uirevision=*quantity*` and the y axis
range will reset but the x axis range will retain any user-
driven zoom.
The 'uirevision' property accepts values of any type
Returns
-------
Any
"""
return self["uirevision"]
@uirevision.setter
def uirevision(self, val):
self["uirevision"] = val
@property
def uniformtext(self):
"""
The 'uniformtext' property is an instance of Uniformtext
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Uniformtext`
- A dict of string/value properties that will be passed
to the Uniformtext constructor
Returns
-------
plotly.graph_objs.layout.Uniformtext
"""
return self["uniformtext"]
@uniformtext.setter
def uniformtext(self, val):
self["uniformtext"] = val
@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
Returns
-------
tuple[plotly.graph_objs.layout.Updatemenu]
"""
return self["updatemenus"]
@updatemenus.setter
def updatemenus(self, val):
self["updatemenus"] = val
@property
def updatemenudefaults(self):
"""
When used in a template (as
layout.template.layout.updatemenudefaults), sets the default
property values to use for elements of layout.updatemenus
The 'updatemenudefaults' property is an instance of Updatemenu
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.Updatemenu`
- A dict of string/value properties that will be passed
to the Updatemenu constructor
Returns
-------
plotly.graph_objs.layout.Updatemenu
"""
return self["updatemenudefaults"]
@updatemenudefaults.setter
def updatemenudefaults(self, val):
self["updatemenudefaults"] = val
@property
def violingap(self):
"""
Sets the gap (in plot fraction) between violins of adjacent
location coordinates. Has no effect on traces that have "width"
set.
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
@property
def violingroupgap(self):
"""
Sets the gap (in plot fraction) between violins of the same
location coordinate. Has no effect on traces that have "width"
set.
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
@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. Has no
effect on traces that have "width" set.
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
@property
def waterfallgap(self):
"""
Sets the gap (in plot fraction) between bars of adjacent
location coordinates.
The 'waterfallgap' property is a number and may be specified as:
- An int or float in the interval [0, 1]
Returns
-------
int|float
"""
return self["waterfallgap"]
@waterfallgap.setter
def waterfallgap(self, val):
self["waterfallgap"] = val
@property
def waterfallgroupgap(self):
"""
Sets the gap (in plot fraction) between bars of the same
location coordinate.
The 'waterfallgroupgap' property is a number and may be specified as:
- An int or float in the interval [0, 1]
Returns
-------
int|float
"""
return self["waterfallgroupgap"]
@waterfallgroupgap.setter
def waterfallgroupgap(self, val):
self["waterfallgroupgap"] = val
@property
def waterfallmode(self):
"""
Determines how bars at the same location coordinate are
displayed on the graph. 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 reduce "opacity" to see multiple bars.
The 'waterfallmode' property is an enumeration that may be specified as:
- One of the following enumeration values:
['group', 'overlay']
Returns
-------
Any
"""
return self["waterfallmode"]
@waterfallmode.setter
def waterfallmode(self, val):
self["waterfallmode"] = val
@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
@property
def xaxis(self):
"""
The 'xaxis' property is an instance of XAxis
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.XAxis`
- A dict of string/value properties that will be passed
to the XAxis constructor
Returns
-------
plotly.graph_objs.layout.XAxis
"""
return self["xaxis"]
@xaxis.setter
def xaxis(self, val):
self["xaxis"] = val
@property
def yaxis(self):
"""
The 'yaxis' property is an instance of YAxis
that may be specified as:
- An instance of :class:`plotly.graph_objs.layout.YAxis`
- A dict of string/value properties that will be passed
to the YAxis constructor
Returns
-------
plotly.graph_objs.layout.YAxis
"""
return self["yaxis"]
@yaxis.setter
def yaxis(self, val):
self["yaxis"] = val
@property
def _prop_descriptions(self):
return """\
activeselection
:class:`plotly.graph_objects.layout.Activeselection`
instance or dict with compatible properties
activeshape
:class:`plotly.graph_objects.layout.Activeshape`
instance or dict with compatible properties
annotations
A tuple of
:class:`plotly.graph_objects.layout.Annotation`
instances or dicts with compatible properties
annotationdefaults
When used in a template (as
layout.template.layout.annotationdefaults), sets the
default property values to use for elements of
layout.annotations
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.
autotypenumbers
Using "strict" a numeric string in trace data is not
converted to a number. Using *convert types* a numeric
string in trace data may be treated as a number during
automatic axis `type` detection. This is the default
value; however it could be overridden for individual
axes.
barcornerradius
Sets the rounding of bar corners. May be an integer
number of pixels, or a percentage of bar width (as a
string ending in %).
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 reduce
"opacity" to see multiple bars.
barnorm
Sets the normalization for bar traces on the graph.
With "fraction", the value of each bar is divided by
the sum of all values at that location coordinate.
"percent" is the same but multiplied by 100 to show
percentages.
boxgap
Sets the gap (in plot fraction) between boxes of
adjacent location coordinates. Has no effect on traces
that have "width" set.
boxgroupgap
Sets the gap (in plot fraction) between boxes of the
same location coordinate. Has no effect on traces that
have "width" set.
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. Has no effect on traces that have
"width" set.
calendar
Sets the default calendar system to use for
interpreting and displaying dates throughout the plot.
clickmode
Determines the mode of single click interactions.
"event" is the default value and emits the
`plotly_click` event. In addition this mode emits the
`plotly_selected` event in drag modes "lasso" and
"select", but with no event data attached (kept for
compatibility reasons). The "select" flag enables
selecting single data points via click. This mode also
supports persistent selections, meaning that pressing
Shift while clicking, adds to / subtracts from an
existing selection. "select" with `hovermode`: "x" can
be confusing, consider explicitly setting `hovermode`:
"closest" when using this feature. Selection events are
sent accordingly as long as "event" flag is set as
well. When the "event" flag is missing, `plotly_click`
and `plotly_selected` events are not fired.
coloraxis
:class:`plotly.graph_objects.layout.Coloraxis` instance
or dict with compatible properties
colorscale
:class:`plotly.graph_objects.layout.Colorscale`
instance or dict with compatible properties
colorway
Sets the default trace colors.
computed
Placeholder for exporting automargin-impacting values
namely `margin.t`, `margin.b`, `margin.l` and
`margin.r` in "full-json" mode.
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.
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.
editrevision
Controls persistence of user-driven changes in
`editable: true` configuration, other than trace names
and axis titles. Defaults to `layout.uirevision`.
extendfunnelareacolors
If `true`, the funnelarea slice colors (whether given
by `funnelareacolorway` or inherited from `colorway`)
will be extended to three times its original length by
first repeating every color 20% lighter then each color
20% darker. This is intended to reduce the likelihood
of reusing the same color when you have many slices,
but you can set `false` to disable. Colors provided in
the trace, using `marker.colors`, are never extended.
extendiciclecolors
If `true`, the icicle slice colors (whether given by
`iciclecolorway` or inherited from `colorway`) will be
extended to three times its original length by first
repeating every color 20% lighter then each color 20%
darker. This is intended to reduce the likelihood of
reusing the same color when you have many slices, but
you can set `false` to disable. Colors provided in the
trace, using `marker.colors`, are never extended.
extendpiecolors
If `true`, the pie slice colors (whether given by
`piecolorway` or inherited from `colorway`) will be
extended to three times its original length by first
repeating every color 20% lighter then each color 20%
darker. This is intended to reduce the likelihood of
reusing the same color when you have many slices, but
you can set `false` to disable. Colors provided in the
trace, using `marker.colors`, are never extended.
extendsunburstcolors
If `true`, the sunburst slice colors (whether given by
`sunburstcolorway` or inherited from `colorway`) will
be extended to three times its original length by first
repeating every color 20% lighter then each color 20%
darker. This is intended to reduce the likelihood of
reusing the same color when you have many slices, but
you can set `false` to disable. Colors provided in the
trace, using `marker.colors`, are never extended.
extendtreemapcolors
If `true`, the treemap slice colors (whether given by
`treemapcolorway` or inherited from `colorway`) will be
extended to three times its original length by first
repeating every color 20% lighter then each color 20%
darker. This is intended to reduce the likelihood of
reusing the same color when you have many slices, but
you can set `false` to disable. Colors provided in the
trace, using `marker.colors`, are never extended.
font
Sets the global font. Note that fonts used in traces
and other layout components inherit from the global
font.
funnelareacolorway
Sets the default funnelarea slice colors. Defaults to
the main `colorway` used for trace colors. If you
specify a new list here it can still be extended with
lighter and darker colors, see
`extendfunnelareacolors`.
funnelgap
Sets the gap (in plot fraction) between bars of
adjacent location coordinates.
funnelgroupgap
Sets the gap (in plot fraction) between bars of the
same location coordinate.
funnelmode
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 "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 reduce "opacity" to
see multiple bars.
geo
:class:`plotly.graph_objects.layout.Geo` instance or
dict with compatible properties
grid
:class:`plotly.graph_objects.layout.Grid` instance or
dict with compatible properties
height
Sets the plot's height (in px).
hiddenlabels
hiddenlabels is the funnelarea & pie chart analog of
visible:'legendonly' but it can contain many labels,
and can simultaneously hide slices from several
pies/funnelarea charts
hiddenlabelssrc
Sets the source reference on Chart Studio Cloud 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 Chart Studio
Cloud (at https://chart-studio.plotly.com 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
:class:`plotly.graph_objects.layout.Hoverlabel`
instance or dict with compatible properties
hovermode
Determines the mode of hover interactions. If
"closest", a single hoverlabel will appear for the
"closest" point within the `hoverdistance`. If "x" (or
"y"), multiple hoverlabels will appear for multiple
points at the "closest" x- (or y-) coordinate within
the `hoverdistance`, with the caveat that no more than
one hoverlabel will appear per trace. If *x unified*
(or *y unified*), a single hoverlabel will appear
multiple points at the closest x- (or y-) coordinate
within the `hoverdistance` with the caveat that no more
than one hoverlabel will appear per trace. In this
mode, spikelines are enabled by default perpendicular
to the specified axis. If false, hover interactions are
disabled.
hoversubplots
Determines expansion of hover effects to other subplots
If "single" just the axis pair of the primary point is
included without overlaying subplots. If "overlaying"
all subplots using the main axis and occupying the same
space are included. If "axis", also include stacked
subplots using the same axis when `hovermode` is set to
"x", *x unified*, "y" or *y unified*.
iciclecolorway
Sets the default icicle slice colors. Defaults to the
main `colorway` used for trace colors. If you specify a
new list here it can still be extended with lighter and
darker colors, see `extendiciclecolors`.
images
A tuple of :class:`plotly.graph_objects.layout.Image`
instances or dicts with compatible properties
imagedefaults
When used in a template (as
layout.template.layout.imagedefaults), sets the default
property values to use for elements of layout.images
legend
:class:`plotly.graph_objects.layout.Legend` instance or
dict with compatible properties
map
:class:`plotly.graph_objects.layout.Map` instance or
dict with compatible properties
mapbox
:class:`plotly.graph_objects.layout.Mapbox` instance or
dict with compatible properties
margin
:class:`plotly.graph_objects.layout.Margin` instance or
dict with compatible properties
meta
Assigns extra meta information that can be used in
various `text` attributes. Attributes such as the
graph, axis and colorbar `title.text`, annotation
`text` `trace.name` in legend items, `rangeselector`,
`updatemenus` and `sliders` `label` text all support
`meta`. One can access `meta` fields using template
strings: `%{meta[i]}` where `i` is the index of the
`meta` item in question. `meta` can also be an object
for example `{key: value}` which can be accessed
%{meta[key]}.
metasrc
Sets the source reference on Chart Studio Cloud for
`meta`.
minreducedheight
Minimum height of the plot with margin.automargin
applied (in px)
minreducedwidth
Minimum width of the plot with margin.automargin
applied (in px)
modebar
:class:`plotly.graph_objects.layout.Modebar` instance
or dict with compatible properties
newselection
:class:`plotly.graph_objects.layout.Newselection`
instance or dict with compatible properties
newshape
:class:`plotly.graph_objects.layout.Newshape` instance
or dict with compatible properties
paper_bgcolor
Sets the background color of the paper where the graph
is drawn.
piecolorway
Sets the default pie slice colors. Defaults to the main
`colorway` used for trace colors. If you specify a new
list here it can still be extended with lighter and
darker colors, see `extendpiecolors`.
plot_bgcolor
Sets the background color of the plotting area in-
between x and y axes.
polar
:class:`plotly.graph_objects.layout.Polar` instance or
dict with compatible properties
scattergap
Sets the gap (in plot fraction) between scatter points
of adjacent location coordinates. Defaults to `bargap`.
scattermode
Determines how scatter points at the same location
coordinate are displayed on the graph. With "group",
the scatter points are plotted next to one another
centered around the shared location. With "overlay",
the scatter points are plotted over one another, you
might need to reduce "opacity" to see multiple scatter
points.
scene
:class:`plotly.graph_objects.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.
selectionrevision
Controls persistence of user-driven changes in selected
points from all traces.
selections
A tuple of
:class:`plotly.graph_objects.layout.Selection`
instances or dicts with compatible properties
selectiondefaults
When used in a template (as
layout.template.layout.selectiondefaults), sets the
default property values to use for elements of
layout.selections
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
A tuple of :class:`plotly.graph_objects.layout.Shape`
instances or dicts with compatible properties
shapedefaults
When used in a template (as
layout.template.layout.shapedefaults), sets the default
property values to use for elements of layout.shapes
showlegend
Determines whether or not a legend is drawn. Default is
`true` if there is a trace to show and any of these: a)
Two or more traces would by default be shown in the
legend. b) One pie trace is shown in the legend. c) One
trace is explicitly given with `showlegend: true`.
sliders
A tuple of :class:`plotly.graph_objects.layout.Slider`
instances or dicts with compatible properties
sliderdefaults
When used in a template (as
layout.template.layout.sliderdefaults), sets the
default property values to use for elements of
layout.sliders
smith
:class:`plotly.graph_objects.layout.Smith` 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.
sunburstcolorway
Sets the default sunburst slice colors. Defaults to the
main `colorway` used for trace colors. If you specify a
new list here it can still be extended with lighter and
darker colors, see `extendsunburstcolors`.
template
Default attributes to be applied to the plot. This
should be a dict with format: `{'layout':
layoutTemplate, 'data': {trace_type: [traceTemplate,
...], ...}}` where `layoutTemplate` is a dict matching
the structure of `figure.layout` and `traceTemplate` is
a dict matching the structure of the trace with type
`trace_type` (e.g. 'scatter'). Alternatively, this may
be specified as an instance of
plotly.graph_objs.layout.Template. Trace templates are
applied cyclically to traces of each type. Container
arrays (eg `annotations`) have special handling: An
object ending in `defaults` (eg `annotationdefaults`)
is applied to each array item. But if an item has a
`templateitemname` key we look in the template array
for an item with matching `name` and apply that
instead. If no matching `name` is found we mark the
item invisible. Any named template item not referenced
is appended to the end of the array, so this can be
used to add a watermark annotation or a logo image, for
example. To omit one of these items on the plot, make
an item with matching `templateitemname` and `visible:
false`.
ternary
:class:`plotly.graph_objects.layout.Ternary` instance
or dict with compatible properties
title
:class:`plotly.graph_objects.layout.Title` instance or
dict with compatible properties
transition
Sets transition options used during Plotly.react
updates.
treemapcolorway
Sets the default treemap slice colors. Defaults to the
main `colorway` used for trace colors. If you specify a
new list here it can still be extended with lighter and
darker colors, see `extendtreemapcolors`.
uirevision
Used to allow user interactions with the plot to
persist after `Plotly.react` calls that are unaware of
these interactions. If `uirevision` is omitted, or if
it is given and it changed from the previous
`Plotly.react` call, the exact new figure is used. If
`uirevision` is truthy and did NOT change, any
attribute that has been affected by user interactions
and did not receive a different value in the new figure
will keep the interaction value. `layout.uirevision`
attribute serves as the default for `uirevision`
attributes in various sub-containers. For finer control
you can set these sub-attributes directly. For example,
if your app separately controls the data on the x and y
axes you might set `xaxis.uirevision=*time*` and
`yaxis.uirevision=*cost*`. Then if only the y data is
changed, you can update `yaxis.uirevision=*quantity*`
and the y axis range will reset but the x axis range
will retain any user-driven zoom.
uniformtext
:class:`plotly.graph_objects.layout.Uniformtext`
instance or dict with compatible properties
updatemenus
A tuple of
:class:`plotly.graph_objects.layout.Updatemenu`
instances or dicts with compatible properties
updatemenudefaults
When used in a template (as
layout.template.layout.updatemenudefaults), sets the
default property values to use for elements of
layout.updatemenus
violingap
Sets the gap (in plot fraction) between violins of
adjacent location coordinates. Has no effect on traces
that have "width" set.
violingroupgap
Sets the gap (in plot fraction) between violins of the
same location coordinate. Has no effect on traces that
have "width" set.
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. Has no effect on traces that
have "width" set.
waterfallgap
Sets the gap (in plot fraction) between bars of
adjacent location coordinates.
waterfallgroupgap
Sets the gap (in plot fraction) between bars of the
same location coordinate.
waterfallmode
Determines how bars at the same location coordinate are
displayed on the graph. 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 reduce "opacity" to see
multiple bars.
width
Sets the plot's width (in px).
xaxis
:class:`plotly.graph_objects.layout.XAxis` instance or
dict with compatible properties
yaxis
:class:`plotly.graph_objects.layout.YAxis` instance or
dict with compatible properties
"""
def __init__(
self,
arg=None,
activeselection=None,
activeshape=None,
annotations=None,
annotationdefaults=None,
autosize=None,
autotypenumbers=None,
barcornerradius=None,
bargap=None,
bargroupgap=None,
barmode=None,
barnorm=None,
boxgap=None,
boxgroupgap=None,
boxmode=None,
calendar=None,
clickmode=None,
coloraxis=None,
colorscale=None,
colorway=None,
computed=None,
datarevision=None,
dragmode=None,
editrevision=None,
extendfunnelareacolors=None,
extendiciclecolors=None,
extendpiecolors=None,
extendsunburstcolors=None,
extendtreemapcolors=None,
font=None,
funnelareacolorway=None,
funnelgap=None,
funnelgroupgap=None,
funnelmode=None,
geo=None,
grid=None,
height=None,
hiddenlabels=None,
hiddenlabelssrc=None,
hidesources=None,
hoverdistance=None,
hoverlabel=None,
hovermode=None,
hoversubplots=None,
iciclecolorway=None,
images=None,
imagedefaults=None,
legend=None,
map=None,
mapbox=None,
margin=None,
meta=None,
metasrc=None,
minreducedheight=None,
minreducedwidth=None,
modebar=None,
newselection=None,
newshape=None,
paper_bgcolor=None,
piecolorway=None,
plot_bgcolor=None,
polar=None,
scattergap=None,
scattermode=None,
scene=None,
selectdirection=None,
selectionrevision=None,
selections=None,
selectiondefaults=None,
separators=None,
shapes=None,
shapedefaults=None,
showlegend=None,
sliders=None,
sliderdefaults=None,
smith=None,
spikedistance=None,
sunburstcolorway=None,
template=None,
ternary=None,
title=None,
transition=None,
treemapcolorway=None,
uirevision=None,
uniformtext=None,
updatemenus=None,
updatemenudefaults=None,
violingap=None,
violingroupgap=None,
violinmode=None,
waterfallgap=None,
waterfallgroupgap=None,
waterfallmode=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 :class:`plotly.graph_objs.Layout`
activeselection
:class:`plotly.graph_objects.layout.Activeselection`
instance or dict with compatible properties
activeshape
:class:`plotly.graph_objects.layout.Activeshape`
instance or dict with compatible properties
annotations
A tuple of
:class:`plotly.graph_objects.layout.Annotation`
instances or dicts with compatible properties
annotationdefaults
When used in a template (as
layout.template.layout.annotationdefaults), sets the
default property values to use for elements of
layout.annotations
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.
autotypenumbers
Using "strict" a numeric string in trace data is not
converted to a number. Using *convert types* a numeric
string in trace data may be treated as a number during
automatic axis `type` detection. This is the default
value; however it could be overridden for individual
axes.
barcornerradius
Sets the rounding of bar corners. May be an integer
number of pixels, or a percentage of bar width (as a
string ending in %).
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 reduce
"opacity" to see multiple bars.
barnorm
Sets the normalization for bar traces on the graph.
With "fraction", the value of each bar is divided by
the sum of all values at that location coordinate.
"percent" is the same but multiplied by 100 to show
percentages.
boxgap
Sets the gap (in plot fraction) between boxes of
adjacent location coordinates. Has no effect on traces
that have "width" set.
boxgroupgap
Sets the gap (in plot fraction) between boxes of the
same location coordinate. Has no effect on traces that
have "width" set.
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. Has no effect on traces that have
"width" set.
calendar
Sets the default calendar system to use for
interpreting and displaying dates throughout the plot.
clickmode
Determines the mode of single click interactions.
"event" is the default value and emits the
`plotly_click` event. In addition this mode emits the
`plotly_selected` event in drag modes "lasso" and
"select", but with no event data attached (kept for
compatibility reasons). The "select" flag enables
selecting single data points via click. This mode also
supports persistent selections, meaning that pressing
Shift while clicking, adds to / subtracts from an
existing selection. "select" with `hovermode`: "x" can
be confusing, consider explicitly setting `hovermode`:
"closest" when using this feature. Selection events are
sent accordingly as long as "event" flag is set as
well. When the "event" flag is missing, `plotly_click`
and `plotly_selected` events are not fired.
coloraxis
:class:`plotly.graph_objects.layout.Coloraxis` instance
or dict with compatible properties
colorscale
:class:`plotly.graph_objects.layout.Colorscale`
instance or dict with compatible properties
colorway
Sets the default trace colors.
computed
Placeholder for exporting automargin-impacting values
namely `margin.t`, `margin.b`, `margin.l` and
`margin.r` in "full-json" mode.
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.
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.
editrevision
Controls persistence of user-driven changes in
`editable: true` configuration, other than trace names
and axis titles. Defaults to `layout.uirevision`.
extendfunnelareacolors
If `true`, the funnelarea slice colors (whether given
by `funnelareacolorway` or inherited from `colorway`)
will be extended to three times its original length by
first repeating every color 20% lighter then each color
20% darker. This is intended to reduce the likelihood
of reusing the same color when you have many slices,
but you can set `false` to disable. Colors provided in
the trace, using `marker.colors`, are never extended.
extendiciclecolors
If `true`, the icicle slice colors (whether given by
`iciclecolorway` or inherited from `colorway`) will be
extended to three times its original length by first
repeating every color 20% lighter then each color 20%
darker. This is intended to reduce the likelihood of
reusing the same color when you have many slices, but
you can set `false` to disable. Colors provided in the
trace, using `marker.colors`, are never extended.
extendpiecolors
If `true`, the pie slice colors (whether given by
`piecolorway` or inherited from `colorway`) will be
extended to three times its original length by first
repeating every color 20% lighter then each color 20%
darker. This is intended to reduce the likelihood of
reusing the same color when you have many slices, but
you can set `false` to disable. Colors provided in the
trace, using `marker.colors`, are never extended.
extendsunburstcolors
If `true`, the sunburst slice colors (whether given by
`sunburstcolorway` or inherited from `colorway`) will
be extended to three times its original length by first
repeating every color 20% lighter then each color 20%
darker. This is intended to reduce the likelihood of
reusing the same color when you have many slices, but
you can set `false` to disable. Colors provided in the
trace, using `marker.colors`, are never extended.
extendtreemapcolors
If `true`, the treemap slice colors (whether given by
`treemapcolorway` or inherited from `colorway`) will be
extended to three times its original length by first
repeating every color 20% lighter then each color 20%
darker. This is intended to reduce the likelihood of
reusing the same color when you have many slices, but
you can set `false` to disable. Colors provided in the
trace, using `marker.colors`, are never extended.
font
Sets the global font. Note that fonts used in traces
and other layout components inherit from the global
font.
funnelareacolorway
Sets the default funnelarea slice colors. Defaults to
the main `colorway` used for trace colors. If you
specify a new list here it can still be extended with
lighter and darker colors, see
`extendfunnelareacolors`.
funnelgap
Sets the gap (in plot fraction) between bars of
adjacent location coordinates.
funnelgroupgap
Sets the gap (in plot fraction) between bars of the
same location coordinate.
funnelmode
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 "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 reduce "opacity" to
see multiple bars.
geo
:class:`plotly.graph_objects.layout.Geo` instance or
dict with compatible properties
grid
:class:`plotly.graph_objects.layout.Grid` instance or
dict with compatible properties
height
Sets the plot's height (in px).
hiddenlabels
hiddenlabels is the funnelarea & pie chart analog of
visible:'legendonly' but it can contain many labels,
and can simultaneously hide slices from several
pies/funnelarea charts
hiddenlabelssrc
Sets the source reference on Chart Studio Cloud 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 Chart Studio
Cloud (at https://chart-studio.plotly.com 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
:class:`plotly.graph_objects.layout.Hoverlabel`
instance or dict with compatible properties
hovermode
Determines the mode of hover interactions. If
"closest", a single hoverlabel will appear for the
"closest" point within the `hoverdistance`. If "x" (or
"y"), multiple hoverlabels will appear for multiple
points at the "closest" x- (or y-) coordinate within
the `hoverdistance`, with the caveat that no more than
one hoverlabel will appear per trace. If *x unified*
(or *y unified*), a single hoverlabel will appear
multiple points at the closest x- (or y-) coordinate
within the `hoverdistance` with the caveat that no more
than one hoverlabel will appear per trace. In this
mode, spikelines are enabled by default perpendicular
to the specified axis. If false, hover interactions are
disabled.
hoversubplots
Determines expansion of hover effects to other subplots
If "single" just the axis pair of the primary point is
included without overlaying subplots. If "overlaying"
all subplots using the main axis and occupying the same
space are included. If "axis", also include stacked
subplots using the same axis when `hovermode` is set to
"x", *x unified*, "y" or *y unified*.
iciclecolorway
Sets the default icicle slice colors. Defaults to the
main `colorway` used for trace colors. If you specify a
new list here it can still be extended with lighter and
darker colors, see `extendiciclecolors`.
images
A tuple of :class:`plotly.graph_objects.layout.Image`
instances or dicts with compatible properties
imagedefaults
When used in a template (as
layout.template.layout.imagedefaults), sets the default
property values to use for elements of layout.images
legend
:class:`plotly.graph_objects.layout.Legend` instance or
dict with compatible properties
map
:class:`plotly.graph_objects.layout.Map` instance or
dict with compatible properties
mapbox
:class:`plotly.graph_objects.layout.Mapbox` instance or
dict with compatible properties
margin
:class:`plotly.graph_objects.layout.Margin` instance or
dict with compatible properties
meta
Assigns extra meta information that can be used in
various `text` attributes. Attributes such as the
graph, axis and colorbar `title.text`, annotation
`text` `trace.name` in legend items, `rangeselector`,
`updatemenus` and `sliders` `label` text all support
`meta`. One can access `meta` fields using template
strings: `%{meta[i]}` where `i` is the index of the
`meta` item in question. `meta` can also be an object
for example `{key: value}` which can be accessed
%{meta[key]}.
metasrc
Sets the source reference on Chart Studio Cloud for
`meta`.
minreducedheight
Minimum height of the plot with margin.automargin
applied (in px)
minreducedwidth
Minimum width of the plot with margin.automargin
applied (in px)
modebar
:class:`plotly.graph_objects.layout.Modebar` instance
or dict with compatible properties
newselection
:class:`plotly.graph_objects.layout.Newselection`
instance or dict with compatible properties
newshape
:class:`plotly.graph_objects.layout.Newshape` instance
or dict with compatible properties
paper_bgcolor
Sets the background color of the paper where the graph
is drawn.
piecolorway
Sets the default pie slice colors. Defaults to the main
`colorway` used for trace colors. If you specify a new
list here it can still be extended with lighter and
darker colors, see `extendpiecolors`.
plot_bgcolor
Sets the background color of the plotting area in-
between x and y axes.
polar
:class:`plotly.graph_objects.layout.Polar` instance or
dict with compatible properties
scattergap
Sets the gap (in plot fraction) between scatter points
of adjacent location coordinates. Defaults to `bargap`.
scattermode
Determines how scatter points at the same location
coordinate are displayed on the graph. With "group",
the scatter points are plotted next to one another
centered around the shared location. With "overlay",
the scatter points are plotted over one another, you
might need to reduce "opacity" to see multiple scatter
points.
scene
:class:`plotly.graph_objects.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.
selectionrevision
Controls persistence of user-driven changes in selected
points from all traces.
selections
A tuple of
:class:`plotly.graph_objects.layout.Selection`
instances or dicts with compatible properties
selectiondefaults
When used in a template (as
layout.template.layout.selectiondefaults), sets the
default property values to use for elements of
layout.selections
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
A tuple of :class:`plotly.graph_objects.layout.Shape`
instances or dicts with compatible properties
shapedefaults
When used in a template (as
layout.template.layout.shapedefaults), sets the default
property values to use for elements of layout.shapes
showlegend
Determines whether or not a legend is drawn. Default is
`true` if there is a trace to show and any of these: a)
Two or more traces would by default be shown in the
legend. b) One pie trace is shown in the legend. c) One
trace is explicitly given with `showlegend: true`.
sliders
A tuple of :class:`plotly.graph_objects.layout.Slider`
instances or dicts with compatible properties
sliderdefaults
When used in a template (as
layout.template.layout.sliderdefaults), sets the
default property values to use for elements of
layout.sliders
smith
:class:`plotly.graph_objects.layout.Smith` 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.
sunburstcolorway
Sets the default sunburst slice colors. Defaults to the
main `colorway` used for trace colors. If you specify a
new list here it can still be extended with lighter and
darker colors, see `extendsunburstcolors`.
template
Default attributes to be applied to the plot. This
should be a dict with format: `{'layout':
layoutTemplate, 'data': {trace_type: [traceTemplate,
...], ...}}` where `layoutTemplate` is a dict matching
the structure of `figure.layout` and `traceTemplate` is
a dict matching the structure of the trace with type
`trace_type` (e.g. 'scatter'). Alternatively, this may
be specified as an instance of
plotly.graph_objs.layout.Template. Trace templates are
applied cyclically to traces of each type. Container
arrays (eg `annotations`) have special handling: An
object ending in `defaults` (eg `annotationdefaults`)
is applied to each array item. But if an item has a
`templateitemname` key we look in the template array
for an item with matching `name` and apply that
instead. If no matching `name` is found we mark the
item invisible. Any named template item not referenced
is appended to the end of the array, so this can be
used to add a watermark annotation or a logo image, for
example. To omit one of these items on the plot, make
an item with matching `templateitemname` and `visible:
false`.
ternary
:class:`plotly.graph_objects.layout.Ternary` instance
or dict with compatible properties
title
:class:`plotly.graph_objects.layout.Title` instance or
dict with compatible properties
transition
Sets transition options used during Plotly.react
updates.
treemapcolorway
Sets the default treemap slice colors. Defaults to the
main `colorway` used for trace colors. If you specify a
new list here it can still be extended with lighter and
darker colors, see `extendtreemapcolors`.
uirevision
Used to allow user interactions with the plot to
persist after `Plotly.react` calls that are unaware of
these interactions. If `uirevision` is omitted, or if
it is given and it changed from the previous
`Plotly.react` call, the exact new figure is used. If
`uirevision` is truthy and did NOT change, any
attribute that has been affected by user interactions
and did not receive a different value in the new figure
will keep the interaction value. `layout.uirevision`
attribute serves as the default for `uirevision`
attributes in various sub-containers. For finer control
you can set these sub-attributes directly. For example,
if your app separately controls the data on the x and y
axes you might set `xaxis.uirevision=*time*` and
`yaxis.uirevision=*cost*`. Then if only the y data is
changed, you can update `yaxis.uirevision=*quantity*`
and the y axis range will reset but the x axis range
will retain any user-driven zoom.
uniformtext
:class:`plotly.graph_objects.layout.Uniformtext`
instance or dict with compatible properties
updatemenus
A tuple of
:class:`plotly.graph_objects.layout.Updatemenu`
instances or dicts with compatible properties
updatemenudefaults
When used in a template (as
layout.template.layout.updatemenudefaults), sets the
default property values to use for elements of
layout.updatemenus
violingap
Sets the gap (in plot fraction) between violins of
adjacent location coordinates. Has no effect on traces
that have "width" set.
violingroupgap
Sets the gap (in plot fraction) between violins of the
same location coordinate. Has no effect on traces that
have "width" set.
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. Has no effect on traces that
have "width" set.
waterfallgap
Sets the gap (in plot fraction) between bars of
adjacent location coordinates.
waterfallgroupgap
Sets the gap (in plot fraction) between bars of the
same location coordinate.
waterfallmode
Determines how bars at the same location coordinate are
displayed on the graph. 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 reduce "opacity" to see
multiple bars.
width
Sets the plot's width (in px).
xaxis
:class:`plotly.graph_objects.layout.XAxis` instance or
dict with compatible properties
yaxis
:class:`plotly.graph_objects.layout.YAxis` instance or
dict with compatible properties
Returns
-------
Layout
"""
super().__init__("layout")
if "_parent" in kwargs:
self._parent = kwargs["_parent"]
return
self._valid_props = {
"activeselection",
"activeshape",
"annotationdefaults",
"annotations",
"autosize",
"autotypenumbers",
"barcornerradius",
"bargap",
"bargroupgap",
"barmode",
"barnorm",
"boxgap",
"boxgroupgap",
"boxmode",
"calendar",
"clickmode",
"coloraxis",
"colorscale",
"colorway",
"computed",
"datarevision",
"dragmode",
"editrevision",
"extendfunnelareacolors",
"extendiciclecolors",
"extendpiecolors",
"extendsunburstcolors",
"extendtreemapcolors",
"font",
"funnelareacolorway",
"funnelgap",
"funnelgroupgap",
"funnelmode",
"geo",
"grid",
"height",
"hiddenlabels",
"hiddenlabelssrc",
"hidesources",
"hoverdistance",
"hoverlabel",
"hovermode",
"hoversubplots",
"iciclecolorway",
"imagedefaults",
"images",
"legend",
"map",
"mapbox",
"margin",
"meta",
"metasrc",
"minreducedheight",
"minreducedwidth",
"modebar",
"newselection",
"newshape",
"paper_bgcolor",
"piecolorway",
"plot_bgcolor",
"polar",
"scattergap",
"scattermode",
"scene",
"selectdirection",
"selectiondefaults",
"selectionrevision",
"selections",
"separators",
"shapedefaults",
"shapes",
"showlegend",
"sliderdefaults",
"sliders",
"smith",
"spikedistance",
"sunburstcolorway",
"template",
"ternary",
"title",
"transition",
"treemapcolorway",
"uirevision",
"uniformtext",
"updatemenudefaults",
"updatemenus",
"violingap",
"violingroupgap",
"violinmode",
"waterfallgap",
"waterfallgroupgap",
"waterfallmode",
"width",
"xaxis",
"yaxis",
}
if arg is None:
arg = {}
elif isinstance(arg, self.__class__):
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 :class:`plotly.graph_objs.Layout`""")
self._skip_invalid = kwargs.pop("skip_invalid", False)
self._validate = kwargs.pop("_validate", True)
self._set_property("activeselection", arg, activeselection)
self._set_property("activeshape", arg, activeshape)
self._set_property("annotations", arg, annotations)
self._set_property("annotationdefaults", arg, annotationdefaults)
self._set_property("autosize", arg, autosize)
self._set_property("autotypenumbers", arg, autotypenumbers)
self._set_property("barcornerradius", arg, barcornerradius)
self._set_property("bargap", arg, bargap)
self._set_property("bargroupgap", arg, bargroupgap)
self._set_property("barmode", arg, barmode)
self._set_property("barnorm", arg, barnorm)
self._set_property("boxgap", arg, boxgap)
self._set_property("boxgroupgap", arg, boxgroupgap)
self._set_property("boxmode", arg, boxmode)
self._set_property("calendar", arg, calendar)
self._set_property("clickmode", arg, clickmode)
self._set_property("coloraxis", arg, coloraxis)
self._set_property("colorscale", arg, colorscale)
self._set_property("colorway", arg, colorway)
self._set_property("computed", arg, computed)
self._set_property("datarevision", arg, datarevision)
self._set_property("dragmode", arg, dragmode)
self._set_property("editrevision", arg, editrevision)
self._set_property("extendfunnelareacolors", arg, extendfunnelareacolors)
self._set_property("extendiciclecolors", arg, extendiciclecolors)
self._set_property("extendpiecolors", arg, extendpiecolors)
self._set_property("extendsunburstcolors", arg, extendsunburstcolors)
self._set_property("extendtreemapcolors", arg, extendtreemapcolors)
self._set_property("font", arg, font)
self._set_property("funnelareacolorway", arg, funnelareacolorway)
self._set_property("funnelgap", arg, funnelgap)
self._set_property("funnelgroupgap", arg, funnelgroupgap)
self._set_property("funnelmode", arg, funnelmode)
self._set_property("geo", arg, geo)
self._set_property("grid", arg, grid)
self._set_property("height", arg, height)
self._set_property("hiddenlabels", arg, hiddenlabels)
self._set_property("hiddenlabelssrc", arg, hiddenlabelssrc)
self._set_property("hidesources", arg, hidesources)
self._set_property("hoverdistance", arg, hoverdistance)
self._set_property("hoverlabel", arg, hoverlabel)
self._set_property("hovermode", arg, hovermode)
self._set_property("hoversubplots", arg, hoversubplots)
self._set_property("iciclecolorway", arg, iciclecolorway)
self._set_property("images", arg, images)
self._set_property("imagedefaults", arg, imagedefaults)
self._set_property("legend", arg, legend)
self._set_property("map", arg, map)
self._set_property("mapbox", arg, mapbox)
self._set_property("margin", arg, margin)
self._set_property("meta", arg, meta)
self._set_property("metasrc", arg, metasrc)
self._set_property("minreducedheight", arg, minreducedheight)
self._set_property("minreducedwidth", arg, minreducedwidth)
self._set_property("modebar", arg, modebar)
self._set_property("newselection", arg, newselection)
self._set_property("newshape", arg, newshape)
self._set_property("paper_bgcolor", arg, paper_bgcolor)
self._set_property("piecolorway", arg, piecolorway)
self._set_property("plot_bgcolor", arg, plot_bgcolor)
self._set_property("polar", arg, polar)
self._set_property("scattergap", arg, scattergap)
self._set_property("scattermode", arg, scattermode)
self._set_property("scene", arg, scene)
self._set_property("selectdirection", arg, selectdirection)
self._set_property("selectionrevision", arg, selectionrevision)
self._set_property("selections", arg, selections)
self._set_property("selectiondefaults", arg, selectiondefaults)
self._set_property("separators", arg, separators)
self._set_property("shapes", arg, shapes)
self._set_property("shapedefaults", arg, shapedefaults)
self._set_property("showlegend", arg, showlegend)
self._set_property("sliders", arg, sliders)
self._set_property("sliderdefaults", arg, sliderdefaults)
self._set_property("smith", arg, smith)
self._set_property("spikedistance", arg, spikedistance)
self._set_property("sunburstcolorway", arg, sunburstcolorway)
self._set_property("template", arg, template)
self._set_property("ternary", arg, ternary)
self._set_property("title", arg, title)
self._set_property("transition", arg, transition)
self._set_property("treemapcolorway", arg, treemapcolorway)
self._set_property("uirevision", arg, uirevision)
self._set_property("uniformtext", arg, uniformtext)
self._set_property("updatemenus", arg, updatemenus)
self._set_property("updatemenudefaults", arg, updatemenudefaults)
self._set_property("violingap", arg, violingap)
self._set_property("violingroupgap", arg, violingroupgap)
self._set_property("violinmode", arg, violinmode)
self._set_property("waterfallgap", arg, waterfallgap)
self._set_property("waterfallgroupgap", arg, waterfallgroupgap)
self._set_property("waterfallmode", arg, waterfallmode)
self._set_property("width", arg, width)
self._set_property("xaxis", arg, xaxis)
self._set_property("yaxis", arg, yaxis)
self._process_kwargs(**dict(arg, **kwargs))
self._skip_invalid = False