_splom.py

fromplotly.basedatatypesimportBaseTraceTypeas_BaseTraceType
importcopyas_copy


classSplom(_BaseTraceType):

# class properties
# --------------------
_parent_path_str=""
_path_str="splom"
_valid_props= {
"customdata",
"customdatasrc",
"diagonal",
"dimensiondefaults",
"dimensions",
"hoverinfo",
"hoverinfosrc",
"hoverlabel",
"hovertemplate",
"hovertemplatesrc",
"hovertext",
"hovertextsrc",
"ids",
"idssrc",
"legend",
"legendgroup",
"legendgrouptitle",
"legendrank",
"legendwidth",
"marker",
"meta",
"metasrc",
"name",
"opacity",
"selected",
"selectedpoints",
"showlegend",
"showlowerhalf",
"showupperhalf",
"stream",
"text",
"textsrc",
"type",
"uid",
"uirevision",
"unselected",
"visible",
"xaxes",
"xhoverformat",
"yaxes",
"yhoverformat",
 }

# customdata
# ----------
@property
defcustomdata(self):
"""
 Assigns extra data each datum. This may be useful when
 listening to hover, click and selection events. Note that,
 "scatter" traces also appends customdata items in the markers
 DOM elements

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

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

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

# customdatasrc
# -------------
@property
defcustomdatasrc(self):
"""
 Sets the source reference on Chart Studio Cloud for
 `customdata`.

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

 Returns
 -------
 str
 """
returnself["customdatasrc"]

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

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

 Supported dict properties:

 visible
 Determines whether or not subplots on the
 diagonal are displayed.

 Returns
 -------
 plotly.graph_objs.splom.Diagonal
 """
returnself["diagonal"]

@diagonal.setter
defdiagonal(self, val):
self["diagonal"] =val

# dimensions
# ----------
@property
defdimensions(self):
"""
 The 'dimensions' property is a tuple of instances of
 Dimension that may be specified as:
 - A list or tuple of instances of plotly.graph_objs.splom.Dimension
 - A list or tuple of dicts of string/value properties that
 will be passed to the Dimension constructor

 Supported dict properties:

 axis
 :class:`plotly.graph_objects.splom.dimension.Ax
 is` instance or dict with compatible properties
 label
 Sets the label corresponding to this splom
 dimension.
 name
 When used in a template, named items are
 created in the output figure in addition to any
 items the figure already has in this array. You
 can modify these items in the output figure by
 making your own item with `templateitemname`
 matching this `name` alongside your
 modifications (including `visible: false` or
 `enabled: false` to hide it). Has no effect
 outside of a template.
 templateitemname
 Used to refer to a named item in this array in
 the template. Named items from the template
 will be created even without a matching item in
 the input figure, but you can modify one by
 making an item with `templateitemname` matching
 its `name`, alongside your modifications
 (including `visible: false` or `enabled: false`
 to hide it). If there is no template or no
 matching item, this item will be hidden unless
 you explicitly show it with `visible: true`.
 values
 Sets the dimension values to be plotted.
 valuessrc
 Sets the source reference on Chart Studio Cloud
 for `values`.
 visible
 Determines whether or not this dimension is
 shown on the graph. Note that even visible
 false dimension contribute to the default grid
 generate by this splom trace.

 Returns
 -------
 tuple[plotly.graph_objs.splom.Dimension]
 """
returnself["dimensions"]

@dimensions.setter
defdimensions(self, val):
self["dimensions"] =val

# dimensiondefaults
# -----------------
@property
defdimensiondefaults(self):
"""
 When used in a template (as
 layout.template.data.splom.dimensiondefaults), sets the default
 property values to use for elements of splom.dimensions

 The 'dimensiondefaults' property is an instance of Dimension
 that may be specified as:
 - An instance of :class:`plotly.graph_objs.splom.Dimension`
 - A dict of string/value properties that will be passed
 to the Dimension constructor

 Supported dict properties:

 Returns
 -------
 plotly.graph_objs.splom.Dimension
 """
returnself["dimensiondefaults"]

@dimensiondefaults.setter
defdimensiondefaults(self, val):
self["dimensiondefaults"] =val

