2004 lines
71 KiB
Python
2004 lines
71 KiB
Python
from plotly.basedatatypes import BaseTraceType as _BaseTraceType
|
||
import copy as _copy
|
||
|
||
|
||
class Carpet(_BaseTraceType):
|
||
|
||
# class properties
|
||
# --------------------
|
||
_parent_path_str = ""
|
||
_path_str = "carpet"
|
||
_valid_props = {
|
||
"a",
|
||
"a0",
|
||
"aaxis",
|
||
"asrc",
|
||
"b",
|
||
"b0",
|
||
"baxis",
|
||
"bsrc",
|
||
"carpet",
|
||
"cheaterslope",
|
||
"color",
|
||
"customdata",
|
||
"customdatasrc",
|
||
"da",
|
||
"db",
|
||
"font",
|
||
"ids",
|
||
"idssrc",
|
||
"legend",
|
||
"legendgrouptitle",
|
||
"legendrank",
|
||
"legendwidth",
|
||
"meta",
|
||
"metasrc",
|
||
"name",
|
||
"opacity",
|
||
"stream",
|
||
"type",
|
||
"uid",
|
||
"uirevision",
|
||
"visible",
|
||
"x",
|
||
"xaxis",
|
||
"xsrc",
|
||
"y",
|
||
"yaxis",
|
||
"ysrc",
|
||
}
|
||
|
||
# a
|
||
# -
|
||
@property
|
||
def a(self):
|
||
"""
|
||
An array containing values of the first parameter value
|
||
|
||
The 'a' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["a"]
|
||
|
||
@a.setter
|
||
def a(self, val):
|
||
self["a"] = val
|
||
|
||
# a0
|
||
# --
|
||
@property
|
||
def a0(self):
|
||
"""
|
||
Alternate to `a`. Builds a linear space of a coordinates. Use
|
||
with `da` where `a0` is the starting coordinate and `da` the
|
||
step.
|
||
|
||
The 'a0' property is a number and may be specified as:
|
||
- An int or float
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["a0"]
|
||
|
||
@a0.setter
|
||
def a0(self, val):
|
||
self["a0"] = val
|
||
|
||
# aaxis
|
||
# -----
|
||
@property
|
||
def aaxis(self):
|
||
"""
|
||
The 'aaxis' property is an instance of Aaxis
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.carpet.Aaxis`
|
||
- A dict of string/value properties that will be passed
|
||
to the Aaxis constructor
|
||
|
||
Supported dict properties:
|
||
|
||
arraydtick
|
||
The stride between grid lines along the axis
|
||
arraytick0
|
||
The starting index of grid lines along the axis
|
||
autorange
|
||
Determines whether or not the range of this
|
||
axis is computed in relation to the input data.
|
||
See `rangemode` for more info. If `range` is
|
||
provided, then `autorange` is set to False.
|
||
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. Defaults to
|
||
layout.autotypenumbers.
|
||
categoryarray
|
||
Sets the order in which categories on this axis
|
||
appear. Only has an effect if `categoryorder`
|
||
is set to "array". Used with `categoryorder`.
|
||
categoryarraysrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `categoryarray`.
|
||
categoryorder
|
||
Specifies the ordering logic for the case of
|
||
categorical variables. By default, plotly uses
|
||
"trace", which specifies the order that is
|
||
present in the data supplied. Set
|
||
`categoryorder` to *category ascending* or
|
||
*category descending* if order should be
|
||
determined by the alphanumerical order of the
|
||
category names. Set `categoryorder` to "array"
|
||
to derive the ordering from the attribute
|
||
`categoryarray`. If a category is not found in
|
||
the `categoryarray` array, the sorting behavior
|
||
for that attribute will be identical to the
|
||
"trace" mode. The unspecified categories will
|
||
follow the categories in `categoryarray`.
|
||
cheatertype
|
||
|
||
color
|
||
Sets default for all colors associated with
|
||
this axis all at once: line, font, tick, and
|
||
grid colors. Grid color is lightened by
|
||
blending this with the plot background
|
||
Individual pieces can override this.
|
||
dtick
|
||
The stride between grid lines along the axis
|
||
endline
|
||
Determines whether or not a line is drawn at
|
||
along the final value of this axis. If True,
|
||
the end line is drawn on top of the grid lines.
|
||
endlinecolor
|
||
Sets the line color of the end line.
|
||
endlinewidth
|
||
Sets the width (in px) of the end line.
|
||
exponentformat
|
||
Determines a formatting rule for the tick
|
||
exponents. For example, consider the number
|
||
1,000,000,000. If "none", it appears as
|
||
1,000,000,000. If "e", 1e+9. If "E", 1E+9. If
|
||
"power", 1x10^9 (with 9 in a super script). If
|
||
"SI", 1G. If "B", 1B.
|
||
fixedrange
|
||
Determines whether or not this axis is zoom-
|
||
able. If true, then zoom is disabled.
|
||
gridcolor
|
||
Sets the axis line color.
|
||
griddash
|
||
Sets the dash style of lines. Set to a dash
|
||
type string ("solid", "dot", "dash",
|
||
"longdash", "dashdot", or "longdashdot") or a
|
||
dash length list in px (eg "5px,10px,2px,2px").
|
||
gridwidth
|
||
Sets the width (in px) of the axis line.
|
||
labelalias
|
||
Replacement text for specific tick or hover
|
||
labels. For example using {US: 'USA', CA:
|
||
'Canada'} changes US to USA and CA to Canada.
|
||
The labels we would have shown must match the
|
||
keys exactly, after adding any tickprefix or
|
||
ticksuffix. For negative numbers the minus sign
|
||
symbol used (U+2212) is wider than the regular
|
||
ascii dash. That means you need to use −1
|
||
instead of -1. labelalias can be used with any
|
||
axis type, and both keys (if needed) and values
|
||
(if desired) can include html-like tags or
|
||
MathJax.
|
||
labelpadding
|
||
Extra padding between label and the axis
|
||
labelprefix
|
||
Sets a axis label prefix.
|
||
labelsuffix
|
||
Sets a axis label suffix.
|
||
linecolor
|
||
Sets the axis line color.
|
||
linewidth
|
||
Sets the width (in px) of the axis line.
|
||
minexponent
|
||
Hide SI prefix for 10^n if |n| is below this
|
||
number
|
||
minorgridcolor
|
||
Sets the color of the grid lines.
|
||
minorgridcount
|
||
Sets the number of minor grid ticks per major
|
||
grid tick
|
||
minorgriddash
|
||
Sets the dash style of lines. Set to a dash
|
||
type string ("solid", "dot", "dash",
|
||
"longdash", "dashdot", or "longdashdot") or a
|
||
dash length list in px (eg "5px,10px,2px,2px").
|
||
minorgridwidth
|
||
Sets the width (in px) of the grid lines.
|
||
nticks
|
||
Specifies the maximum number of ticks for the
|
||
particular axis. The actual number of ticks
|
||
will be chosen automatically to be less than or
|
||
equal to `nticks`. Has an effect only if
|
||
`tickmode` is set to "auto".
|
||
range
|
||
Sets the range of this axis. If the axis `type`
|
||
is "log", then you must take the log of your
|
||
desired range (e.g. to set the range from 1 to
|
||
100, set the range from 0 to 2). If the axis
|
||
`type` is "date", it should be date strings,
|
||
like date data, though Date objects and unix
|
||
milliseconds will be accepted and converted to
|
||
strings. If the axis `type` is "category", it
|
||
should be numbers, using the scale where each
|
||
category is assigned a serial number from zero
|
||
in the order it appears.
|
||
rangemode
|
||
If "normal", the range is computed in relation
|
||
to the extrema of the input data. If *tozero*`,
|
||
the range extends to 0, regardless of the input
|
||
data If "nonnegative", the range is non-
|
||
negative, regardless of the input data.
|
||
separatethousands
|
||
If "true", even 4-digit integers are separated
|
||
showexponent
|
||
If "all", all exponents are shown besides their
|
||
significands. If "first", only the exponent of
|
||
the first tick is shown. If "last", only the
|
||
exponent of the last tick is shown. If "none",
|
||
no exponents appear.
|
||
showgrid
|
||
Determines whether or not grid lines are drawn.
|
||
If True, the grid lines are drawn at every tick
|
||
mark.
|
||
showline
|
||
Determines whether or not a line bounding this
|
||
axis is drawn.
|
||
showticklabels
|
||
Determines whether axis labels are drawn on the
|
||
low side, the high side, both, or neither side
|
||
of the axis.
|
||
showtickprefix
|
||
If "all", all tick labels are displayed with a
|
||
prefix. If "first", only the first tick is
|
||
displayed with a prefix. If "last", only the
|
||
last tick is displayed with a suffix. If
|
||
"none", tick prefixes are hidden.
|
||
showticksuffix
|
||
Same as `showtickprefix` but for tick suffixes.
|
||
smoothing
|
||
|
||
startline
|
||
Determines whether or not a line is drawn at
|
||
along the starting value of this axis. If True,
|
||
the start line is drawn on top of the grid
|
||
lines.
|
||
startlinecolor
|
||
Sets the line color of the start line.
|
||
startlinewidth
|
||
Sets the width (in px) of the start line.
|
||
tick0
|
||
The starting index of grid lines along the axis
|
||
tickangle
|
||
Sets the angle of the tick labels with respect
|
||
to the horizontal. For example, a `tickangle`
|
||
of -90 draws the tick labels vertically.
|
||
tickfont
|
||
Sets the tick font.
|
||
tickformat
|
||
Sets the tick label formatting rule using d3
|
||
formatting mini-languages which are very
|
||
similar to those in Python. For numbers, see: h
|
||
ttps://github.com/d3/d3-format/tree/v1.4.5#d3-
|
||
format. And for dates see:
|
||
https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format. We add two
|
||
items to d3's date formatter: "%h" for half of
|
||
the year as a decimal number as well as "%{n}f"
|
||
for fractional seconds with n digits. For
|
||
example, *2016-10-13 09:15:23.456* with
|
||
tickformat "%H~%M~%S.%2f" would display
|
||
"09~15~23.46"
|
||
tickformatstops
|
||
A tuple of :class:`plotly.graph_objects.carpet.
|
||
aaxis.Tickformatstop` instances or dicts with
|
||
compatible properties
|
||
tickformatstopdefaults
|
||
When used in a template (as layout.template.dat
|
||
a.carpet.aaxis.tickformatstopdefaults), sets
|
||
the default property values to use for elements
|
||
of carpet.aaxis.tickformatstops
|
||
tickmode
|
||
|
||
tickprefix
|
||
Sets a tick label prefix.
|
||
ticksuffix
|
||
Sets a tick label suffix.
|
||
ticktext
|
||
Sets the text displayed at the ticks position
|
||
via `tickvals`. Only has an effect if
|
||
`tickmode` is set to "array". Used with
|
||
`tickvals`.
|
||
ticktextsrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `ticktext`.
|
||
tickvals
|
||
Sets the values at which ticks on this axis
|
||
appear. Only has an effect if `tickmode` is set
|
||
to "array". Used with `ticktext`.
|
||
tickvalssrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `tickvals`.
|
||
title
|
||
:class:`plotly.graph_objects.carpet.aaxis.Title
|
||
` instance or dict with compatible properties
|
||
titlefont
|
||
Deprecated: Please use carpet.aaxis.title.font
|
||
instead. Sets this axis' title font. Note that
|
||
the title's font used to be set by the now
|
||
deprecated `titlefont` attribute.
|
||
titleoffset
|
||
Deprecated: Please use
|
||
carpet.aaxis.title.offset instead. An
|
||
additional amount by which to offset the title
|
||
from the tick labels, given in pixels. Note
|
||
that this used to be set by the now deprecated
|
||
`titleoffset` attribute.
|
||
type
|
||
Sets the axis type. By default, plotly attempts
|
||
to determined the axis type by looking into the
|
||
data of the traces that referenced the axis in
|
||
question.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.carpet.Aaxis
|
||
"""
|
||
return self["aaxis"]
|
||
|
||
@aaxis.setter
|
||
def aaxis(self, val):
|
||
self["aaxis"] = val
|
||
|
||
# asrc
|
||
# ----
|
||
@property
|
||
def asrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `a`.
|
||
|
||
The 'asrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["asrc"]
|
||
|
||
@asrc.setter
|
||
def asrc(self, val):
|
||
self["asrc"] = val
|
||
|
||
# b
|
||
# -
|
||
@property
|
||
def b(self):
|
||
"""
|
||
A two dimensional array of y coordinates at each carpet point.
|
||
|
||
The 'b' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["b"]
|
||
|
||
@b.setter
|
||
def b(self, val):
|
||
self["b"] = val
|
||
|
||
# b0
|
||
# --
|
||
@property
|
||
def b0(self):
|
||
"""
|
||
Alternate to `b`. Builds a linear space of a coordinates. Use
|
||
with `db` where `b0` is the starting coordinate and `db` the
|
||
step.
|
||
|
||
The 'b0' property is a number and may be specified as:
|
||
- An int or float
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["b0"]
|
||
|
||
@b0.setter
|
||
def b0(self, val):
|
||
self["b0"] = val
|
||
|
||
# baxis
|
||
# -----
|
||
@property
|
||
def baxis(self):
|
||
"""
|
||
The 'baxis' property is an instance of Baxis
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.carpet.Baxis`
|
||
- A dict of string/value properties that will be passed
|
||
to the Baxis constructor
|
||
|
||
Supported dict properties:
|
||
|
||
arraydtick
|
||
The stride between grid lines along the axis
|
||
arraytick0
|
||
The starting index of grid lines along the axis
|
||
autorange
|
||
Determines whether or not the range of this
|
||
axis is computed in relation to the input data.
|
||
See `rangemode` for more info. If `range` is
|
||
provided, then `autorange` is set to False.
|
||
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. Defaults to
|
||
layout.autotypenumbers.
|
||
categoryarray
|
||
Sets the order in which categories on this axis
|
||
appear. Only has an effect if `categoryorder`
|
||
is set to "array". Used with `categoryorder`.
|
||
categoryarraysrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `categoryarray`.
|
||
categoryorder
|
||
Specifies the ordering logic for the case of
|
||
categorical variables. By default, plotly uses
|
||
"trace", which specifies the order that is
|
||
present in the data supplied. Set
|
||
`categoryorder` to *category ascending* or
|
||
*category descending* if order should be
|
||
determined by the alphanumerical order of the
|
||
category names. Set `categoryorder` to "array"
|
||
to derive the ordering from the attribute
|
||
`categoryarray`. If a category is not found in
|
||
the `categoryarray` array, the sorting behavior
|
||
for that attribute will be identical to the
|
||
"trace" mode. The unspecified categories will
|
||
follow the categories in `categoryarray`.
|
||
cheatertype
|
||
|
||
color
|
||
Sets default for all colors associated with
|
||
this axis all at once: line, font, tick, and
|
||
grid colors. Grid color is lightened by
|
||
blending this with the plot background
|
||
Individual pieces can override this.
|
||
dtick
|
||
The stride between grid lines along the axis
|
||
endline
|
||
Determines whether or not a line is drawn at
|
||
along the final value of this axis. If True,
|
||
the end line is drawn on top of the grid lines.
|
||
endlinecolor
|
||
Sets the line color of the end line.
|
||
endlinewidth
|
||
Sets the width (in px) of the end line.
|
||
exponentformat
|
||
Determines a formatting rule for the tick
|
||
exponents. For example, consider the number
|
||
1,000,000,000. If "none", it appears as
|
||
1,000,000,000. If "e", 1e+9. If "E", 1E+9. If
|
||
"power", 1x10^9 (with 9 in a super script). If
|
||
"SI", 1G. If "B", 1B.
|
||
fixedrange
|
||
Determines whether or not this axis is zoom-
|
||
able. If true, then zoom is disabled.
|
||
gridcolor
|
||
Sets the axis line color.
|
||
griddash
|
||
Sets the dash style of lines. Set to a dash
|
||
type string ("solid", "dot", "dash",
|
||
"longdash", "dashdot", or "longdashdot") or a
|
||
dash length list in px (eg "5px,10px,2px,2px").
|
||
gridwidth
|
||
Sets the width (in px) of the axis line.
|
||
labelalias
|
||
Replacement text for specific tick or hover
|
||
labels. For example using {US: 'USA', CA:
|
||
'Canada'} changes US to USA and CA to Canada.
|
||
The labels we would have shown must match the
|
||
keys exactly, after adding any tickprefix or
|
||
ticksuffix. For negative numbers the minus sign
|
||
symbol used (U+2212) is wider than the regular
|
||
ascii dash. That means you need to use −1
|
||
instead of -1. labelalias can be used with any
|
||
axis type, and both keys (if needed) and values
|
||
(if desired) can include html-like tags or
|
||
MathJax.
|
||
labelpadding
|
||
Extra padding between label and the axis
|
||
labelprefix
|
||
Sets a axis label prefix.
|
||
labelsuffix
|
||
Sets a axis label suffix.
|
||
linecolor
|
||
Sets the axis line color.
|
||
linewidth
|
||
Sets the width (in px) of the axis line.
|
||
minexponent
|
||
Hide SI prefix for 10^n if |n| is below this
|
||
number
|
||
minorgridcolor
|
||
Sets the color of the grid lines.
|
||
minorgridcount
|
||
Sets the number of minor grid ticks per major
|
||
grid tick
|
||
minorgriddash
|
||
Sets the dash style of lines. Set to a dash
|
||
type string ("solid", "dot", "dash",
|
||
"longdash", "dashdot", or "longdashdot") or a
|
||
dash length list in px (eg "5px,10px,2px,2px").
|
||
minorgridwidth
|
||
Sets the width (in px) of the grid lines.
|
||
nticks
|
||
Specifies the maximum number of ticks for the
|
||
particular axis. The actual number of ticks
|
||
will be chosen automatically to be less than or
|
||
equal to `nticks`. Has an effect only if
|
||
`tickmode` is set to "auto".
|
||
range
|
||
Sets the range of this axis. If the axis `type`
|
||
is "log", then you must take the log of your
|
||
desired range (e.g. to set the range from 1 to
|
||
100, set the range from 0 to 2). If the axis
|
||
`type` is "date", it should be date strings,
|
||
like date data, though Date objects and unix
|
||
milliseconds will be accepted and converted to
|
||
strings. If the axis `type` is "category", it
|
||
should be numbers, using the scale where each
|
||
category is assigned a serial number from zero
|
||
in the order it appears.
|
||
rangemode
|
||
If "normal", the range is computed in relation
|
||
to the extrema of the input data. If *tozero*`,
|
||
the range extends to 0, regardless of the input
|
||
data If "nonnegative", the range is non-
|
||
negative, regardless of the input data.
|
||
separatethousands
|
||
If "true", even 4-digit integers are separated
|
||
showexponent
|
||
If "all", all exponents are shown besides their
|
||
significands. If "first", only the exponent of
|
||
the first tick is shown. If "last", only the
|
||
exponent of the last tick is shown. If "none",
|
||
no exponents appear.
|
||
showgrid
|
||
Determines whether or not grid lines are drawn.
|
||
If True, the grid lines are drawn at every tick
|
||
mark.
|
||
showline
|
||
Determines whether or not a line bounding this
|
||
axis is drawn.
|
||
showticklabels
|
||
Determines whether axis labels are drawn on the
|
||
low side, the high side, both, or neither side
|
||
of the axis.
|
||
showtickprefix
|
||
If "all", all tick labels are displayed with a
|
||
prefix. If "first", only the first tick is
|
||
displayed with a prefix. If "last", only the
|
||
last tick is displayed with a suffix. If
|
||
"none", tick prefixes are hidden.
|
||
showticksuffix
|
||
Same as `showtickprefix` but for tick suffixes.
|
||
smoothing
|
||
|
||
startline
|
||
Determines whether or not a line is drawn at
|
||
along the starting value of this axis. If True,
|
||
the start line is drawn on top of the grid
|
||
lines.
|
||
startlinecolor
|
||
Sets the line color of the start line.
|
||
startlinewidth
|
||
Sets the width (in px) of the start line.
|
||
tick0
|
||
The starting index of grid lines along the axis
|
||
tickangle
|
||
Sets the angle of the tick labels with respect
|
||
to the horizontal. For example, a `tickangle`
|
||
of -90 draws the tick labels vertically.
|
||
tickfont
|
||
Sets the tick font.
|
||
tickformat
|
||
Sets the tick label formatting rule using d3
|
||
formatting mini-languages which are very
|
||
similar to those in Python. For numbers, see: h
|
||
ttps://github.com/d3/d3-format/tree/v1.4.5#d3-
|
||
format. And for dates see:
|
||
https://github.com/d3/d3-time-
|
||
format/tree/v2.2.3#locale_format. We add two
|
||
items to d3's date formatter: "%h" for half of
|
||
the year as a decimal number as well as "%{n}f"
|
||
for fractional seconds with n digits. For
|
||
example, *2016-10-13 09:15:23.456* with
|
||
tickformat "%H~%M~%S.%2f" would display
|
||
"09~15~23.46"
|
||
tickformatstops
|
||
A tuple of :class:`plotly.graph_objects.carpet.
|
||
baxis.Tickformatstop` instances or dicts with
|
||
compatible properties
|
||
tickformatstopdefaults
|
||
When used in a template (as layout.template.dat
|
||
a.carpet.baxis.tickformatstopdefaults), sets
|
||
the default property values to use for elements
|
||
of carpet.baxis.tickformatstops
|
||
tickmode
|
||
|
||
tickprefix
|
||
Sets a tick label prefix.
|
||
ticksuffix
|
||
Sets a tick label suffix.
|
||
ticktext
|
||
Sets the text displayed at the ticks position
|
||
via `tickvals`. Only has an effect if
|
||
`tickmode` is set to "array". Used with
|
||
`tickvals`.
|
||
ticktextsrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `ticktext`.
|
||
tickvals
|
||
Sets the values at which ticks on this axis
|
||
appear. Only has an effect if `tickmode` is set
|
||
to "array". Used with `ticktext`.
|
||
tickvalssrc
|
||
Sets the source reference on Chart Studio Cloud
|
||
for `tickvals`.
|
||
title
|
||
:class:`plotly.graph_objects.carpet.baxis.Title
|
||
` instance or dict with compatible properties
|
||
titlefont
|
||
Deprecated: Please use carpet.baxis.title.font
|
||
instead. Sets this axis' title font. Note that
|
||
the title's font used to be set by the now
|
||
deprecated `titlefont` attribute.
|
||
titleoffset
|
||
Deprecated: Please use
|
||
carpet.baxis.title.offset instead. An
|
||
additional amount by which to offset the title
|
||
from the tick labels, given in pixels. Note
|
||
that this used to be set by the now deprecated
|
||
`titleoffset` attribute.
|
||
type
|
||
Sets the axis type. By default, plotly attempts
|
||
to determined the axis type by looking into the
|
||
data of the traces that referenced the axis in
|
||
question.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.carpet.Baxis
|
||
"""
|
||
return self["baxis"]
|
||
|
||
@baxis.setter
|
||
def baxis(self, val):
|
||
self["baxis"] = val
|
||
|
||
# bsrc
|
||
# ----
|
||
@property
|
||
def bsrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `b`.
|
||
|
||
The 'bsrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["bsrc"]
|
||
|
||
@bsrc.setter
|
||
def bsrc(self, val):
|
||
self["bsrc"] = val
|
||
|
||
# carpet
|
||
# ------
|
||
@property
|
||
def carpet(self):
|
||
"""
|
||
An identifier for this carpet, so that `scattercarpet` and
|
||
`contourcarpet` traces can specify a carpet plot on which they
|
||
lie
|
||
|
||
The 'carpet' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["carpet"]
|
||
|
||
@carpet.setter
|
||
def carpet(self, val):
|
||
self["carpet"] = val
|
||
|
||
# cheaterslope
|
||
# ------------
|
||
@property
|
||
def cheaterslope(self):
|
||
"""
|
||
The shift applied to each successive row of data in creating a
|
||
cheater plot. Only used if `x` is been omitted.
|
||
|
||
The 'cheaterslope' property is a number and may be specified as:
|
||
- An int or float
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["cheaterslope"]
|
||
|
||
@cheaterslope.setter
|
||
def cheaterslope(self, val):
|
||
self["cheaterslope"] = val
|
||
|
||
# color
|
||
# -----
|
||
@property
|
||
def color(self):
|
||
"""
|
||
Sets default for all colors associated with this axis all at
|
||
once: line, font, tick, and grid colors. Grid color is
|
||
lightened by blending this with the plot background Individual
|
||
pieces can override this.
|
||
|
||
The 'color' property is a color and may be specified as:
|
||
- A hex string (e.g. '#ff0000')
|
||
- An rgb/rgba string (e.g. 'rgb(255,0,0)')
|
||
- An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
|
||
- An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
|
||
- A named CSS color:
|
||
aliceblue, antiquewhite, aqua, aquamarine, azure,
|
||
beige, bisque, black, blanchedalmond, blue,
|
||
blueviolet, brown, burlywood, cadetblue,
|
||
chartreuse, chocolate, coral, cornflowerblue,
|
||
cornsilk, crimson, cyan, darkblue, darkcyan,
|
||
darkgoldenrod, darkgray, darkgrey, darkgreen,
|
||
darkkhaki, darkmagenta, darkolivegreen, darkorange,
|
||
darkorchid, darkred, darksalmon, darkseagreen,
|
||
darkslateblue, darkslategray, darkslategrey,
|
||
darkturquoise, darkviolet, deeppink, deepskyblue,
|
||
dimgray, dimgrey, dodgerblue, firebrick,
|
||
floralwhite, forestgreen, fuchsia, gainsboro,
|
||
ghostwhite, gold, goldenrod, gray, grey, green,
|
||
greenyellow, honeydew, hotpink, indianred, indigo,
|
||
ivory, khaki, lavender, lavenderblush, lawngreen,
|
||
lemonchiffon, lightblue, lightcoral, lightcyan,
|
||
lightgoldenrodyellow, lightgray, lightgrey,
|
||
lightgreen, lightpink, lightsalmon, lightseagreen,
|
||
lightskyblue, lightslategray, lightslategrey,
|
||
lightsteelblue, lightyellow, lime, limegreen,
|
||
linen, magenta, maroon, mediumaquamarine,
|
||
mediumblue, mediumorchid, mediumpurple,
|
||
mediumseagreen, mediumslateblue, mediumspringgreen,
|
||
mediumturquoise, mediumvioletred, midnightblue,
|
||
mintcream, mistyrose, moccasin, navajowhite, navy,
|
||
oldlace, olive, olivedrab, orange, orangered,
|
||
orchid, palegoldenrod, palegreen, paleturquoise,
|
||
palevioletred, papayawhip, peachpuff, peru, pink,
|
||
plum, powderblue, purple, red, rosybrown,
|
||
royalblue, rebeccapurple, saddlebrown, salmon,
|
||
sandybrown, seagreen, seashell, sienna, silver,
|
||
skyblue, slateblue, slategray, slategrey, snow,
|
||
springgreen, steelblue, tan, teal, thistle, tomato,
|
||
turquoise, violet, wheat, white, whitesmoke,
|
||
yellow, yellowgreen
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["color"]
|
||
|
||
@color.setter
|
||
def color(self, val):
|
||
self["color"] = val
|
||
|
||
# customdata
|
||
# ----------
|
||
@property
|
||
def customdata(self):
|
||
"""
|
||
Assigns extra data each datum. This may be useful when
|
||
listening to hover, click and selection events. Note that,
|
||
"scatter" traces also appends customdata items in the markers
|
||
DOM elements
|
||
|
||
The 'customdata' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["customdata"]
|
||
|
||
@customdata.setter
|
||
def customdata(self, val):
|
||
self["customdata"] = val
|
||
|
||
# customdatasrc
|
||
# -------------
|
||
@property
|
||
def customdatasrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`customdata`.
|
||
|
||
The 'customdatasrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["customdatasrc"]
|
||
|
||
@customdatasrc.setter
|
||
def customdatasrc(self, val):
|
||
self["customdatasrc"] = val
|
||
|
||
# da
|
||
# --
|
||
@property
|
||
def da(self):
|
||
"""
|
||
Sets the a coordinate step. See `a0` for more info.
|
||
|
||
The 'da' property is a number and may be specified as:
|
||
- An int or float
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["da"]
|
||
|
||
@da.setter
|
||
def da(self, val):
|
||
self["da"] = val
|
||
|
||
# db
|
||
# --
|
||
@property
|
||
def db(self):
|
||
"""
|
||
Sets the b coordinate step. See `b0` for more info.
|
||
|
||
The 'db' property is a number and may be specified as:
|
||
- An int or float
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["db"]
|
||
|
||
@db.setter
|
||
def db(self, val):
|
||
self["db"] = val
|
||
|
||
# font
|
||
# ----
|
||
@property
|
||
def font(self):
|
||
"""
|
||
The default font used for axis & tick labels on this carpet
|
||
|
||
The 'font' property is an instance of Font
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.carpet.Font`
|
||
- A dict of string/value properties that will be passed
|
||
to the Font constructor
|
||
|
||
Supported dict properties:
|
||
|
||
color
|
||
|
||
family
|
||
HTML font family - the typeface that will be
|
||
applied by the web browser. The web browser
|
||
will only be able to apply a font if it is
|
||
available on the system which it operates.
|
||
Provide multiple font families, separated by
|
||
commas, to indicate the preference in which to
|
||
apply fonts if they aren't available on the
|
||
system. The Chart Studio Cloud (at
|
||
https://chart-studio.plotly.com or on-premise)
|
||
generates images on a server, where only a
|
||
select number of fonts are installed and
|
||
supported. These include "Arial", "Balto",
|
||
"Courier New", "Droid Sans",, "Droid Serif",
|
||
"Droid Sans Mono", "Gravitas One", "Old
|
||
Standard TT", "Open Sans", "Overpass", "PT Sans
|
||
Narrow", "Raleway", "Times New Roman".
|
||
size
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.carpet.Font
|
||
"""
|
||
return self["font"]
|
||
|
||
@font.setter
|
||
def font(self, val):
|
||
self["font"] = val
|
||
|
||
# ids
|
||
# ---
|
||
@property
|
||
def ids(self):
|
||
"""
|
||
Assigns id labels to each datum. These ids for object constancy
|
||
of data points during animation. Should be an array of strings,
|
||
not numbers or any other type.
|
||
|
||
The 'ids' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["ids"]
|
||
|
||
@ids.setter
|
||
def ids(self, val):
|
||
self["ids"] = val
|
||
|
||
# idssrc
|
||
# ------
|
||
@property
|
||
def idssrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `ids`.
|
||
|
||
The 'idssrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["idssrc"]
|
||
|
||
@idssrc.setter
|
||
def idssrc(self, val):
|
||
self["idssrc"] = val
|
||
|
||
# legend
|
||
# ------
|
||
@property
|
||
def legend(self):
|
||
"""
|
||
Sets the reference to a legend to show this trace in.
|
||
References to these legends are "legend", "legend2", "legend3",
|
||
etc. Settings for these legends are set in the layout, under
|
||
`layout.legend`, `layout.legend2`, etc.
|
||
|
||
The 'legend' property is an identifier of a particular
|
||
subplot, of type 'legend', that may be specified as the string 'legend'
|
||
optionally followed by an integer >= 1
|
||
(e.g. 'legend', 'legend1', 'legend2', 'legend3', etc.)
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["legend"]
|
||
|
||
@legend.setter
|
||
def legend(self, val):
|
||
self["legend"] = val
|
||
|
||
# legendgrouptitle
|
||
# ----------------
|
||
@property
|
||
def legendgrouptitle(self):
|
||
"""
|
||
The 'legendgrouptitle' property is an instance of Legendgrouptitle
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.carpet.Legendgrouptitle`
|
||
- A dict of string/value properties that will be passed
|
||
to the Legendgrouptitle constructor
|
||
|
||
Supported dict properties:
|
||
|
||
font
|
||
Sets this legend group's title font.
|
||
text
|
||
Sets the title of the legend group.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.carpet.Legendgrouptitle
|
||
"""
|
||
return self["legendgrouptitle"]
|
||
|
||
@legendgrouptitle.setter
|
||
def legendgrouptitle(self, val):
|
||
self["legendgrouptitle"] = val
|
||
|
||
# legendrank
|
||
# ----------
|
||
@property
|
||
def legendrank(self):
|
||
"""
|
||
Sets the legend rank for this trace. Items and groups with
|
||
smaller ranks are presented on top/left side while with
|
||
"reversed" `legend.traceorder` they are on bottom/right side.
|
||
The default legendrank is 1000, so that you can use ranks less
|
||
than 1000 to place certain items before all unranked items, and
|
||
ranks greater than 1000 to go after all unranked items. When
|
||
having unranked or equal rank items shapes would be displayed
|
||
after traces i.e. according to their order in data and layout.
|
||
|
||
The 'legendrank' property is a number and may be specified as:
|
||
- An int or float
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["legendrank"]
|
||
|
||
@legendrank.setter
|
||
def legendrank(self, val):
|
||
self["legendrank"] = val
|
||
|
||
# legendwidth
|
||
# -----------
|
||
@property
|
||
def legendwidth(self):
|
||
"""
|
||
Sets the width (in px or fraction) of the legend for this
|
||
trace.
|
||
|
||
The 'legendwidth' property is a number and may be specified as:
|
||
- An int or float in the interval [0, inf]
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["legendwidth"]
|
||
|
||
@legendwidth.setter
|
||
def legendwidth(self, val):
|
||
self["legendwidth"] = val
|
||
|
||
# meta
|
||
# ----
|
||
@property
|
||
def meta(self):
|
||
"""
|
||
Assigns extra meta information associated with this trace that
|
||
can be used in various text attributes. Attributes such as
|
||
trace `name`, graph, axis and colorbar `title.text`, annotation
|
||
`text` `rangeselector`, `updatemenues` and `sliders` `label`
|
||
text all support `meta`. To access the trace `meta` values in
|
||
an attribute in the same trace, simply use `%{meta[i]}` where
|
||
`i` is the index or key of the `meta` item in question. To
|
||
access trace `meta` in layout attributes, use
|
||
`%{data[n[.meta[i]}` where `i` is the index or key of the
|
||
`meta` and `n` is the trace index.
|
||
|
||
The 'meta' property accepts values of any type
|
||
|
||
Returns
|
||
-------
|
||
Any|numpy.ndarray
|
||
"""
|
||
return self["meta"]
|
||
|
||
@meta.setter
|
||
def meta(self, val):
|
||
self["meta"] = val
|
||
|
||
# metasrc
|
||
# -------
|
||
@property
|
||
def metasrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `meta`.
|
||
|
||
The 'metasrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["metasrc"]
|
||
|
||
@metasrc.setter
|
||
def metasrc(self, val):
|
||
self["metasrc"] = val
|
||
|
||
# name
|
||
# ----
|
||
@property
|
||
def name(self):
|
||
"""
|
||
Sets the trace name. The trace name appears as the legend item
|
||
and on hover.
|
||
|
||
The 'name' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["name"]
|
||
|
||
@name.setter
|
||
def name(self, val):
|
||
self["name"] = val
|
||
|
||
# opacity
|
||
# -------
|
||
@property
|
||
def opacity(self):
|
||
"""
|
||
Sets the opacity of the trace.
|
||
|
||
The 'opacity' property is a number and may be specified as:
|
||
- An int or float in the interval [0, 1]
|
||
|
||
Returns
|
||
-------
|
||
int|float
|
||
"""
|
||
return self["opacity"]
|
||
|
||
@opacity.setter
|
||
def opacity(self, val):
|
||
self["opacity"] = val
|
||
|
||
# stream
|
||
# ------
|
||
@property
|
||
def stream(self):
|
||
"""
|
||
The 'stream' property is an instance of Stream
|
||
that may be specified as:
|
||
- An instance of :class:`plotly.graph_objs.carpet.Stream`
|
||
- A dict of string/value properties that will be passed
|
||
to the Stream constructor
|
||
|
||
Supported dict properties:
|
||
|
||
maxpoints
|
||
Sets the maximum number of points to keep on
|
||
the plots from an incoming stream. If
|
||
`maxpoints` is set to 50, only the newest 50
|
||
points will be displayed on the plot.
|
||
token
|
||
The stream id number links a data trace on a
|
||
plot with a stream. See https://chart-
|
||
studio.plotly.com/settings for more details.
|
||
|
||
Returns
|
||
-------
|
||
plotly.graph_objs.carpet.Stream
|
||
"""
|
||
return self["stream"]
|
||
|
||
@stream.setter
|
||
def stream(self, val):
|
||
self["stream"] = val
|
||
|
||
# uid
|
||
# ---
|
||
@property
|
||
def uid(self):
|
||
"""
|
||
Assign an id to this trace, Use this to provide object
|
||
constancy between traces during animations and transitions.
|
||
|
||
The 'uid' property is a string and must be specified as:
|
||
- A string
|
||
- A number that will be converted to a string
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["uid"]
|
||
|
||
@uid.setter
|
||
def uid(self, val):
|
||
self["uid"] = val
|
||
|
||
# uirevision
|
||
# ----------
|
||
@property
|
||
def uirevision(self):
|
||
"""
|
||
Controls persistence of some user-driven changes to the trace:
|
||
`constraintrange` in `parcoords` traces, as well as some
|
||
`editable: true` modifications such as `name` and
|
||
`colorbar.title`. Defaults to `layout.uirevision`. Note that
|
||
other user-driven trace attribute changes are controlled by
|
||
`layout` attributes: `trace.visible` is controlled by
|
||
`layout.legend.uirevision`, `selectedpoints` is controlled by
|
||
`layout.selectionrevision`, and `colorbar.(x|y)` (accessible
|
||
with `config: {editable: true}`) is controlled by
|
||
`layout.editrevision`. Trace changes are tracked by `uid`,
|
||
which only falls back on trace index if no `uid` is provided.
|
||
So if your app can add/remove traces before the end of the
|
||
`data` array, such that the same trace has a different index,
|
||
you can still preserve user-driven changes if you give each
|
||
trace a `uid` that stays with it as it moves.
|
||
|
||
The 'uirevision' property accepts values of any type
|
||
|
||
Returns
|
||
-------
|
||
Any
|
||
"""
|
||
return self["uirevision"]
|
||
|
||
@uirevision.setter
|
||
def uirevision(self, val):
|
||
self["uirevision"] = val
|
||
|
||
# visible
|
||
# -------
|
||
@property
|
||
def visible(self):
|
||
"""
|
||
Determines whether or not this trace is visible. If
|
||
"legendonly", the trace is not drawn, but can appear as a
|
||
legend item (provided that the legend itself is visible).
|
||
|
||
The 'visible' property is an enumeration that may be specified as:
|
||
- One of the following enumeration values:
|
||
[True, False, 'legendonly']
|
||
|
||
Returns
|
||
-------
|
||
Any
|
||
"""
|
||
return self["visible"]
|
||
|
||
@visible.setter
|
||
def visible(self, val):
|
||
self["visible"] = val
|
||
|
||
# x
|
||
# -
|
||
@property
|
||
def x(self):
|
||
"""
|
||
A two dimensional array of x coordinates at each carpet point.
|
||
If omitted, the plot is a cheater plot and the xaxis is hidden
|
||
by default.
|
||
|
||
The 'x' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["x"]
|
||
|
||
@x.setter
|
||
def x(self, val):
|
||
self["x"] = val
|
||
|
||
# xaxis
|
||
# -----
|
||
@property
|
||
def xaxis(self):
|
||
"""
|
||
Sets a reference between this trace's x coordinates and a 2D
|
||
cartesian x axis. If "x" (the default value), the x coordinates
|
||
refer to `layout.xaxis`. If "x2", the x coordinates refer to
|
||
`layout.xaxis2`, and so on.
|
||
|
||
The 'xaxis' property is an identifier of a particular
|
||
subplot, of type 'x', that may be specified as the string 'x'
|
||
optionally followed by an integer >= 1
|
||
(e.g. 'x', 'x1', 'x2', 'x3', etc.)
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["xaxis"]
|
||
|
||
@xaxis.setter
|
||
def xaxis(self, val):
|
||
self["xaxis"] = val
|
||
|
||
# xsrc
|
||
# ----
|
||
@property
|
||
def xsrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `x`.
|
||
|
||
The 'xsrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["xsrc"]
|
||
|
||
@xsrc.setter
|
||
def xsrc(self, val):
|
||
self["xsrc"] = val
|
||
|
||
# y
|
||
# -
|
||
@property
|
||
def y(self):
|
||
"""
|
||
A two dimensional array of y coordinates at each carpet point.
|
||
|
||
The 'y' property is an array that may be specified as a tuple,
|
||
list, numpy array, or pandas Series
|
||
|
||
Returns
|
||
-------
|
||
numpy.ndarray
|
||
"""
|
||
return self["y"]
|
||
|
||
@y.setter
|
||
def y(self, val):
|
||
self["y"] = val
|
||
|
||
# yaxis
|
||
# -----
|
||
@property
|
||
def yaxis(self):
|
||
"""
|
||
Sets a reference between this trace's y coordinates and a 2D
|
||
cartesian y axis. If "y" (the default value), the y coordinates
|
||
refer to `layout.yaxis`. If "y2", the y coordinates refer to
|
||
`layout.yaxis2`, and so on.
|
||
|
||
The 'yaxis' property is an identifier of a particular
|
||
subplot, of type 'y', that may be specified as the string 'y'
|
||
optionally followed by an integer >= 1
|
||
(e.g. 'y', 'y1', 'y2', 'y3', etc.)
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["yaxis"]
|
||
|
||
@yaxis.setter
|
||
def yaxis(self, val):
|
||
self["yaxis"] = val
|
||
|
||
# ysrc
|
||
# ----
|
||
@property
|
||
def ysrc(self):
|
||
"""
|
||
Sets the source reference on Chart Studio Cloud for `y`.
|
||
|
||
The 'ysrc' property must be specified as a string or
|
||
as a plotly.grid_objs.Column object
|
||
|
||
Returns
|
||
-------
|
||
str
|
||
"""
|
||
return self["ysrc"]
|
||
|
||
@ysrc.setter
|
||
def ysrc(self, val):
|
||
self["ysrc"] = val
|
||
|
||
# type
|
||
# ----
|
||
@property
|
||
def type(self):
|
||
return self._props["type"]
|
||
|
||
# Self properties description
|
||
# ---------------------------
|
||
@property
|
||
def _prop_descriptions(self):
|
||
return """\
|
||
a
|
||
An array containing values of the first parameter value
|
||
a0
|
||
Alternate to `a`. Builds a linear space of a
|
||
coordinates. Use with `da` where `a0` is the starting
|
||
coordinate and `da` the step.
|
||
aaxis
|
||
:class:`plotly.graph_objects.carpet.Aaxis` instance or
|
||
dict with compatible properties
|
||
asrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`a`.
|
||
b
|
||
A two dimensional array of y coordinates at each carpet
|
||
point.
|
||
b0
|
||
Alternate to `b`. Builds a linear space of a
|
||
coordinates. Use with `db` where `b0` is the starting
|
||
coordinate and `db` the step.
|
||
baxis
|
||
:class:`plotly.graph_objects.carpet.Baxis` instance or
|
||
dict with compatible properties
|
||
bsrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`b`.
|
||
carpet
|
||
An identifier for this carpet, so that `scattercarpet`
|
||
and `contourcarpet` traces can specify a carpet plot on
|
||
which they lie
|
||
cheaterslope
|
||
The shift applied to each successive row of data in
|
||
creating a cheater plot. Only used if `x` is been
|
||
omitted.
|
||
color
|
||
Sets default for all colors associated with this axis
|
||
all at once: line, font, tick, and grid colors. Grid
|
||
color is lightened by blending this with the plot
|
||
background Individual pieces can override this.
|
||
customdata
|
||
Assigns extra data each datum. This may be useful when
|
||
listening to hover, click and selection events. Note
|
||
that, "scatter" traces also appends customdata items in
|
||
the markers DOM elements
|
||
customdatasrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`customdata`.
|
||
da
|
||
Sets the a coordinate step. See `a0` for more info.
|
||
db
|
||
Sets the b coordinate step. See `b0` for more info.
|
||
font
|
||
The default font used for axis & tick labels on this
|
||
carpet
|
||
ids
|
||
Assigns id labels to each datum. These ids for object
|
||
constancy of data points during animation. Should be an
|
||
array of strings, not numbers or any other type.
|
||
idssrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`ids`.
|
||
legend
|
||
Sets the reference to a legend to show this trace in.
|
||
References to these legends are "legend", "legend2",
|
||
"legend3", etc. Settings for these legends are set in
|
||
the layout, under `layout.legend`, `layout.legend2`,
|
||
etc.
|
||
legendgrouptitle
|
||
:class:`plotly.graph_objects.carpet.Legendgrouptitle`
|
||
instance or dict with compatible properties
|
||
legendrank
|
||
Sets the legend rank for this trace. Items and groups
|
||
with smaller ranks are presented on top/left side while
|
||
with "reversed" `legend.traceorder` they are on
|
||
bottom/right side. The default legendrank is 1000, so
|
||
that you can use ranks less than 1000 to place certain
|
||
items before all unranked items, and ranks greater than
|
||
1000 to go after all unranked items. When having
|
||
unranked or equal rank items shapes would be displayed
|
||
after traces i.e. according to their order in data and
|
||
layout.
|
||
legendwidth
|
||
Sets the width (in px or fraction) of the legend for
|
||
this trace.
|
||
meta
|
||
Assigns extra meta information associated with this
|
||
trace that can be used in various text attributes.
|
||
Attributes such as trace `name`, graph, axis and
|
||
colorbar `title.text`, annotation `text`
|
||
`rangeselector`, `updatemenues` and `sliders` `label`
|
||
text all support `meta`. To access the trace `meta`
|
||
values in an attribute in the same trace, simply use
|
||
`%{meta[i]}` where `i` is the index or key of the
|
||
`meta` item in question. To access trace `meta` in
|
||
layout attributes, use `%{data[n[.meta[i]}` where `i`
|
||
is the index or key of the `meta` and `n` is the trace
|
||
index.
|
||
metasrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`meta`.
|
||
name
|
||
Sets the trace name. The trace name appears as the
|
||
legend item and on hover.
|
||
opacity
|
||
Sets the opacity of the trace.
|
||
stream
|
||
:class:`plotly.graph_objects.carpet.Stream` instance or
|
||
dict with compatible properties
|
||
uid
|
||
Assign an id to this trace, Use this to provide object
|
||
constancy between traces during animations and
|
||
transitions.
|
||
uirevision
|
||
Controls persistence of some user-driven changes to the
|
||
trace: `constraintrange` in `parcoords` traces, as well
|
||
as some `editable: true` modifications such as `name`
|
||
and `colorbar.title`. Defaults to `layout.uirevision`.
|
||
Note that other user-driven trace attribute changes are
|
||
controlled by `layout` attributes: `trace.visible` is
|
||
controlled by `layout.legend.uirevision`,
|
||
`selectedpoints` is controlled by
|
||
`layout.selectionrevision`, and `colorbar.(x|y)`
|
||
(accessible with `config: {editable: true}`) is
|
||
controlled by `layout.editrevision`. Trace changes are
|
||
tracked by `uid`, which only falls back on trace index
|
||
if no `uid` is provided. So if your app can add/remove
|
||
traces before the end of the `data` array, such that
|
||
the same trace has a different index, you can still
|
||
preserve user-driven changes if you give each trace a
|
||
`uid` that stays with it as it moves.
|
||
visible
|
||
Determines whether or not this trace is visible. If
|
||
"legendonly", the trace is not drawn, but can appear as
|
||
a legend item (provided that the legend itself is
|
||
visible).
|
||
x
|
||
A two dimensional array of x coordinates at each carpet
|
||
point. If omitted, the plot is a cheater plot and the
|
||
xaxis is hidden by default.
|
||
xaxis
|
||
Sets a reference between this trace's x coordinates and
|
||
a 2D cartesian x axis. If "x" (the default value), the
|
||
x coordinates refer to `layout.xaxis`. If "x2", the x
|
||
coordinates refer to `layout.xaxis2`, and so on.
|
||
xsrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`x`.
|
||
y
|
||
A two dimensional array of y coordinates at each carpet
|
||
point.
|
||
yaxis
|
||
Sets a reference between this trace's y coordinates and
|
||
a 2D cartesian y axis. If "y" (the default value), the
|
||
y coordinates refer to `layout.yaxis`. If "y2", the y
|
||
coordinates refer to `layout.yaxis2`, and so on.
|
||
ysrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`y`.
|
||
"""
|
||
|
||
def __init__(
|
||
self,
|
||
arg=None,
|
||
a=None,
|
||
a0=None,
|
||
aaxis=None,
|
||
asrc=None,
|
||
b=None,
|
||
b0=None,
|
||
baxis=None,
|
||
bsrc=None,
|
||
carpet=None,
|
||
cheaterslope=None,
|
||
color=None,
|
||
customdata=None,
|
||
customdatasrc=None,
|
||
da=None,
|
||
db=None,
|
||
font=None,
|
||
ids=None,
|
||
idssrc=None,
|
||
legend=None,
|
||
legendgrouptitle=None,
|
||
legendrank=None,
|
||
legendwidth=None,
|
||
meta=None,
|
||
metasrc=None,
|
||
name=None,
|
||
opacity=None,
|
||
stream=None,
|
||
uid=None,
|
||
uirevision=None,
|
||
visible=None,
|
||
x=None,
|
||
xaxis=None,
|
||
xsrc=None,
|
||
y=None,
|
||
yaxis=None,
|
||
ysrc=None,
|
||
**kwargs,
|
||
):
|
||
"""
|
||
Construct a new Carpet object
|
||
|
||
The data describing carpet axis layout is set in `y` and
|
||
(optionally) also `x`. If only `y` is present, `x` the plot is
|
||
interpreted as a cheater plot and is filled in using the `y`
|
||
values. `x` and `y` may either be 2D arrays matching with each
|
||
dimension matching that of `a` and `b`, or they may be 1D
|
||
arrays with total length equal to that of `a` and `b`.
|
||
|
||
Parameters
|
||
----------
|
||
arg
|
||
dict of properties compatible with this constructor or
|
||
an instance of :class:`plotly.graph_objs.Carpet`
|
||
a
|
||
An array containing values of the first parameter value
|
||
a0
|
||
Alternate to `a`. Builds a linear space of a
|
||
coordinates. Use with `da` where `a0` is the starting
|
||
coordinate and `da` the step.
|
||
aaxis
|
||
:class:`plotly.graph_objects.carpet.Aaxis` instance or
|
||
dict with compatible properties
|
||
asrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`a`.
|
||
b
|
||
A two dimensional array of y coordinates at each carpet
|
||
point.
|
||
b0
|
||
Alternate to `b`. Builds a linear space of a
|
||
coordinates. Use with `db` where `b0` is the starting
|
||
coordinate and `db` the step.
|
||
baxis
|
||
:class:`plotly.graph_objects.carpet.Baxis` instance or
|
||
dict with compatible properties
|
||
bsrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`b`.
|
||
carpet
|
||
An identifier for this carpet, so that `scattercarpet`
|
||
and `contourcarpet` traces can specify a carpet plot on
|
||
which they lie
|
||
cheaterslope
|
||
The shift applied to each successive row of data in
|
||
creating a cheater plot. Only used if `x` is been
|
||
omitted.
|
||
color
|
||
Sets default for all colors associated with this axis
|
||
all at once: line, font, tick, and grid colors. Grid
|
||
color is lightened by blending this with the plot
|
||
background Individual pieces can override this.
|
||
customdata
|
||
Assigns extra data each datum. This may be useful when
|
||
listening to hover, click and selection events. Note
|
||
that, "scatter" traces also appends customdata items in
|
||
the markers DOM elements
|
||
customdatasrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`customdata`.
|
||
da
|
||
Sets the a coordinate step. See `a0` for more info.
|
||
db
|
||
Sets the b coordinate step. See `b0` for more info.
|
||
font
|
||
The default font used for axis & tick labels on this
|
||
carpet
|
||
ids
|
||
Assigns id labels to each datum. These ids for object
|
||
constancy of data points during animation. Should be an
|
||
array of strings, not numbers or any other type.
|
||
idssrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`ids`.
|
||
legend
|
||
Sets the reference to a legend to show this trace in.
|
||
References to these legends are "legend", "legend2",
|
||
"legend3", etc. Settings for these legends are set in
|
||
the layout, under `layout.legend`, `layout.legend2`,
|
||
etc.
|
||
legendgrouptitle
|
||
:class:`plotly.graph_objects.carpet.Legendgrouptitle`
|
||
instance or dict with compatible properties
|
||
legendrank
|
||
Sets the legend rank for this trace. Items and groups
|
||
with smaller ranks are presented on top/left side while
|
||
with "reversed" `legend.traceorder` they are on
|
||
bottom/right side. The default legendrank is 1000, so
|
||
that you can use ranks less than 1000 to place certain
|
||
items before all unranked items, and ranks greater than
|
||
1000 to go after all unranked items. When having
|
||
unranked or equal rank items shapes would be displayed
|
||
after traces i.e. according to their order in data and
|
||
layout.
|
||
legendwidth
|
||
Sets the width (in px or fraction) of the legend for
|
||
this trace.
|
||
meta
|
||
Assigns extra meta information associated with this
|
||
trace that can be used in various text attributes.
|
||
Attributes such as trace `name`, graph, axis and
|
||
colorbar `title.text`, annotation `text`
|
||
`rangeselector`, `updatemenues` and `sliders` `label`
|
||
text all support `meta`. To access the trace `meta`
|
||
values in an attribute in the same trace, simply use
|
||
`%{meta[i]}` where `i` is the index or key of the
|
||
`meta` item in question. To access trace `meta` in
|
||
layout attributes, use `%{data[n[.meta[i]}` where `i`
|
||
is the index or key of the `meta` and `n` is the trace
|
||
index.
|
||
metasrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`meta`.
|
||
name
|
||
Sets the trace name. The trace name appears as the
|
||
legend item and on hover.
|
||
opacity
|
||
Sets the opacity of the trace.
|
||
stream
|
||
:class:`plotly.graph_objects.carpet.Stream` instance or
|
||
dict with compatible properties
|
||
uid
|
||
Assign an id to this trace, Use this to provide object
|
||
constancy between traces during animations and
|
||
transitions.
|
||
uirevision
|
||
Controls persistence of some user-driven changes to the
|
||
trace: `constraintrange` in `parcoords` traces, as well
|
||
as some `editable: true` modifications such as `name`
|
||
and `colorbar.title`. Defaults to `layout.uirevision`.
|
||
Note that other user-driven trace attribute changes are
|
||
controlled by `layout` attributes: `trace.visible` is
|
||
controlled by `layout.legend.uirevision`,
|
||
`selectedpoints` is controlled by
|
||
`layout.selectionrevision`, and `colorbar.(x|y)`
|
||
(accessible with `config: {editable: true}`) is
|
||
controlled by `layout.editrevision`. Trace changes are
|
||
tracked by `uid`, which only falls back on trace index
|
||
if no `uid` is provided. So if your app can add/remove
|
||
traces before the end of the `data` array, such that
|
||
the same trace has a different index, you can still
|
||
preserve user-driven changes if you give each trace a
|
||
`uid` that stays with it as it moves.
|
||
visible
|
||
Determines whether or not this trace is visible. If
|
||
"legendonly", the trace is not drawn, but can appear as
|
||
a legend item (provided that the legend itself is
|
||
visible).
|
||
x
|
||
A two dimensional array of x coordinates at each carpet
|
||
point. If omitted, the plot is a cheater plot and the
|
||
xaxis is hidden by default.
|
||
xaxis
|
||
Sets a reference between this trace's x coordinates and
|
||
a 2D cartesian x axis. If "x" (the default value), the
|
||
x coordinates refer to `layout.xaxis`. If "x2", the x
|
||
coordinates refer to `layout.xaxis2`, and so on.
|
||
xsrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`x`.
|
||
y
|
||
A two dimensional array of y coordinates at each carpet
|
||
point.
|
||
yaxis
|
||
Sets a reference between this trace's y coordinates and
|
||
a 2D cartesian y axis. If "y" (the default value), the
|
||
y coordinates refer to `layout.yaxis`. If "y2", the y
|
||
coordinates refer to `layout.yaxis2`, and so on.
|
||
ysrc
|
||
Sets the source reference on Chart Studio Cloud for
|
||
`y`.
|
||
|
||
Returns
|
||
-------
|
||
Carpet
|
||
"""
|
||
super(Carpet, self).__init__("carpet")
|
||
|
||
if "_parent" in kwargs:
|
||
self._parent = kwargs["_parent"]
|
||
return
|
||
|
||
# Validate arg
|
||
# ------------
|
||
if arg is None:
|
||
arg = {}
|
||
elif isinstance(arg, self.__class__):
|
||
arg = arg.to_plotly_json()
|
||
elif isinstance(arg, dict):
|
||
arg = _copy.copy(arg)
|
||
else:
|
||
raise ValueError(
|
||
"""\
|
||
The first argument to the plotly.graph_objs.Carpet
|
||
constructor must be a dict or
|
||
an instance of :class:`plotly.graph_objs.Carpet`"""
|
||
)
|
||
|
||
# Handle skip_invalid
|
||
# -------------------
|
||
self._skip_invalid = kwargs.pop("skip_invalid", False)
|
||
self._validate = kwargs.pop("_validate", True)
|
||
|
||
# Populate data dict with properties
|
||
# ----------------------------------
|
||
_v = arg.pop("a", None)
|
||
_v = a if a is not None else _v
|
||
if _v is not None:
|
||
self["a"] = _v
|
||
_v = arg.pop("a0", None)
|
||
_v = a0 if a0 is not None else _v
|
||
if _v is not None:
|
||
self["a0"] = _v
|
||
_v = arg.pop("aaxis", None)
|
||
_v = aaxis if aaxis is not None else _v
|
||
if _v is not None:
|
||
self["aaxis"] = _v
|
||
_v = arg.pop("asrc", None)
|
||
_v = asrc if asrc is not None else _v
|
||
if _v is not None:
|
||
self["asrc"] = _v
|
||
_v = arg.pop("b", None)
|
||
_v = b if b is not None else _v
|
||
if _v is not None:
|
||
self["b"] = _v
|
||
_v = arg.pop("b0", None)
|
||
_v = b0 if b0 is not None else _v
|
||
if _v is not None:
|
||
self["b0"] = _v
|
||
_v = arg.pop("baxis", None)
|
||
_v = baxis if baxis is not None else _v
|
||
if _v is not None:
|
||
self["baxis"] = _v
|
||
_v = arg.pop("bsrc", None)
|
||
_v = bsrc if bsrc is not None else _v
|
||
if _v is not None:
|
||
self["bsrc"] = _v
|
||
_v = arg.pop("carpet", None)
|
||
_v = carpet if carpet is not None else _v
|
||
if _v is not None:
|
||
self["carpet"] = _v
|
||
_v = arg.pop("cheaterslope", None)
|
||
_v = cheaterslope if cheaterslope is not None else _v
|
||
if _v is not None:
|
||
self["cheaterslope"] = _v
|
||
_v = arg.pop("color", None)
|
||
_v = color if color is not None else _v
|
||
if _v is not None:
|
||
self["color"] = _v
|
||
_v = arg.pop("customdata", None)
|
||
_v = customdata if customdata is not None else _v
|
||
if _v is not None:
|
||
self["customdata"] = _v
|
||
_v = arg.pop("customdatasrc", None)
|
||
_v = customdatasrc if customdatasrc is not None else _v
|
||
if _v is not None:
|
||
self["customdatasrc"] = _v
|
||
_v = arg.pop("da", None)
|
||
_v = da if da is not None else _v
|
||
if _v is not None:
|
||
self["da"] = _v
|
||
_v = arg.pop("db", None)
|
||
_v = db if db is not None else _v
|
||
if _v is not None:
|
||
self["db"] = _v
|
||
_v = arg.pop("font", None)
|
||
_v = font if font is not None else _v
|
||
if _v is not None:
|
||
self["font"] = _v
|
||
_v = arg.pop("ids", None)
|
||
_v = ids if ids is not None else _v
|
||
if _v is not None:
|
||
self["ids"] = _v
|
||
_v = arg.pop("idssrc", None)
|
||
_v = idssrc if idssrc is not None else _v
|
||
if _v is not None:
|
||
self["idssrc"] = _v
|
||
_v = arg.pop("legend", None)
|
||
_v = legend if legend is not None else _v
|
||
if _v is not None:
|
||
self["legend"] = _v
|
||
_v = arg.pop("legendgrouptitle", None)
|
||
_v = legendgrouptitle if legendgrouptitle is not None else _v
|
||
if _v is not None:
|
||
self["legendgrouptitle"] = _v
|
||
_v = arg.pop("legendrank", None)
|
||
_v = legendrank if legendrank is not None else _v
|
||
if _v is not None:
|
||
self["legendrank"] = _v
|
||
_v = arg.pop("legendwidth", None)
|
||
_v = legendwidth if legendwidth is not None else _v
|
||
if _v is not None:
|
||
self["legendwidth"] = _v
|
||
_v = arg.pop("meta", None)
|
||
_v = meta if meta is not None else _v
|
||
if _v is not None:
|
||
self["meta"] = _v
|
||
_v = arg.pop("metasrc", None)
|
||
_v = metasrc if metasrc is not None else _v
|
||
if _v is not None:
|
||
self["metasrc"] = _v
|
||
_v = arg.pop("name", None)
|
||
_v = name if name is not None else _v
|
||
if _v is not None:
|
||
self["name"] = _v
|
||
_v = arg.pop("opacity", None)
|
||
_v = opacity if opacity is not None else _v
|
||
if _v is not None:
|
||
self["opacity"] = _v
|
||
_v = arg.pop("stream", None)
|
||
_v = stream if stream is not None else _v
|
||
if _v is not None:
|
||
self["stream"] = _v
|
||
_v = arg.pop("uid", None)
|
||
_v = uid if uid is not None else _v
|
||
if _v is not None:
|
||
self["uid"] = _v
|
||
_v = arg.pop("uirevision", None)
|
||
_v = uirevision if uirevision is not None else _v
|
||
if _v is not None:
|
||
self["uirevision"] = _v
|
||
_v = arg.pop("visible", None)
|
||
_v = visible if visible is not None else _v
|
||
if _v is not None:
|
||
self["visible"] = _v
|
||
_v = arg.pop("x", None)
|
||
_v = x if x is not None else _v
|
||
if _v is not None:
|
||
self["x"] = _v
|
||
_v = arg.pop("xaxis", None)
|
||
_v = xaxis if xaxis is not None else _v
|
||
if _v is not None:
|
||
self["xaxis"] = _v
|
||
_v = arg.pop("xsrc", None)
|
||
_v = xsrc if xsrc is not None else _v
|
||
if _v is not None:
|
||
self["xsrc"] = _v
|
||
_v = arg.pop("y", None)
|
||
_v = y if y is not None else _v
|
||
if _v is not None:
|
||
self["y"] = _v
|
||
_v = arg.pop("yaxis", None)
|
||
_v = yaxis if yaxis is not None else _v
|
||
if _v is not None:
|
||
self["yaxis"] = _v
|
||
_v = arg.pop("ysrc", None)
|
||
_v = ysrc if ysrc is not None else _v
|
||
if _v is not None:
|
||
self["ysrc"] = _v
|
||
|
||
# Read-only literals
|
||
# ------------------
|
||
|
||
self._props["type"] = "carpet"
|
||
arg.pop("type", None)
|
||
|
||
# Process unknown kwargs
|
||
# ----------------------
|
||
self._process_kwargs(**dict(arg, **kwargs))
|
||
|
||
# Reset skip_invalid
|
||
# ------------------
|
||
self._skip_invalid = False
|