_funnel.py

fromplotly.basedatatypesimportBaseTraceTypeas_BaseTraceType
importcopyas_copy


classFunnel(_BaseTraceType):

# class properties
# --------------------
_parent_path_str=""
_path_str="funnel"
_valid_props= {
"alignmentgroup",
"cliponaxis",
"connector",
"constraintext",
"customdata",
"customdatasrc",
"dx",
"dy",
"hoverinfo",
"hoverinfosrc",
"hoverlabel",
"hovertemplate",
"hovertemplatesrc",
"hovertext",
"hovertextsrc",
"ids",
"idssrc",
"insidetextanchor",
"insidetextfont",
"legend",
"legendgroup",
"legendgrouptitle",
"legendrank",
"legendwidth",
"marker",
"meta",
"metasrc",
"name",
"offset",
"offsetgroup",
"opacity",
"orientation",
"outsidetextfont",
"selectedpoints",
"showlegend",
"stream",
"text",
"textangle",
"textfont",
"textinfo",
"textposition",
"textpositionsrc",
"textsrc",
"texttemplate",
"texttemplatesrc",
"type",
"uid",
"uirevision",
"visible",
"width",
"x",
"x0",
"xaxis",
"xhoverformat",
"xperiod",
"xperiod0",
"xperiodalignment",
"xsrc",
"y",
"y0",
"yaxis",
"yhoverformat",
"yperiod",
"yperiod0",
"yperiodalignment",
"ysrc",
"zorder",
 }

# alignmentgroup
# --------------
@property
defalignmentgroup(self):
"""
 Set several traces linked to the same position axis or matching
 axes to the same alignmentgroup. This controls whether bars
 compute their positional range dependently or independently.

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

 Returns
 -------
 str
 """
returnself["alignmentgroup"]

@alignmentgroup.setter
defalignmentgroup(self, val):
self["alignmentgroup"] =val

# cliponaxis
# ----------
@property
defcliponaxis(self):
"""
 Determines whether the text nodes are clipped about the subplot
 axes. To show the text nodes above axis lines and tick labels,
 make sure to set `xaxis.layer` and `yaxis.layer` to *below
 traces*.

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

 Returns
 -------
 bool
 """
returnself["cliponaxis"]

@cliponaxis.setter
defcliponaxis(self, val):
self["cliponaxis"] =val

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

 Supported dict properties:

 fillcolor
 Sets the fill color.
 line
 :class:`plotly.graph_objects.funnel.connector.L
 ine` instance or dict with compatible
 properties
 visible
 Determines if connector regions and lines are
 drawn.

 Returns
 -------
 plotly.graph_objs.funnel.Connector
 """
returnself["connector"]

@connector.setter
defconnector(self, val):
self["connector"] =val

# constraintext
# -------------
@property
defconstraintext(self):
"""
 Constrain the size of text inside or outside a bar to be no
 larger than the bar itself.

 The 'constraintext' property is an enumeration that may be specified as:
 - One of the following enumeration values:
 ['inside', 'outside', 'both', 'none']

 Returns
 -------
 Any
 """
returnself["constraintext"]

@constraintext.setter
defconstraintext(self, val):
self["constraintext"] =val

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

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

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

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

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

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

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

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

# dx
# --
@property
defdx(self):
"""
 Sets the x coordinate step. See `x0` for more info.

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

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

@dx.setter
defdx(self, val):
self["dx"] =val

# dy
# --
@property
defdy(self):
"""
 Sets the y coordinate step. See `y0` for more info.

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

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

@dy.setter
defdy(self, val):
self["dy"] =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 ['name', 'x', 'y', 'text', 'percent initial', 'percent previous', 'percent total'] joined with '+' characters
 (e.g. 'name+x')
 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.funnel.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.funnel.Hoverlabel
 """
returnself["hoverlabel"]

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

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

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

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

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

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

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

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

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

# hovertext
# ---------
@property
defhovertext(self):
"""
 Sets hover text elements associated with each (x,y) pair. 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. To be seen, trace
 `hoverinfo` must contain a "text" flag.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# insidetextanchor
# ----------------
@property
definsidetextanchor(self):
"""
 Determines if texts are kept at center or start/end points in
 `textposition` "inside" mode.

 The 'insidetextanchor' property is an enumeration that may be specified as:
 - One of the following enumeration values:
 ['end', 'middle', 'start']

 Returns
 -------
 Any
 """
returnself["insidetextanchor"]

@insidetextanchor.setter
definsidetextanchor(self, val):
self["insidetextanchor"] =val

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

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

 Supported dict properties:

 color

 colorsrc
 Sets the source reference on Chart Studio Cloud
 for `color`.
 family
 HTML font family - the typeface that will be
 applied by the web browser. The web browser
 will only be able to apply a font if it is
 available on the system which it operates.
 Provide multiple font families, separated by
 commas, to indicate the preference in which to
 apply fonts if they aren't available on the
 system. The Chart Studio Cloud (at
 https://chart-studio.plotly.com or on-premise)
 generates images on a server, where only a
 select number of fonts are installed and
 supported. These include "Arial", "Balto",
 "Courier New", "Droid Sans", "Droid Serif",
 "Droid Sans Mono", "Gravitas One", "Old
 Standard TT", "Open Sans", "Overpass", "PT Sans
 Narrow", "Raleway", "Times New Roman".
 familysrc
 Sets the source reference on Chart Studio Cloud
 for `family`.
 lineposition
 Sets the kind of decoration line(s) with text,
 such as an "under", "over" or "through" as well
 as combinations e.g. "under+over", etc.
 linepositionsrc
 Sets the source reference on Chart Studio Cloud
 for `lineposition`.
 shadow
 Sets the shape and color of the shadow behind
 text. "auto" places minimal shadow and applies
 contrast text font color. See
 https://developer.mozilla.org/en-
 US/docs/Web/CSS/text-shadow for additional
 options.
 shadowsrc
 Sets the source reference on Chart Studio Cloud
 for `shadow`.
 size

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

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

@insidetextfont.setter
definsidetextfont(self, val):
self["insidetextfont"] =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.funnel.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.funnel.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.funnel.Marker`
 - A dict of string/value properties that will be passed
 to the Marker constructor

 Supported dict properties:

 autocolorscale
 Determines whether the colorscale is a default
 palette (`autocolorscale: true`) or the palette
 determined by `marker.colorscale`. Has an
 effect only if 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.funnel.marker.Colo
 rBar` 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.funnel.marker.Line
 ` instance or dict with compatible properties
 opacity
 Sets the opacity of the bars.
 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.

 Returns
 -------
 plotly.graph_objs.funnel.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

# offset
# ------
@property
defoffset(self):
"""
 Shifts the position where the bar is drawn (in position axis
 units). In "group" barmode, traces that set "offset" will be
 excluded and drawn in "overlay" mode instead.

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

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

@offset.setter
defoffset(self, val):
self["offset"] =val

# offsetgroup
# -----------
@property
defoffsetgroup(self):
"""
 Set several traces linked to the same position axis or matching
 axes to the same offsetgroup where bars of the same position
 coordinate will line up.

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

 Returns
 -------
 str
 """
returnself["offsetgroup"]

@offsetgroup.setter