# hoverinfo
# ---------
@property
defhoverinfo(self):
"""
 Determines which trace information appear on hover. If `none`
 or `skip` are set, no information is displayed upon hovering.
 But, if `none` is set, click and hover events are still fired.

 The 'hoverinfo' property is a flaglist and may be specified
 as a string containing:
 - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters
 (e.g. 'x+y')
 OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip')
 - A list or array of the above

 Returns
 -------
 Any|numpy.ndarray
 """
returnself["hoverinfo"]

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

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

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

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

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

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

 Supported dict properties:

 align
 Sets the horizontal alignment of the text
 content within hover label box. Has an effect
 only if the hover label text spans more two or
 more lines
 alignsrc
 Sets the source reference on Chart Studio Cloud
 for `align`.
 bgcolor
 Sets the background color of the hover labels
 for this trace
 bgcolorsrc
 Sets the source reference on Chart Studio Cloud
 for `bgcolor`.
 bordercolor
 Sets the border color of the hover labels for
 this trace.
 bordercolorsrc
 Sets the source reference on Chart Studio Cloud
 for `bordercolor`.
 font
 Sets the font used in hover labels.
 namelength
 Sets the default length (in number of
 characters) of the trace name in the hover
 labels for all traces. -1 shows the whole name
 regardless of length. 0-3 shows the first 0-3
 characters, and an integer >3 will show the
 whole name if it is less than that many
 characters, but if it is longer, will truncate
 to `namelength - 3` characters and add an
 ellipsis.
 namelengthsrc
 Sets the source reference on Chart Studio Cloud
 for `namelength`.

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

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

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

 The 'hovertemplate' property is a string and must be specified as:
 - A string
 - A number that will be converted to a string
 - A tuple, list, or one-dimensional numpy array of the above

 Returns
 -------
 str|numpy.ndarray
 """
returnself["hovertemplate"]

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

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

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

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

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

# hovertext
# ---------
@property
defhovertext(self):
"""
 Same as `text`.

 The 'hovertext' property is a string and must be specified as:
 - A string
 - A number that will be converted to a string
 - A tuple, list, or one-dimensional numpy array of the above

 Returns
 -------
 str|numpy.ndarray
 """
returnself["hovertext"]

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

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

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

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

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

# ids
# ---
@property
defids(self):
"""
 Assigns id labels to each datum. These ids for object constancy
 of data points during animation. Should be an array of strings,
 not numbers or any other type.

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

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

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

# idssrc
# ------
@property
defidssrc(self):
"""
 Sets the source reference on Chart Studio Cloud for `ids`.

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

 Returns
 -------
 str
 """
returnself["idssrc"]

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

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

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

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

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

# legendgroup
# -----------
@property
deflegendgroup(self):
"""
 Sets the legend group for this trace. Traces and shapes part of
 the same legend group hide/show at the same time when toggling
 legend items.

 The 'legendgroup' property is a string and must be specified as:
 - A string
 - A number that will be converted to a string

 Returns
 -------
 str
 """
returnself["legendgroup"]

@legendgroup.setter
deflegendgroup(self, val):
self["legendgroup"] =val

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

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

# legendrank
# ----------
@property
deflegendrank(self):
"""
 Sets the legend rank for this trace. Items and groups with
 smaller ranks are presented on top/left side while with
 "reversed" `legend.traceorder` they are on bottom/right side.
 The default legendrank is 1000, so that you can use ranks less
 than 1000 to place certain items before all unranked items, and
 ranks greater than 1000 to go after all unranked items. When
 having unranked or equal rank items shapes would be displayed
 after traces i.e. according to their order in data and layout.

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

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

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

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

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

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

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

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

 Supported dict properties:

 angle
 Sets the marker angle in respect to `angleref`.
 anglesrc
 Sets the source reference on Chart Studio Cloud
 for `angle`.
 autocolorscale
 Determines whether the colorscale is a default
 palette (`autocolorscale: true`) or the palette
 determined by `marker.colorscale`. Has an
 effect only if in `marker.color` is set to a
 numerical array. In case `colorscale` is
 unspecified or `autocolorscale` is true, the
 default palette will be chosen according to
 whether numbers in the `color` array are all
 positive, all negative or mixed.
 cauto
 Determines whether or not the color domain is
 computed with respect to the input data (here
 in `marker.color`) or the bounds set in
 `marker.cmin` and `marker.cmax` Has an effect
 only if in `marker.color` is set to a numerical
 array. Defaults to `false` when `marker.cmin`
 and `marker.cmax` are set by the user.
 cmax
 Sets the upper bound of the color domain. Has
 an effect only if in `marker.color` is set to a
 numerical array. Value should have the same
 units as in `marker.color` and if set,
 `marker.cmin` must be set as well.
 cmid
 Sets the mid-point of the color domain by
 scaling `marker.cmin` and/or `marker.cmax` to
 be equidistant to this point. Has an effect
 only if in `marker.color` is set to a numerical
 array. Value should have the same units as in
 `marker.color`. Has no effect when
 `marker.cauto` is `false`.
 cmin
 Sets the lower bound of the color domain. Has
 an effect only if in `marker.color` is set to a
 numerical array. Value should have the same
 units as in `marker.color` and if set,
 `marker.cmax` must be set as well.
 color
 Sets the marker color. It accepts either a
 specific color or an array of numbers that are
 mapped to the colorscale relative to the max
 and min values of the array or relative to
 `marker.cmin` and `marker.cmax` if set.
 coloraxis
 Sets a reference to a shared color axis.
 References to these shared color axes are
 "coloraxis", "coloraxis2", "coloraxis3", etc.
 Settings for these shared color axes are set in
 the layout, under `layout.coloraxis`,
 `layout.coloraxis2`, etc. Note that multiple
 color scales can be linked to the same color
 axis.
 colorbar
 :class:`plotly.graph_objects.splom.marker.Color
 Bar` instance or dict with compatible
 properties
 colorscale
 Sets the colorscale. Has an effect only if in
 `marker.color` is set to a numerical array. The
 colorscale must be an array containing arrays
 mapping a normalized value to an rgb, rgba,
 hex, hsl, hsv, or named color string. At
 minimum, a mapping for the lowest (0) and
 highest (1) values are required. For example,
 `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`.
 To control the bounds of the colorscale in
 color space, use `marker.cmin` and
 `marker.cmax`. Alternatively, `colorscale` may
 be a palette name string of the following list:
 Blackbody,Bluered,Blues,Cividis,Earth,Electric,
 Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,Rd
 Bu,Reds,Viridis,YlGnBu,YlOrRd.
 colorsrc
 Sets the source reference on Chart Studio Cloud
 for `color`.
 line
 :class:`plotly.graph_objects.splom.marker.Line`
 instance or dict with compatible properties
 opacity
 Sets the marker opacity.
 opacitysrc
 Sets the source reference on Chart Studio Cloud
 for `opacity`.
 reversescale
 Reverses the color mapping if true. Has an
 effect only if in `marker.color` is set to a
 numerical array. If true, `marker.cmin` will
 correspond to the last color in the array and
 `marker.cmax` will correspond to the first
 color.
 showscale
 Determines whether or not a colorbar is
 displayed for this trace. Has an effect only if
 in `marker.color` is set to a numerical array.
 size
 Sets the marker size (in px).
 sizemin
 Has an effect only if `marker.size` is set to a
 numerical array. Sets the minimum size (in px)
 of the rendered marker points.
 sizemode
 Has an effect only if `marker.size` is set to a
 numerical array. Sets the rule for which the
 data in `size` is converted to pixels.
 sizeref
 Has an effect only if `marker.size` is set to a
 numerical array. Sets the scale factor used to
 determine the rendered size of marker points.
 Use with `sizemin` and `sizemode`.
 sizesrc
 Sets the source reference on Chart Studio Cloud
 for `size`.
 symbol
 Sets the marker symbol type. Adding 100 is
 equivalent to appending "-open" to a symbol
 name. Adding 200 is equivalent to appending
 "-dot" to a symbol name. Adding 300 is
 equivalent to appending "-open-dot" or "dot-
 open" to a symbol name.
 symbolsrc
 Sets the source reference on Chart Studio Cloud
 for `symbol`.

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

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

# meta
# ----
@property
defmeta(self):
"""
 Assigns extra meta information associated with this trace that
 can be used in various text attributes. Attributes such as
 trace `name`, graph, axis and colorbar `title.text`, annotation
 `text` `rangeselector`, `updatemenues` and `sliders` `label`
 text all support `meta`. To access the trace `meta` values in
 an attribute in the same trace, simply use `%{meta[i]}` where
 `i` is the index or key of the `meta` item in question. To
 access trace `meta` in layout attributes, use
 `%{data[n[.meta[i]}` where `i` is the index or key of the
 `meta` and `n` is the trace index.

 The 'meta' property accepts values of any type

 Returns
 -------
 Any|numpy.ndarray
 """
returnself["meta"]

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

# metasrc
# -------
@property
defmetasrc(self):
"""
 Sets the source reference on Chart Studio Cloud for `meta`.

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

 Returns
 -------
 str
 """
returnself["metasrc"]

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

# name
# ----
@property
defname(self):
"""
 Sets the trace name. The trace name appears as the legend item
 and on hover.

 The 'name' property is a string and must be specified as:
 - A string
 - A number that will be converted to a string

 Returns
 -------
 str
 """
returnself["name"]

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

# opacity
# -------
@property
defopacity(self):
"""
 Sets the opacity of the trace.

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

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

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

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

 Supported dict properties:

 marker
 :class:`plotly.graph_objects.splom.selected.Mar
 ker` instance or dict with compatible
 properties

 Returns
 -------
 plotly.graph_objs.splom.Selected
 """
returnself["selected"]

@selected.setter
defselected(self, val):
self["selected"] =val

# selectedpoints
# --------------
@property
defselectedpoints(self):
"""
 Array containing integer indices of selected points. Has an
 effect only for traces that support selections. Note that an
 empty array means an empty selection where the `unselected` are
 turned on for all points, whereas, any other non-array values
 means no selection all where the `selected` and `unselected`
 styles have no effect.

 The 'selectedpoints' property accepts values of any type

 Returns
 -------
 Any
 """
returnself["selectedpoints"]

@selectedpoints.setter
defselectedpoints(self, val):
self["selectedpoints"] =val

# showlegend
# ----------
@property
defshowlegend(self):
"""
 Determines whether or not an item corresponding to this trace
 is shown in the legend.

 The 'showlegend' property must be specified as a bool
 (either True, or False)

 Returns
 -------
 bool
 """
returnself["showlegend"]

@showlegend.setter
defshowlegend(self, val):
self["showlegend"] =val

# showlowerhalf
# -------------
@property
defshowlowerhalf(self):
"""
 Determines whether or not subplots on the lower half from the
 diagonal are displayed.

 The 'showlowerhalf' property must be specified as a bool
 (either True, or False)

 Returns
 -------
 bool
 """
returnself["showlowerhalf"]

@showlowerhalf.setter
defshowlowerhalf(self, val):
self["showlowerhalf"] =val

# showupperhalf
# -------------
@property
defshowupperhalf(self):
"""
 Determines whether or not subplots on the upper half from the
 diagonal are displayed.

 The 'showupperhalf' property must be specified as a bool
 (either True, or False)

 Returns
 -------
 bool
 """
returnself["showupperhalf"]

@showupperhalf.setter
defshowupperhalf(self, val):
self["showupperhalf"] =val

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

 Supported dict properties:

 maxpoints
 Sets the maximum number of points to keep on
 the plots from an incoming stream. If
 `maxpoints` is set to 50, only the newest 50
 points will be displayed on the plot.
 token
 The stream id number links a data trace on a
 plot with a stream. See https://chart-
 studio.plotly.com/settings for more details.

 Returns
 -------
 plotly.graph_objs.splom.Stream
 """
returnself["stream"]

@stream.setter
defstream(self, val):
self["stream"] =val

# text
# ----
@property
deftext(self):
"""
 Sets text elements associated with each (x,y) pair to appear on
 hover. If a single string, the same string appears over all the
 data points. If an array of string, the items are mapped in
 order to the this trace's (x,y) coordinates.

 The 'text' property is a string and must be specified as:
 - A string
 - A number that will be converted to a string
 - A tuple, list, or one-dimensional numpy array of the above

 Returns
 -------