Search is not available for this dataset
identifier
stringlengths 1
155
| parameters
stringlengths 2
6.09k
| docstring
stringlengths 11
63.4k
| docstring_summary
stringlengths 0
63.4k
| function
stringlengths 29
99.8k
| function_tokens
list | start_point
list | end_point
list | language
stringclasses 1
value | docstring_language
stringlengths 2
7
| docstring_language_predictions
stringlengths 18
23
| is_langid_reliable
stringclasses 2
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
Scatterpolar.subplot | (self) |
Sets a reference between this trace's data coordinates and a
polar subplot. If "polar" (the default value), the data refer
to `layout.polar`. If "polar2", the data refer to
`layout.polar2`, and so on.
The 'subplot' property is an identifier of a particular
subplot, of type 'polar', that may be specified as the string 'polar'
optionally followed by an integer >= 1
(e.g. 'polar', 'polar1', 'polar2', 'polar3', etc.)
Returns
-------
str
|
Sets a reference between this trace's data coordinates and a
polar subplot. If "polar" (the default value), the data refer
to `layout.polar`. If "polar2", the data refer to
`layout.polar2`, and so on.
The 'subplot' property is an identifier of a particular
subplot, of type 'polar', that may be specified as the string 'polar'
optionally followed by an integer >= 1
(e.g. 'polar', 'polar1', 'polar2', 'polar3', etc.) | def subplot(self):
"""
Sets a reference between this trace's data coordinates and a
polar subplot. If "polar" (the default value), the data refer
to `layout.polar`. If "polar2", the data refer to
`layout.polar2`, and so on.
The 'subplot' property is an identifier of a particular
subplot, of type 'polar', that may be specified as the string 'polar'
optionally followed by an integer >= 1
(e.g. 'polar', 'polar1', 'polar2', 'polar3', etc.)
Returns
-------
str
"""
return self["subplot"] | [
"def",
"subplot",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"subplot\"",
"]"
] | [
1078,
4
] | [
1094,
30
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.text | (self) |
Sets 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. If trace `hoverinfo` contains a
"text" flag and "hovertext" is not set, these elements will be
seen in the hover labels.
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
-------
str|numpy.ndarray
|
Sets 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. If trace `hoverinfo` contains a
"text" flag and "hovertext" is not set, these elements will be
seen in the hover labels.
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 | def text(self):
"""
Sets 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. If trace `hoverinfo` contains a
"text" flag and "hovertext" is not set, these elements will be
seen in the hover labels.
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
-------
str|numpy.ndarray
"""
return self["text"] | [
"def",
"text",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"text\"",
"]"
] | [
1103,
4
] | [
1121,
27
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.textfont | (self) |
Sets the text font.
The 'textfont' property is an instance of Textfont
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolar.Textfont`
- A dict of string/value properties that will be passed
to the Textfont 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 .
size
sizesrc
Sets the source reference on Chart Studio Cloud
for size .
Returns
-------
plotly.graph_objs.scatterpolar.Textfont
|
Sets the text font.
The 'textfont' property is an instance of Textfont
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolar.Textfont`
- A dict of string/value properties that will be passed
to the Textfont 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 .
size
sizesrc
Sets the source reference on Chart Studio Cloud
for size . | def textfont(self):
"""
Sets the text font.
The 'textfont' property is an instance of Textfont
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolar.Textfont`
- A dict of string/value properties that will be passed
to the Textfont 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 .
size
sizesrc
Sets the source reference on Chart Studio Cloud
for size .
Returns
-------
plotly.graph_objs.scatterpolar.Textfont
"""
return self["textfont"] | [
"def",
"textfont",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"textfont\"",
"]"
] | [
1130,
4
] | [
1177,
31
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.textposition | (self) |
Sets the positions of the `text` elements with respects to the
(x,y) coordinates.
The 'textposition' property is an enumeration that may be specified as:
- One of the following enumeration values:
['top left', 'top center', 'top right', 'middle left',
'middle center', 'middle right', 'bottom left', 'bottom
center', 'bottom right']
- A tuple, list, or one-dimensional numpy array of the above
Returns
-------
Any|numpy.ndarray
|
Sets the positions of the `text` elements with respects to the
(x,y) coordinates.
The 'textposition' property is an enumeration that may be specified as:
- One of the following enumeration values:
['top left', 'top center', 'top right', 'middle left',
'middle center', 'middle right', 'bottom left', 'bottom
center', 'bottom right']
- A tuple, list, or one-dimensional numpy array of the above | def textposition(self):
"""
Sets the positions of the `text` elements with respects to the
(x,y) coordinates.
The 'textposition' property is an enumeration that may be specified as:
- One of the following enumeration values:
['top left', 'top center', 'top right', 'middle left',
'middle center', 'middle right', 'bottom left', 'bottom
center', 'bottom right']
- A tuple, list, or one-dimensional numpy array of the above
Returns
-------
Any|numpy.ndarray
"""
return self["textposition"] | [
"def",
"textposition",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"textposition\"",
"]"
] | [
1186,
4
] | [
1202,
35
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.textpositionsrc | (self) |
Sets the source reference on Chart Studio Cloud for
textposition .
The 'textpositionsrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
|
Sets the source reference on Chart Studio Cloud for
textposition .
The 'textpositionsrc' property must be specified as a string or
as a plotly.grid_objs.Column object | def textpositionsrc(self):
"""
Sets the source reference on Chart Studio Cloud for
textposition .
The 'textpositionsrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
"""
return self["textpositionsrc"] | [
"def",
"textpositionsrc",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"textpositionsrc\"",
"]"
] | [
1211,
4
] | [
1223,
38
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.textsrc | (self) |
Sets the source reference on Chart Studio Cloud for text .
The 'textsrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
|
Sets the source reference on Chart Studio Cloud for text .
The 'textsrc' property must be specified as a string or
as a plotly.grid_objs.Column object | def textsrc(self):
"""
Sets the source reference on Chart Studio Cloud for text .
The 'textsrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
"""
return self["textsrc"] | [
"def",
"textsrc",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"textsrc\"",
"]"
] | [
1232,
4
] | [
1243,
30
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.texttemplate | (self) |
Template string used for rendering the information text that
appear on points. Note that this will override `textinfo`.
Variables are inserted using %{variable}, for example "y:
%{y}". Numbers are formatted using d3-format's syntax
%{variable:d3-format}, for example "Price: %{y:$.2f}".
https://github.com/d3/d3-3.x-api-
reference/blob/master/Formatting.md#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-3.x-api-
reference/blob/master/Time-Formatting.md#format for details on
the date formatting syntax. Every attributes that can be
specified per-point (the ones that are `arrayOk: true`) are
available. variables `r`, `theta` and `text`.
The 'texttemplate' 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
|
Template string used for rendering the information text that
appear on points. Note that this will override `textinfo`.
Variables are inserted using %{variable}, for example "y:
%{y}". Numbers are formatted using d3-format's syntax
%{variable:d3-format}, for example "Price: %{y:$.2f}".
https://github.com/d3/d3-3.x-api-
reference/blob/master/Formatting.md#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-3.x-api-
reference/blob/master/Time-Formatting.md#format for details on
the date formatting syntax. Every attributes that can be
specified per-point (the ones that are `arrayOk: true`) are
available. variables `r`, `theta` and `text`.
The 'texttemplate' 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 | def texttemplate(self):
"""
Template string used for rendering the information text that
appear on points. Note that this will override `textinfo`.
Variables are inserted using %{variable}, for example "y:
%{y}". Numbers are formatted using d3-format's syntax
%{variable:d3-format}, for example "Price: %{y:$.2f}".
https://github.com/d3/d3-3.x-api-
reference/blob/master/Formatting.md#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-3.x-api-
reference/blob/master/Time-Formatting.md#format for details on
the date formatting syntax. Every attributes that can be
specified per-point (the ones that are `arrayOk: true`) are
available. variables `r`, `theta` and `text`.
The 'texttemplate' 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
"""
return self["texttemplate"] | [
"def",
"texttemplate",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"texttemplate\"",
"]"
] | [
1252,
4
] | [
1278,
35
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.texttemplatesrc | (self) |
Sets the source reference on Chart Studio Cloud for
texttemplate .
The 'texttemplatesrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
|
Sets the source reference on Chart Studio Cloud for
texttemplate .
The 'texttemplatesrc' property must be specified as a string or
as a plotly.grid_objs.Column object | def texttemplatesrc(self):
"""
Sets the source reference on Chart Studio Cloud for
texttemplate .
The 'texttemplatesrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
"""
return self["texttemplatesrc"] | [
"def",
"texttemplatesrc",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"texttemplatesrc\"",
"]"
] | [
1287,
4
] | [
1299,
38
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.theta | (self) |
Sets the angular coordinates
The 'theta' property is an array that may be specified as a tuple,
list, numpy array, or pandas Series
Returns
-------
numpy.ndarray
|
Sets the angular coordinates
The 'theta' property is an array that may be specified as a tuple,
list, numpy array, or pandas Series | def theta(self):
"""
Sets the angular coordinates
The 'theta' property is an array that may be specified as a tuple,
list, numpy array, or pandas Series
Returns
-------
numpy.ndarray
"""
return self["theta"] | [
"def",
"theta",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"theta\"",
"]"
] | [
1308,
4
] | [
1319,
28
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.theta0 | (self) |
Alternate to `theta`. Builds a linear space of theta
coordinates. Use with `dtheta` where `theta0` is the starting
coordinate and `dtheta` the step.
The 'theta0' property accepts values of any type
Returns
-------
Any
|
Alternate to `theta`. Builds a linear space of theta
coordinates. Use with `dtheta` where `theta0` is the starting
coordinate and `dtheta` the step.
The 'theta0' property accepts values of any type | def theta0(self):
"""
Alternate to `theta`. Builds a linear space of theta
coordinates. Use with `dtheta` where `theta0` is the starting
coordinate and `dtheta` the step.
The 'theta0' property accepts values of any type
Returns
-------
Any
"""
return self["theta0"] | [
"def",
"theta0",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"theta0\"",
"]"
] | [
1328,
4
] | [
1340,
29
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.thetasrc | (self) |
Sets the source reference on Chart Studio Cloud for theta .
The 'thetasrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
|
Sets the source reference on Chart Studio Cloud for theta .
The 'thetasrc' property must be specified as a string or
as a plotly.grid_objs.Column object | def thetasrc(self):
"""
Sets the source reference on Chart Studio Cloud for theta .
The 'thetasrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
"""
return self["thetasrc"] | [
"def",
"thetasrc",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"thetasrc\"",
"]"
] | [
1349,
4
] | [
1360,
31
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.thetaunit | (self) |
Sets the unit of input "theta" values. Has an effect only when
on "linear" angular axes.
The 'thetaunit' property is an enumeration that may be specified as:
- One of the following enumeration values:
['radians', 'degrees', 'gradians']
Returns
-------
Any
|
Sets the unit of input "theta" values. Has an effect only when
on "linear" angular axes.
The 'thetaunit' property is an enumeration that may be specified as:
- One of the following enumeration values:
['radians', 'degrees', 'gradians'] | def thetaunit(self):
"""
Sets the unit of input "theta" values. Has an effect only when
on "linear" angular axes.
The 'thetaunit' property is an enumeration that may be specified as:
- One of the following enumeration values:
['radians', 'degrees', 'gradians']
Returns
-------
Any
"""
return self["thetaunit"] | [
"def",
"thetaunit",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"thetaunit\"",
"]"
] | [
1369,
4
] | [
1382,
32
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.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
|
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 | 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"] | [
"def",
"uid",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"uid\"",
"]"
] | [
1391,
4
] | [
1404,
26
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.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
|
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 | 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"] | [
"def",
"uirevision",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"uirevision\"",
"]"
] | [
1413,
4
] | [
1437,
33
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.unselected | (self) |
The 'unselected' property is an instance of Unselected
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolar.Unselected`
- A dict of string/value properties that will be passed
to the Unselected constructor
Supported dict properties:
marker
:class:`plotly.graph_objects.scatterpolar.unsel
ected.Marker` instance or dict with compatible
properties
textfont
:class:`plotly.graph_objects.scatterpolar.unsel
ected.Textfont` instance or dict with
compatible properties
Returns
-------
plotly.graph_objs.scatterpolar.Unselected
|
The 'unselected' property is an instance of Unselected
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolar.Unselected`
- A dict of string/value properties that will be passed
to the Unselected constructor
Supported dict properties:
marker
:class:`plotly.graph_objects.scatterpolar.unsel
ected.Marker` instance or dict with compatible
properties
textfont
:class:`plotly.graph_objects.scatterpolar.unsel
ected.Textfont` instance or dict with
compatible properties | def unselected(self):
"""
The 'unselected' property is an instance of Unselected
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolar.Unselected`
- A dict of string/value properties that will be passed
to the Unselected constructor
Supported dict properties:
marker
:class:`plotly.graph_objects.scatterpolar.unsel
ected.Marker` instance or dict with compatible
properties
textfont
:class:`plotly.graph_objects.scatterpolar.unsel
ected.Textfont` instance or dict with
compatible properties
Returns
-------
plotly.graph_objs.scatterpolar.Unselected
"""
return self["unselected"] | [
"def",
"unselected",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"unselected\"",
"]"
] | [
1446,
4
] | [
1469,
33
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.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
|
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'] | 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"] | [
"def",
"visible",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"visible\"",
"]"
] | [
1478,
4
] | [
1492,
30
] | python | en | ['en', 'error', 'th'] | False |
Scatterpolar.__init__ | (
self,
arg=None,
cliponaxis=None,
connectgaps=None,
customdata=None,
customdatasrc=None,
dr=None,
dtheta=None,
fill=None,
fillcolor=None,
hoverinfo=None,
hoverinfosrc=None,
hoverlabel=None,
hoveron=None,
hovertemplate=None,
hovertemplatesrc=None,
hovertext=None,
hovertextsrc=None,
ids=None,
idssrc=None,
legendgroup=None,
line=None,
marker=None,
meta=None,
metasrc=None,
mode=None,
name=None,
opacity=None,
r=None,
r0=None,
rsrc=None,
selected=None,
selectedpoints=None,
showlegend=None,
stream=None,
subplot=None,
text=None,
textfont=None,
textposition=None,
textpositionsrc=None,
textsrc=None,
texttemplate=None,
texttemplatesrc=None,
theta=None,
theta0=None,
thetasrc=None,
thetaunit=None,
uid=None,
uirevision=None,
unselected=None,
visible=None,
**kwargs
) |
Construct a new Scatterpolar object
The scatterpolar trace type encompasses line charts, scatter
charts, text charts, and bubble charts in polar coordinates.
The data visualized as scatter point or lines is set in `r`
(radial) and `theta` (angular) coordinates Text (appearing
either on the chart or on hover only) is via `text`. Bubble
charts are achieved by setting `marker.size` and/or
`marker.color` to numerical arrays.
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of :class:`plotly.graph_objs.Scatterpolar`
cliponaxis
Determines whether or not markers and text nodes are
clipped about the subplot axes. To show markers and
text nodes above axis lines and tick labels, make sure
to set `xaxis.layer` and `yaxis.layer` to *below
traces*.
connectgaps
Determines whether or not gaps (i.e. {nan} or missing
values) in the provided data arrays are connected.
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 .
dr
Sets the r coordinate step.
dtheta
Sets the theta coordinate step. By default, the
`dtheta` step equals the subplot's period divided by
the length of the `r` coordinates.
fill
Sets the area to fill with a solid color. Use with
`fillcolor` if not "none". scatterpolar has a subset of
the options available to scatter. "toself" connects the
endpoints of the trace (or each segment of the trace if
it has gaps) into a closed shape. "tonext" fills the
space between two traces if one completely encloses the
other (eg consecutive contour lines), and behaves like
"toself" if there is no trace before it. "tonext"
should not be used if one trace does not enclose the
other.
fillcolor
Sets the fill color. Defaults to a half-transparent
variant of the line color, marker color, or marker line
color, whichever is available.
hoverinfo
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.
hoverinfosrc
Sets the source reference on Chart Studio Cloud for
hoverinfo .
hoverlabel
:class:`plotly.graph_objects.scatterpolar.Hoverlabel`
instance or dict with compatible properties
hoveron
Do the hover effects highlight individual points
(markers or line points) or do they highlight filled
regions? If the fill is "toself" or "tonext" and there
are no markers or text, then the default is "fills",
otherwise it is "points".
hovertemplate
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}". Numbers are formatted using
d3-format's syntax %{variable:d3-format}, for example
"Price: %{y:$.2f}". https://github.com/d3/d3-3.x-api-
reference/blob/master/Formatting.md#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-3.x-api-
reference/blob/master/Time-Formatting.md#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>`.
hovertemplatesrc
Sets the source reference on Chart Studio Cloud for
hovertemplate .
hovertext
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.
hovertextsrc
Sets the source reference on Chart Studio Cloud for
hovertext .
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 .
legendgroup
Sets the legend group for this trace. Traces part of
the same legend group hide/show at the same time when
toggling legend items.
line
:class:`plotly.graph_objects.scatterpolar.Line`
instance or dict with compatible properties
marker
:class:`plotly.graph_objects.scatterpolar.Marker`
instance or dict with compatible properties
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 .
mode
Determines the drawing mode for this scatter trace. If
the provided `mode` includes "text" then the `text`
elements appear at the coordinates. Otherwise, the
`text` elements appear on hover. If there are less than
20 points and the trace is not stacked then the default
is "lines+markers". Otherwise, "lines".
name
Sets the trace name. The trace name appear as the
legend item and on hover.
opacity
Sets the opacity of the trace.
r
Sets the radial coordinates
r0
Alternate to `r`. Builds a linear space of r
coordinates. Use with `dr` where `r0` is the starting
coordinate and `dr` the step.
rsrc
Sets the source reference on Chart Studio Cloud for r
.
selected
:class:`plotly.graph_objects.scatterpolar.Selected`
instance or dict with compatible properties
selectedpoints
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.
showlegend
Determines whether or not an item corresponding to this
trace is shown in the legend.
stream
:class:`plotly.graph_objects.scatterpolar.Stream`
instance or dict with compatible properties
subplot
Sets a reference between this trace's data coordinates
and a polar subplot. If "polar" (the default value),
the data refer to `layout.polar`. If "polar2", the data
refer to `layout.polar2`, and so on.
text
Sets 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.
If trace `hoverinfo` contains a "text" flag and
"hovertext" is not set, these elements will be seen in
the hover labels.
textfont
Sets the text font.
textposition
Sets the positions of the `text` elements with respects
to the (x,y) coordinates.
textpositionsrc
Sets the source reference on Chart Studio Cloud for
textposition .
textsrc
Sets the source reference on Chart Studio Cloud for
text .
texttemplate
Template string used for rendering the information text
that appear on points. Note that this will override
`textinfo`. Variables are inserted using %{variable},
for example "y: %{y}". Numbers are formatted using
d3-format's syntax %{variable:d3-format}, for example
"Price: %{y:$.2f}". https://github.com/d3/d3-3.x-api-
reference/blob/master/Formatting.md#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-3.x-api-
reference/blob/master/Time-Formatting.md#format for
details on the date formatting syntax. Every attributes
that can be specified per-point (the ones that are
`arrayOk: true`) are available. variables `r`, `theta`
and `text`.
texttemplatesrc
Sets the source reference on Chart Studio Cloud for
texttemplate .
theta
Sets the angular coordinates
theta0
Alternate to `theta`. Builds a linear space of theta
coordinates. Use with `dtheta` where `theta0` is the
starting coordinate and `dtheta` the step.
thetasrc
Sets the source reference on Chart Studio Cloud for
theta .
thetaunit
Sets the unit of input "theta" values. Has an effect
only when on "linear" angular axes.
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.
unselected
:class:`plotly.graph_objects.scatterpolar.Unselected`
instance or dict with compatible properties
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).
Returns
-------
Scatterpolar
|
Construct a new Scatterpolar object
The scatterpolar trace type encompasses line charts, scatter
charts, text charts, and bubble charts in polar coordinates.
The data visualized as scatter point or lines is set in `r`
(radial) and `theta` (angular) coordinates Text (appearing
either on the chart or on hover only) is via `text`. Bubble
charts are achieved by setting `marker.size` and/or
`marker.color` to numerical arrays. | def __init__(
self,
arg=None,
cliponaxis=None,
connectgaps=None,
customdata=None,
customdatasrc=None,
dr=None,
dtheta=None,
fill=None,
fillcolor=None,
hoverinfo=None,
hoverinfosrc=None,
hoverlabel=None,
hoveron=None,
hovertemplate=None,
hovertemplatesrc=None,
hovertext=None,
hovertextsrc=None,
ids=None,
idssrc=None,
legendgroup=None,
line=None,
marker=None,
meta=None,
metasrc=None,
mode=None,
name=None,
opacity=None,
r=None,
r0=None,
rsrc=None,
selected=None,
selectedpoints=None,
showlegend=None,
stream=None,
subplot=None,
text=None,
textfont=None,
textposition=None,
textpositionsrc=None,
textsrc=None,
texttemplate=None,
texttemplatesrc=None,
theta=None,
theta0=None,
thetasrc=None,
thetaunit=None,
uid=None,
uirevision=None,
unselected=None,
visible=None,
**kwargs
):
"""
Construct a new Scatterpolar object
The scatterpolar trace type encompasses line charts, scatter
charts, text charts, and bubble charts in polar coordinates.
The data visualized as scatter point or lines is set in `r`
(radial) and `theta` (angular) coordinates Text (appearing
either on the chart or on hover only) is via `text`. Bubble
charts are achieved by setting `marker.size` and/or
`marker.color` to numerical arrays.
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of :class:`plotly.graph_objs.Scatterpolar`
cliponaxis
Determines whether or not markers and text nodes are
clipped about the subplot axes. To show markers and
text nodes above axis lines and tick labels, make sure
to set `xaxis.layer` and `yaxis.layer` to *below
traces*.
connectgaps
Determines whether or not gaps (i.e. {nan} or missing
values) in the provided data arrays are connected.
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 .
dr
Sets the r coordinate step.
dtheta
Sets the theta coordinate step. By default, the
`dtheta` step equals the subplot's period divided by
the length of the `r` coordinates.
fill
Sets the area to fill with a solid color. Use with
`fillcolor` if not "none". scatterpolar has a subset of
the options available to scatter. "toself" connects the
endpoints of the trace (or each segment of the trace if
it has gaps) into a closed shape. "tonext" fills the
space between two traces if one completely encloses the
other (eg consecutive contour lines), and behaves like
"toself" if there is no trace before it. "tonext"
should not be used if one trace does not enclose the
other.
fillcolor
Sets the fill color. Defaults to a half-transparent
variant of the line color, marker color, or marker line
color, whichever is available.
hoverinfo
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.
hoverinfosrc
Sets the source reference on Chart Studio Cloud for
hoverinfo .
hoverlabel
:class:`plotly.graph_objects.scatterpolar.Hoverlabel`
instance or dict with compatible properties
hoveron
Do the hover effects highlight individual points
(markers or line points) or do they highlight filled
regions? If the fill is "toself" or "tonext" and there
are no markers or text, then the default is "fills",
otherwise it is "points".
hovertemplate
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}". Numbers are formatted using
d3-format's syntax %{variable:d3-format}, for example
"Price: %{y:$.2f}". https://github.com/d3/d3-3.x-api-
reference/blob/master/Formatting.md#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-3.x-api-
reference/blob/master/Time-Formatting.md#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>`.
hovertemplatesrc
Sets the source reference on Chart Studio Cloud for
hovertemplate .
hovertext
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.
hovertextsrc
Sets the source reference on Chart Studio Cloud for
hovertext .
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 .
legendgroup
Sets the legend group for this trace. Traces part of
the same legend group hide/show at the same time when
toggling legend items.
line
:class:`plotly.graph_objects.scatterpolar.Line`
instance or dict with compatible properties
marker
:class:`plotly.graph_objects.scatterpolar.Marker`
instance or dict with compatible properties
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 .
mode
Determines the drawing mode for this scatter trace. If
the provided `mode` includes "text" then the `text`
elements appear at the coordinates. Otherwise, the
`text` elements appear on hover. If there are less than
20 points and the trace is not stacked then the default
is "lines+markers". Otherwise, "lines".
name
Sets the trace name. The trace name appear as the
legend item and on hover.
opacity
Sets the opacity of the trace.
r
Sets the radial coordinates
r0
Alternate to `r`. Builds a linear space of r
coordinates. Use with `dr` where `r0` is the starting
coordinate and `dr` the step.
rsrc
Sets the source reference on Chart Studio Cloud for r
.
selected
:class:`plotly.graph_objects.scatterpolar.Selected`
instance or dict with compatible properties
selectedpoints
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.
showlegend
Determines whether or not an item corresponding to this
trace is shown in the legend.
stream
:class:`plotly.graph_objects.scatterpolar.Stream`
instance or dict with compatible properties
subplot
Sets a reference between this trace's data coordinates
and a polar subplot. If "polar" (the default value),
the data refer to `layout.polar`. If "polar2", the data
refer to `layout.polar2`, and so on.
text
Sets 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.
If trace `hoverinfo` contains a "text" flag and
"hovertext" is not set, these elements will be seen in
the hover labels.
textfont
Sets the text font.
textposition
Sets the positions of the `text` elements with respects
to the (x,y) coordinates.
textpositionsrc
Sets the source reference on Chart Studio Cloud for
textposition .
textsrc
Sets the source reference on Chart Studio Cloud for
text .
texttemplate
Template string used for rendering the information text
that appear on points. Note that this will override
`textinfo`. Variables are inserted using %{variable},
for example "y: %{y}". Numbers are formatted using
d3-format's syntax %{variable:d3-format}, for example
"Price: %{y:$.2f}". https://github.com/d3/d3-3.x-api-
reference/blob/master/Formatting.md#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-3.x-api-
reference/blob/master/Time-Formatting.md#format for
details on the date formatting syntax. Every attributes
that can be specified per-point (the ones that are
`arrayOk: true`) are available. variables `r`, `theta`
and `text`.
texttemplatesrc
Sets the source reference on Chart Studio Cloud for
texttemplate .
theta
Sets the angular coordinates
theta0
Alternate to `theta`. Builds a linear space of theta
coordinates. Use with `dtheta` where `theta0` is the
starting coordinate and `dtheta` the step.
thetasrc
Sets the source reference on Chart Studio Cloud for
theta .
thetaunit
Sets the unit of input "theta" values. Has an effect
only when on "linear" angular axes.
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.
unselected
:class:`plotly.graph_objects.scatterpolar.Unselected`
instance or dict with compatible properties
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).
Returns
-------
Scatterpolar
"""
super(Scatterpolar, self).__init__("scatterpolar")
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.Scatterpolar
constructor must be a dict or
an instance of :class:`plotly.graph_objs.Scatterpolar`"""
)
# 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("cliponaxis", None)
_v = cliponaxis if cliponaxis is not None else _v
if _v is not None:
self["cliponaxis"] = _v
_v = arg.pop("connectgaps", None)
_v = connectgaps if connectgaps is not None else _v
if _v is not None:
self["connectgaps"] = _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("dr", None)
_v = dr if dr is not None else _v
if _v is not None:
self["dr"] = _v
_v = arg.pop("dtheta", None)
_v = dtheta if dtheta is not None else _v
if _v is not None:
self["dtheta"] = _v
_v = arg.pop("fill", None)
_v = fill if fill is not None else _v
if _v is not None:
self["fill"] = _v
_v = arg.pop("fillcolor", None)
_v = fillcolor if fillcolor is not None else _v
if _v is not None:
self["fillcolor"] = _v
_v = arg.pop("hoverinfo", None)
_v = hoverinfo if hoverinfo is not None else _v
if _v is not None:
self["hoverinfo"] = _v
_v = arg.pop("hoverinfosrc", None)
_v = hoverinfosrc if hoverinfosrc is not None else _v
if _v is not None:
self["hoverinfosrc"] = _v
_v = arg.pop("hoverlabel", None)
_v = hoverlabel if hoverlabel is not None else _v
if _v is not None:
self["hoverlabel"] = _v
_v = arg.pop("hoveron", None)
_v = hoveron if hoveron is not None else _v
if _v is not None:
self["hoveron"] = _v
_v = arg.pop("hovertemplate", None)
_v = hovertemplate if hovertemplate is not None else _v
if _v is not None:
self["hovertemplate"] = _v
_v = arg.pop("hovertemplatesrc", None)
_v = hovertemplatesrc if hovertemplatesrc is not None else _v
if _v is not None:
self["hovertemplatesrc"] = _v
_v = arg.pop("hovertext", None)
_v = hovertext if hovertext is not None else _v
if _v is not None:
self["hovertext"] = _v
_v = arg.pop("hovertextsrc", None)
_v = hovertextsrc if hovertextsrc is not None else _v
if _v is not None:
self["hovertextsrc"] = _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("legendgroup", None)
_v = legendgroup if legendgroup is not None else _v
if _v is not None:
self["legendgroup"] = _v
_v = arg.pop("line", None)
_v = line if line is not None else _v
if _v is not None:
self["line"] = _v
_v = arg.pop("marker", None)
_v = marker if marker is not None else _v
if _v is not None:
self["marker"] = _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("mode", None)
_v = mode if mode is not None else _v
if _v is not None:
self["mode"] = _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("r", None)
_v = r if r is not None else _v
if _v is not None:
self["r"] = _v
_v = arg.pop("r0", None)
_v = r0 if r0 is not None else _v
if _v is not None:
self["r0"] = _v
_v = arg.pop("rsrc", None)
_v = rsrc if rsrc is not None else _v
if _v is not None:
self["rsrc"] = _v
_v = arg.pop("selected", None)
_v = selected if selected is not None else _v
if _v is not None:
self["selected"] = _v
_v = arg.pop("selectedpoints", None)
_v = selectedpoints if selectedpoints is not None else _v
if _v is not None:
self["selectedpoints"] = _v
_v = arg.pop("showlegend", None)
_v = showlegend if showlegend is not None else _v
if _v is not None:
self["showlegend"] = _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("subplot", None)
_v = subplot if subplot is not None else _v
if _v is not None:
self["subplot"] = _v
_v = arg.pop("text", None)
_v = text if text is not None else _v
if _v is not None:
self["text"] = _v
_v = arg.pop("textfont", None)
_v = textfont if textfont is not None else _v
if _v is not None:
self["textfont"] = _v
_v = arg.pop("textposition", None)
_v = textposition if textposition is not None else _v
if _v is not None:
self["textposition"] = _v
_v = arg.pop("textpositionsrc", None)
_v = textpositionsrc if textpositionsrc is not None else _v
if _v is not None:
self["textpositionsrc"] = _v
_v = arg.pop("textsrc", None)
_v = textsrc if textsrc is not None else _v
if _v is not None:
self["textsrc"] = _v
_v = arg.pop("texttemplate", None)
_v = texttemplate if texttemplate is not None else _v
if _v is not None:
self["texttemplate"] = _v
_v = arg.pop("texttemplatesrc", None)
_v = texttemplatesrc if texttemplatesrc is not None else _v
if _v is not None:
self["texttemplatesrc"] = _v
_v = arg.pop("theta", None)
_v = theta if theta is not None else _v
if _v is not None:
self["theta"] = _v
_v = arg.pop("theta0", None)
_v = theta0 if theta0 is not None else _v
if _v is not None:
self["theta0"] = _v
_v = arg.pop("thetasrc", None)
_v = thetasrc if thetasrc is not None else _v
if _v is not None:
self["thetasrc"] = _v
_v = arg.pop("thetaunit", None)
_v = thetaunit if thetaunit is not None else _v
if _v is not None:
self["thetaunit"] = _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("unselected", None)
_v = unselected if unselected is not None else _v
if _v is not None:
self["unselected"] = _v
_v = arg.pop("visible", None)
_v = visible if visible is not None else _v
if _v is not None:
self["visible"] = _v
# Read-only literals
# ------------------
self._props["type"] = "scatterpolar"
arg.pop("type", None)
# Process unknown kwargs
# ----------------------
self._process_kwargs(**dict(arg, **kwargs))
# Reset skip_invalid
# ------------------
self._skip_invalid = False | [
"def",
"__init__",
"(",
"self",
",",
"arg",
"=",
"None",
",",
"cliponaxis",
"=",
"None",
",",
"connectgaps",
"=",
"None",
",",
"customdata",
"=",
"None",
",",
"customdatasrc",
"=",
"None",
",",
"dr",
"=",
"None",
",",
"dtheta",
"=",
"None",
",",
"fill",
"=",
"None",
",",
"fillcolor",
"=",
"None",
",",
"hoverinfo",
"=",
"None",
",",
"hoverinfosrc",
"=",
"None",
",",
"hoverlabel",
"=",
"None",
",",
"hoveron",
"=",
"None",
",",
"hovertemplate",
"=",
"None",
",",
"hovertemplatesrc",
"=",
"None",
",",
"hovertext",
"=",
"None",
",",
"hovertextsrc",
"=",
"None",
",",
"ids",
"=",
"None",
",",
"idssrc",
"=",
"None",
",",
"legendgroup",
"=",
"None",
",",
"line",
"=",
"None",
",",
"marker",
"=",
"None",
",",
"meta",
"=",
"None",
",",
"metasrc",
"=",
"None",
",",
"mode",
"=",
"None",
",",
"name",
"=",
"None",
",",
"opacity",
"=",
"None",
",",
"r",
"=",
"None",
",",
"r0",
"=",
"None",
",",
"rsrc",
"=",
"None",
",",
"selected",
"=",
"None",
",",
"selectedpoints",
"=",
"None",
",",
"showlegend",
"=",
"None",
",",
"stream",
"=",
"None",
",",
"subplot",
"=",
"None",
",",
"text",
"=",
"None",
",",
"textfont",
"=",
"None",
",",
"textposition",
"=",
"None",
",",
"textpositionsrc",
"=",
"None",
",",
"textsrc",
"=",
"None",
",",
"texttemplate",
"=",
"None",
",",
"texttemplatesrc",
"=",
"None",
",",
"theta",
"=",
"None",
",",
"theta0",
"=",
"None",
",",
"thetasrc",
"=",
"None",
",",
"thetaunit",
"=",
"None",
",",
"uid",
"=",
"None",
",",
"uirevision",
"=",
"None",
",",
"unselected",
"=",
"None",
",",
"visible",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"super",
"(",
"Scatterpolar",
",",
"self",
")",
".",
"__init__",
"(",
"\"scatterpolar\"",
")",
"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",
"(",
"\"\"\"\\\nThe first argument to the plotly.graph_objs.Scatterpolar \nconstructor must be a dict or \nan instance of :class:`plotly.graph_objs.Scatterpolar`\"\"\"",
")",
"# 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",
"(",
"\"cliponaxis\"",
",",
"None",
")",
"_v",
"=",
"cliponaxis",
"if",
"cliponaxis",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"cliponaxis\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"connectgaps\"",
",",
"None",
")",
"_v",
"=",
"connectgaps",
"if",
"connectgaps",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"connectgaps\"",
"]",
"=",
"_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",
"(",
"\"dr\"",
",",
"None",
")",
"_v",
"=",
"dr",
"if",
"dr",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"dr\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"dtheta\"",
",",
"None",
")",
"_v",
"=",
"dtheta",
"if",
"dtheta",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"dtheta\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"fill\"",
",",
"None",
")",
"_v",
"=",
"fill",
"if",
"fill",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"fill\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"fillcolor\"",
",",
"None",
")",
"_v",
"=",
"fillcolor",
"if",
"fillcolor",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"fillcolor\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"hoverinfo\"",
",",
"None",
")",
"_v",
"=",
"hoverinfo",
"if",
"hoverinfo",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"hoverinfo\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"hoverinfosrc\"",
",",
"None",
")",
"_v",
"=",
"hoverinfosrc",
"if",
"hoverinfosrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"hoverinfosrc\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"hoverlabel\"",
",",
"None",
")",
"_v",
"=",
"hoverlabel",
"if",
"hoverlabel",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"hoverlabel\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"hoveron\"",
",",
"None",
")",
"_v",
"=",
"hoveron",
"if",
"hoveron",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"hoveron\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"hovertemplate\"",
",",
"None",
")",
"_v",
"=",
"hovertemplate",
"if",
"hovertemplate",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"hovertemplate\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"hovertemplatesrc\"",
",",
"None",
")",
"_v",
"=",
"hovertemplatesrc",
"if",
"hovertemplatesrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"hovertemplatesrc\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"hovertext\"",
",",
"None",
")",
"_v",
"=",
"hovertext",
"if",
"hovertext",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"hovertext\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"hovertextsrc\"",
",",
"None",
")",
"_v",
"=",
"hovertextsrc",
"if",
"hovertextsrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"hovertextsrc\"",
"]",
"=",
"_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",
"(",
"\"legendgroup\"",
",",
"None",
")",
"_v",
"=",
"legendgroup",
"if",
"legendgroup",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"legendgroup\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"line\"",
",",
"None",
")",
"_v",
"=",
"line",
"if",
"line",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"line\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"marker\"",
",",
"None",
")",
"_v",
"=",
"marker",
"if",
"marker",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"marker\"",
"]",
"=",
"_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",
"(",
"\"mode\"",
",",
"None",
")",
"_v",
"=",
"mode",
"if",
"mode",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"mode\"",
"]",
"=",
"_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",
"(",
"\"r\"",
",",
"None",
")",
"_v",
"=",
"r",
"if",
"r",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"r\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"r0\"",
",",
"None",
")",
"_v",
"=",
"r0",
"if",
"r0",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"r0\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"rsrc\"",
",",
"None",
")",
"_v",
"=",
"rsrc",
"if",
"rsrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"rsrc\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"selected\"",
",",
"None",
")",
"_v",
"=",
"selected",
"if",
"selected",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"selected\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"selectedpoints\"",
",",
"None",
")",
"_v",
"=",
"selectedpoints",
"if",
"selectedpoints",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"selectedpoints\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"showlegend\"",
",",
"None",
")",
"_v",
"=",
"showlegend",
"if",
"showlegend",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"showlegend\"",
"]",
"=",
"_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",
"(",
"\"subplot\"",
",",
"None",
")",
"_v",
"=",
"subplot",
"if",
"subplot",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"subplot\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"text\"",
",",
"None",
")",
"_v",
"=",
"text",
"if",
"text",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"text\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"textfont\"",
",",
"None",
")",
"_v",
"=",
"textfont",
"if",
"textfont",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"textfont\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"textposition\"",
",",
"None",
")",
"_v",
"=",
"textposition",
"if",
"textposition",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"textposition\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"textpositionsrc\"",
",",
"None",
")",
"_v",
"=",
"textpositionsrc",
"if",
"textpositionsrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"textpositionsrc\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"textsrc\"",
",",
"None",
")",
"_v",
"=",
"textsrc",
"if",
"textsrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"textsrc\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"texttemplate\"",
",",
"None",
")",
"_v",
"=",
"texttemplate",
"if",
"texttemplate",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"texttemplate\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"texttemplatesrc\"",
",",
"None",
")",
"_v",
"=",
"texttemplatesrc",
"if",
"texttemplatesrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"texttemplatesrc\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"theta\"",
",",
"None",
")",
"_v",
"=",
"theta",
"if",
"theta",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"theta\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"theta0\"",
",",
"None",
")",
"_v",
"=",
"theta0",
"if",
"theta0",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"theta0\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"thetasrc\"",
",",
"None",
")",
"_v",
"=",
"thetasrc",
"if",
"thetasrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"thetasrc\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"thetaunit\"",
",",
"None",
")",
"_v",
"=",
"thetaunit",
"if",
"thetaunit",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"thetaunit\"",
"]",
"=",
"_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",
"(",
"\"unselected\"",
",",
"None",
")",
"_v",
"=",
"unselected",
"if",
"unselected",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"unselected\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"visible\"",
",",
"None",
")",
"_v",
"=",
"visible",
"if",
"visible",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"visible\"",
"]",
"=",
"_v",
"# Read-only literals",
"# ------------------",
"self",
".",
"_props",
"[",
"\"type\"",
"]",
"=",
"\"scatterpolar\"",
"arg",
".",
"pop",
"(",
"\"type\"",
",",
"None",
")",
"# Process unknown kwargs",
"# ----------------------",
"self",
".",
"_process_kwargs",
"(",
"*",
"*",
"dict",
"(",
"arg",
",",
"*",
"*",
"kwargs",
")",
")",
"# Reset skip_invalid",
"# ------------------",
"self",
".",
"_skip_invalid",
"=",
"False"
] | [
1758,
4
] | [
2318,
34
] | python | en | ['en', 'error', 'th'] | False |
Line.color | (self) |
Sets the color of line bounding the box(es).
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
|
Sets the color of line bounding the box(es).
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 | def color(self):
"""
Sets the color of line bounding the box(es).
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"] | [
"def",
"color",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"color\"",
"]"
] | [
15,
4
] | [
65,
28
] | python | en | ['en', 'error', 'th'] | False |
Line.width | (self) |
Sets the width (in px) of line bounding the box(es).
The 'width' property is a number and may be specified as:
- An int or float in the interval [0, inf]
Returns
-------
int|float
|
Sets the width (in px) of line bounding the box(es).
The 'width' property is a number and may be specified as:
- An int or float in the interval [0, inf] | def width(self):
"""
Sets the width (in px) of line bounding the box(es).
The 'width' property is a number and may be specified as:
- An int or float in the interval [0, inf]
Returns
-------
int|float
"""
return self["width"] | [
"def",
"width",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"width\"",
"]"
] | [
74,
4
] | [
85,
28
] | python | en | ['en', 'error', 'th'] | False |
Line.__init__ | (self, arg=None, color=None, width=None, **kwargs) |
Construct a new Line object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.candlestick.increasing.Line`
color
Sets the color of line bounding the box(es).
width
Sets the width (in px) of line bounding the box(es).
Returns
-------
Line
|
Construct a new Line object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.candlestick.increasing.Line`
color
Sets the color of line bounding the box(es).
width
Sets the width (in px) of line bounding the box(es). | def __init__(self, arg=None, color=None, width=None, **kwargs):
"""
Construct a new Line object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.candlestick.increasing.Line`
color
Sets the color of line bounding the box(es).
width
Sets the width (in px) of line bounding the box(es).
Returns
-------
Line
"""
super(Line, self).__init__("line")
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.candlestick.increasing.Line
constructor must be a dict or
an instance of :class:`plotly.graph_objs.candlestick.increasing.Line`"""
)
# 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("color", None)
_v = color if color is not None else _v
if _v is not None:
self["color"] = _v
_v = arg.pop("width", None)
_v = width if width is not None else _v
if _v is not None:
self["width"] = _v
# Process unknown kwargs
# ----------------------
self._process_kwargs(**dict(arg, **kwargs))
# Reset skip_invalid
# ------------------
self._skip_invalid = False | [
"def",
"__init__",
"(",
"self",
",",
"arg",
"=",
"None",
",",
"color",
"=",
"None",
",",
"width",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"super",
"(",
"Line",
",",
"self",
")",
".",
"__init__",
"(",
"\"line\"",
")",
"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",
"(",
"\"\"\"\\\nThe first argument to the plotly.graph_objs.candlestick.increasing.Line \nconstructor must be a dict or \nan instance of :class:`plotly.graph_objs.candlestick.increasing.Line`\"\"\"",
")",
"# 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",
"(",
"\"color\"",
",",
"None",
")",
"_v",
"=",
"color",
"if",
"color",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"color\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"width\"",
",",
"None",
")",
"_v",
"=",
"width",
"if",
"width",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"width\"",
"]",
"=",
"_v",
"# Process unknown kwargs",
"# ----------------------",
"self",
".",
"_process_kwargs",
"(",
"*",
"*",
"dict",
"(",
"arg",
",",
"*",
"*",
"kwargs",
")",
")",
"# Reset skip_invalid",
"# ------------------",
"self",
".",
"_skip_invalid",
"=",
"False"
] | [
102,
4
] | [
165,
34
] | python | en | ['en', 'error', 'th'] | False |
get_pairs | (word) | Return set of symbol pairs in a word.
word is represented as tuple of symbols (symbols being variable-length strings)
| Return set of symbol pairs in a word. | def get_pairs(word):
"""Return set of symbol pairs in a word.
word is represented as tuple of symbols (symbols being variable-length strings)
"""
pairs = set()
prev_char = word[0]
for char in word[1:]:
pairs.add((prev_char, char))
prev_char = char
return pairs | [
"def",
"get_pairs",
"(",
"word",
")",
":",
"pairs",
"=",
"set",
"(",
")",
"prev_char",
"=",
"word",
"[",
"0",
"]",
"for",
"char",
"in",
"word",
"[",
"1",
":",
"]",
":",
"pairs",
".",
"add",
"(",
"(",
"prev_char",
",",
"char",
")",
")",
"prev_char",
"=",
"char",
"return",
"pairs"
] | [
120,
0
] | [
130,
16
] | python | en | ['en', 'en', 'en'] | True |
encode | (orig, bpe_codes, bpe_codes_reverse, vocab, separator, version, cache, glossaries=None) | Encode word based on list of BPE merge operations, which are applied consecutively
| Encode word based on list of BPE merge operations, which are applied consecutively
| def encode(orig, bpe_codes, bpe_codes_reverse, vocab, separator, version, cache, glossaries=None):
"""Encode word based on list of BPE merge operations, which are applied consecutively
"""
if orig in cache:
return cache[orig]
if orig in glossaries:
cache[orig] = (orig,)
return (orig,)
if version == (0, 1):
word = tuple(orig) + ('</w>',)
elif version == (0, 2): # more consistent handling of word-final segments
word = tuple(orig[:-1]) + ( orig[-1] + '</w>',)
else:
raise NotImplementedError
pairs = get_pairs(word)
if not pairs:
return orig
while True:
bigram = min(pairs, key = lambda pair: bpe_codes.get(pair, float('inf')))
if bigram not in bpe_codes:
break
first, second = bigram
new_word = []
i = 0
while i < len(word):
try:
j = word.index(first, i)
new_word.extend(word[i:j])
i = j
except:
new_word.extend(word[i:])
break
if word[i] == first and i < len(word)-1 and word[i+1] == second:
new_word.append(first+second)
i += 2
else:
new_word.append(word[i])
i += 1
new_word = tuple(new_word)
word = new_word
if len(word) == 1:
break
else:
pairs = get_pairs(word)
# don't print end-of-word symbols
if word[-1] == '</w>':
word = word[:-1]
elif word[-1].endswith('</w>'):
word = word[:-1] + (word[-1].replace('</w>',''),)
if vocab:
word = check_vocab_and_split(word, bpe_codes_reverse, vocab, separator)
cache[orig] = word
return word | [
"def",
"encode",
"(",
"orig",
",",
"bpe_codes",
",",
"bpe_codes_reverse",
",",
"vocab",
",",
"separator",
",",
"version",
",",
"cache",
",",
"glossaries",
"=",
"None",
")",
":",
"if",
"orig",
"in",
"cache",
":",
"return",
"cache",
"[",
"orig",
"]",
"if",
"orig",
"in",
"glossaries",
":",
"cache",
"[",
"orig",
"]",
"=",
"(",
"orig",
",",
")",
"return",
"(",
"orig",
",",
")",
"if",
"version",
"==",
"(",
"0",
",",
"1",
")",
":",
"word",
"=",
"tuple",
"(",
"orig",
")",
"+",
"(",
"'</w>'",
",",
")",
"elif",
"version",
"==",
"(",
"0",
",",
"2",
")",
":",
"# more consistent handling of word-final segments",
"word",
"=",
"tuple",
"(",
"orig",
"[",
":",
"-",
"1",
"]",
")",
"+",
"(",
"orig",
"[",
"-",
"1",
"]",
"+",
"'</w>'",
",",
")",
"else",
":",
"raise",
"NotImplementedError",
"pairs",
"=",
"get_pairs",
"(",
"word",
")",
"if",
"not",
"pairs",
":",
"return",
"orig",
"while",
"True",
":",
"bigram",
"=",
"min",
"(",
"pairs",
",",
"key",
"=",
"lambda",
"pair",
":",
"bpe_codes",
".",
"get",
"(",
"pair",
",",
"float",
"(",
"'inf'",
")",
")",
")",
"if",
"bigram",
"not",
"in",
"bpe_codes",
":",
"break",
"first",
",",
"second",
"=",
"bigram",
"new_word",
"=",
"[",
"]",
"i",
"=",
"0",
"while",
"i",
"<",
"len",
"(",
"word",
")",
":",
"try",
":",
"j",
"=",
"word",
".",
"index",
"(",
"first",
",",
"i",
")",
"new_word",
".",
"extend",
"(",
"word",
"[",
"i",
":",
"j",
"]",
")",
"i",
"=",
"j",
"except",
":",
"new_word",
".",
"extend",
"(",
"word",
"[",
"i",
":",
"]",
")",
"break",
"if",
"word",
"[",
"i",
"]",
"==",
"first",
"and",
"i",
"<",
"len",
"(",
"word",
")",
"-",
"1",
"and",
"word",
"[",
"i",
"+",
"1",
"]",
"==",
"second",
":",
"new_word",
".",
"append",
"(",
"first",
"+",
"second",
")",
"i",
"+=",
"2",
"else",
":",
"new_word",
".",
"append",
"(",
"word",
"[",
"i",
"]",
")",
"i",
"+=",
"1",
"new_word",
"=",
"tuple",
"(",
"new_word",
")",
"word",
"=",
"new_word",
"if",
"len",
"(",
"word",
")",
"==",
"1",
":",
"break",
"else",
":",
"pairs",
"=",
"get_pairs",
"(",
"word",
")",
"# don't print end-of-word symbols",
"if",
"word",
"[",
"-",
"1",
"]",
"==",
"'</w>'",
":",
"word",
"=",
"word",
"[",
":",
"-",
"1",
"]",
"elif",
"word",
"[",
"-",
"1",
"]",
".",
"endswith",
"(",
"'</w>'",
")",
":",
"word",
"=",
"word",
"[",
":",
"-",
"1",
"]",
"+",
"(",
"word",
"[",
"-",
"1",
"]",
".",
"replace",
"(",
"'</w>'",
",",
"''",
")",
",",
")",
"if",
"vocab",
":",
"word",
"=",
"check_vocab_and_split",
"(",
"word",
",",
"bpe_codes_reverse",
",",
"vocab",
",",
"separator",
")",
"cache",
"[",
"orig",
"]",
"=",
"word",
"return",
"word"
] | [
132,
0
] | [
194,
15
] | python | en | ['en', 'en', 'en'] | True |
recursive_split | (segment, bpe_codes, vocab, separator, final=False) | Recursively split segment into smaller units (by reversing BPE merges)
until all units are either in-vocabulary, or cannot be split futher. | Recursively split segment into smaller units (by reversing BPE merges)
until all units are either in-vocabulary, or cannot be split futher. | def recursive_split(segment, bpe_codes, vocab, separator, final=False):
"""Recursively split segment into smaller units (by reversing BPE merges)
until all units are either in-vocabulary, or cannot be split futher."""
try:
if final:
left, right = bpe_codes[segment + '</w>']
right = right[:-4]
else:
left, right = bpe_codes[segment]
except:
#sys.stderr.write('cannot split {0} further.\n'.format(segment))
yield segment
return
if left + separator in vocab:
yield left
else:
for item in recursive_split(left, bpe_codes, vocab, separator, False):
yield item
if (final and right in vocab) or (not final and right + separator in vocab):
yield right
else:
for item in recursive_split(right, bpe_codes, vocab, separator, final):
yield item | [
"def",
"recursive_split",
"(",
"segment",
",",
"bpe_codes",
",",
"vocab",
",",
"separator",
",",
"final",
"=",
"False",
")",
":",
"try",
":",
"if",
"final",
":",
"left",
",",
"right",
"=",
"bpe_codes",
"[",
"segment",
"+",
"'</w>'",
"]",
"right",
"=",
"right",
"[",
":",
"-",
"4",
"]",
"else",
":",
"left",
",",
"right",
"=",
"bpe_codes",
"[",
"segment",
"]",
"except",
":",
"#sys.stderr.write('cannot split {0} further.\\n'.format(segment))",
"yield",
"segment",
"return",
"if",
"left",
"+",
"separator",
"in",
"vocab",
":",
"yield",
"left",
"else",
":",
"for",
"item",
"in",
"recursive_split",
"(",
"left",
",",
"bpe_codes",
",",
"vocab",
",",
"separator",
",",
"False",
")",
":",
"yield",
"item",
"if",
"(",
"final",
"and",
"right",
"in",
"vocab",
")",
"or",
"(",
"not",
"final",
"and",
"right",
"+",
"separator",
"in",
"vocab",
")",
":",
"yield",
"right",
"else",
":",
"for",
"item",
"in",
"recursive_split",
"(",
"right",
",",
"bpe_codes",
",",
"vocab",
",",
"separator",
",",
"final",
")",
":",
"yield",
"item"
] | [
196,
0
] | [
221,
22
] | python | en | ['en', 'no', 'en'] | True |
check_vocab_and_split | (orig, bpe_codes, vocab, separator) | Check for each segment in word if it is in-vocabulary,
and segment OOV segments into smaller units by reversing the BPE merge operations | Check for each segment in word if it is in-vocabulary,
and segment OOV segments into smaller units by reversing the BPE merge operations | def check_vocab_and_split(orig, bpe_codes, vocab, separator):
"""Check for each segment in word if it is in-vocabulary,
and segment OOV segments into smaller units by reversing the BPE merge operations"""
out = []
for segment in orig[:-1]:
if segment + separator in vocab:
out.append(segment)
else:
#sys.stderr.write('OOV: {0}\n'.format(segment))
for item in recursive_split(segment, bpe_codes, vocab, separator, False):
out.append(item)
segment = orig[-1]
if segment in vocab:
out.append(segment)
else:
#sys.stderr.write('OOV: {0}\n'.format(segment))
for item in recursive_split(segment, bpe_codes, vocab, separator, True):
out.append(item)
return out | [
"def",
"check_vocab_and_split",
"(",
"orig",
",",
"bpe_codes",
",",
"vocab",
",",
"separator",
")",
":",
"out",
"=",
"[",
"]",
"for",
"segment",
"in",
"orig",
"[",
":",
"-",
"1",
"]",
":",
"if",
"segment",
"+",
"separator",
"in",
"vocab",
":",
"out",
".",
"append",
"(",
"segment",
")",
"else",
":",
"#sys.stderr.write('OOV: {0}\\n'.format(segment))",
"for",
"item",
"in",
"recursive_split",
"(",
"segment",
",",
"bpe_codes",
",",
"vocab",
",",
"separator",
",",
"False",
")",
":",
"out",
".",
"append",
"(",
"item",
")",
"segment",
"=",
"orig",
"[",
"-",
"1",
"]",
"if",
"segment",
"in",
"vocab",
":",
"out",
".",
"append",
"(",
"segment",
")",
"else",
":",
"#sys.stderr.write('OOV: {0}\\n'.format(segment))",
"for",
"item",
"in",
"recursive_split",
"(",
"segment",
",",
"bpe_codes",
",",
"vocab",
",",
"separator",
",",
"True",
")",
":",
"out",
".",
"append",
"(",
"item",
")",
"return",
"out"
] | [
223,
0
] | [
245,
14
] | python | en | ['en', 'en', 'en'] | True |
read_vocabulary | (vocab_file, threshold) | read vocabulary file produced by get_vocab.py, and filter according to frequency threshold.
| read vocabulary file produced by get_vocab.py, and filter according to frequency threshold.
| def read_vocabulary(vocab_file, threshold):
"""read vocabulary file produced by get_vocab.py, and filter according to frequency threshold.
"""
vocabulary = set()
for line in vocab_file:
word, freq = line.split()
freq = int(freq)
if threshold == None or freq >= threshold:
vocabulary.add(word)
return vocabulary | [
"def",
"read_vocabulary",
"(",
"vocab_file",
",",
"threshold",
")",
":",
"vocabulary",
"=",
"set",
"(",
")",
"for",
"line",
"in",
"vocab_file",
":",
"word",
",",
"freq",
"=",
"line",
".",
"split",
"(",
")",
"freq",
"=",
"int",
"(",
"freq",
")",
"if",
"threshold",
"==",
"None",
"or",
"freq",
">=",
"threshold",
":",
"vocabulary",
".",
"add",
"(",
"word",
")",
"return",
"vocabulary"
] | [
248,
0
] | [
260,
21
] | python | en | ['en', 'en', 'en'] | True |
isolate_glossary | (word, glossary) |
Isolate a glossary present inside a word.
Returns a list of subwords. In which all 'glossary' glossaries are isolated
For example, if 'USA' is the glossary and '1934USABUSA' the word, the return value is:
['1934', 'USA', 'B', 'USA']
|
Isolate a glossary present inside a word. | def isolate_glossary(word, glossary):
"""
Isolate a glossary present inside a word.
Returns a list of subwords. In which all 'glossary' glossaries are isolated
For example, if 'USA' is the glossary and '1934USABUSA' the word, the return value is:
['1934', 'USA', 'B', 'USA']
"""
if word == glossary or glossary not in word:
return [word]
else:
splits = word.split(glossary)
segments = [segment.strip() for split in splits[:-1] for segment in [split, glossary] if segment != '']
return segments + [splits[-1].strip()] if splits[-1] != '' else segments | [
"def",
"isolate_glossary",
"(",
"word",
",",
"glossary",
")",
":",
"if",
"word",
"==",
"glossary",
"or",
"glossary",
"not",
"in",
"word",
":",
"return",
"[",
"word",
"]",
"else",
":",
"splits",
"=",
"word",
".",
"split",
"(",
"glossary",
")",
"segments",
"=",
"[",
"segment",
".",
"strip",
"(",
")",
"for",
"split",
"in",
"splits",
"[",
":",
"-",
"1",
"]",
"for",
"segment",
"in",
"[",
"split",
",",
"glossary",
"]",
"if",
"segment",
"!=",
"''",
"]",
"return",
"segments",
"+",
"[",
"splits",
"[",
"-",
"1",
"]",
".",
"strip",
"(",
")",
"]",
"if",
"splits",
"[",
"-",
"1",
"]",
"!=",
"''",
"else",
"segments"
] | [
262,
0
] | [
276,
80
] | python | en | ['en', 'error', 'th'] | False |
BPE.segment | (self, sentence) | segment single sentence (whitespace-tokenized string) with BPE encoding | segment single sentence (whitespace-tokenized string) with BPE encoding | def segment(self, sentence):
"""segment single sentence (whitespace-tokenized string) with BPE encoding"""
output = []
for word in sentence.split():
new_word = [out for segment in self._isolate_glossaries(word)
for out in encode(segment,
self.bpe_codes,
self.bpe_codes_reverse,
self.vocab,
self.separator,
self.version,
self.cache,
self.glossaries)]
for item in new_word[:-1]:
output.append(item + self.separator)
output.append(new_word[-1])
return ' '.join(output) | [
"def",
"segment",
"(",
"self",
",",
"sentence",
")",
":",
"output",
"=",
"[",
"]",
"for",
"word",
"in",
"sentence",
".",
"split",
"(",
")",
":",
"new_word",
"=",
"[",
"out",
"for",
"segment",
"in",
"self",
".",
"_isolate_glossaries",
"(",
"word",
")",
"for",
"out",
"in",
"encode",
"(",
"segment",
",",
"self",
".",
"bpe_codes",
",",
"self",
".",
"bpe_codes_reverse",
",",
"self",
".",
"vocab",
",",
"self",
".",
"separator",
",",
"self",
".",
"version",
",",
"self",
".",
"cache",
",",
"self",
".",
"glossaries",
")",
"]",
"for",
"item",
"in",
"new_word",
"[",
":",
"-",
"1",
"]",
":",
"output",
".",
"append",
"(",
"item",
"+",
"self",
".",
"separator",
")",
"output",
".",
"append",
"(",
"new_word",
"[",
"-",
"1",
"]",
")",
"return",
"' '",
".",
"join",
"(",
"output",
")"
] | [
52,
4
] | [
70,
31
] | python | en | ['en', 'el-Latn', 'en'] | True |
Unselected.marker | (self) |
The 'marker' property is an instance of Marker
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolargl.unselected.Marker`
- A dict of string/value properties that will be passed
to the Marker constructor
Supported dict properties:
color
Sets the marker color of unselected points,
applied only when a selection exists.
opacity
Sets the marker opacity of unselected points,
applied only when a selection exists.
size
Sets the marker size of unselected points,
applied only when a selection exists.
Returns
-------
plotly.graph_objs.scatterpolargl.unselected.Marker
|
The 'marker' property is an instance of Marker
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolargl.unselected.Marker`
- A dict of string/value properties that will be passed
to the Marker constructor
Supported dict properties:
color
Sets the marker color of unselected points,
applied only when a selection exists.
opacity
Sets the marker opacity of unselected points,
applied only when a selection exists.
size
Sets the marker size of unselected points,
applied only when a selection exists. | def marker(self):
"""
The 'marker' property is an instance of Marker
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolargl.unselected.Marker`
- A dict of string/value properties that will be passed
to the Marker constructor
Supported dict properties:
color
Sets the marker color of unselected points,
applied only when a selection exists.
opacity
Sets the marker opacity of unselected points,
applied only when a selection exists.
size
Sets the marker size of unselected points,
applied only when a selection exists.
Returns
-------
plotly.graph_objs.scatterpolargl.unselected.Marker
"""
return self["marker"] | [
"def",
"marker",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"marker\"",
"]"
] | [
15,
4
] | [
39,
29
] | python | en | ['en', 'error', 'th'] | False |
Unselected.textfont | (self) |
The 'textfont' property is an instance of Textfont
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolargl.unselected.Textfont`
- A dict of string/value properties that will be passed
to the Textfont constructor
Supported dict properties:
color
Sets the text font color of unselected points,
applied only when a selection exists.
Returns
-------
plotly.graph_objs.scatterpolargl.unselected.Textfont
|
The 'textfont' property is an instance of Textfont
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolargl.unselected.Textfont`
- A dict of string/value properties that will be passed
to the Textfont constructor
Supported dict properties:
color
Sets the text font color of unselected points,
applied only when a selection exists. | def textfont(self):
"""
The 'textfont' property is an instance of Textfont
that may be specified as:
- An instance of :class:`plotly.graph_objs.scatterpolargl.unselected.Textfont`
- A dict of string/value properties that will be passed
to the Textfont constructor
Supported dict properties:
color
Sets the text font color of unselected points,
applied only when a selection exists.
Returns
-------
plotly.graph_objs.scatterpolargl.unselected.Textfont
"""
return self["textfont"] | [
"def",
"textfont",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"textfont\"",
"]"
] | [
48,
4
] | [
66,
31
] | python | en | ['en', 'error', 'th'] | False |
Unselected.__init__ | (self, arg=None, marker=None, textfont=None, **kwargs) |
Construct a new Unselected object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.scatterpolargl.Unselected`
marker
:class:`plotly.graph_objects.scatterpolargl.unselected.
Marker` instance or dict with compatible properties
textfont
:class:`plotly.graph_objects.scatterpolargl.unselected.
Textfont` instance or dict with compatible properties
Returns
-------
Unselected
|
Construct a new Unselected object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.scatterpolargl.Unselected`
marker
:class:`plotly.graph_objects.scatterpolargl.unselected.
Marker` instance or dict with compatible properties
textfont
:class:`plotly.graph_objects.scatterpolargl.unselected.
Textfont` instance or dict with compatible properties | def __init__(self, arg=None, marker=None, textfont=None, **kwargs):
"""
Construct a new Unselected object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.scatterpolargl.Unselected`
marker
:class:`plotly.graph_objects.scatterpolargl.unselected.
Marker` instance or dict with compatible properties
textfont
:class:`plotly.graph_objects.scatterpolargl.unselected.
Textfont` instance or dict with compatible properties
Returns
-------
Unselected
"""
super(Unselected, self).__init__("unselected")
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.scatterpolargl.Unselected
constructor must be a dict or
an instance of :class:`plotly.graph_objs.scatterpolargl.Unselected`"""
)
# 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("marker", None)
_v = marker if marker is not None else _v
if _v is not None:
self["marker"] = _v
_v = arg.pop("textfont", None)
_v = textfont if textfont is not None else _v
if _v is not None:
self["textfont"] = _v
# Process unknown kwargs
# ----------------------
self._process_kwargs(**dict(arg, **kwargs))
# Reset skip_invalid
# ------------------
self._skip_invalid = False | [
"def",
"__init__",
"(",
"self",
",",
"arg",
"=",
"None",
",",
"marker",
"=",
"None",
",",
"textfont",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"super",
"(",
"Unselected",
",",
"self",
")",
".",
"__init__",
"(",
"\"unselected\"",
")",
"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",
"(",
"\"\"\"\\\nThe first argument to the plotly.graph_objs.scatterpolargl.Unselected \nconstructor must be a dict or \nan instance of :class:`plotly.graph_objs.scatterpolargl.Unselected`\"\"\"",
")",
"# 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",
"(",
"\"marker\"",
",",
"None",
")",
"_v",
"=",
"marker",
"if",
"marker",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"marker\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"textfont\"",
",",
"None",
")",
"_v",
"=",
"textfont",
"if",
"textfont",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"textfont\"",
"]",
"=",
"_v",
"# Process unknown kwargs",
"# ----------------------",
"self",
".",
"_process_kwargs",
"(",
"*",
"*",
"dict",
"(",
"arg",
",",
"*",
"*",
"kwargs",
")",
")",
"# Reset skip_invalid",
"# ------------------",
"self",
".",
"_skip_invalid",
"=",
"False"
] | [
85,
4
] | [
150,
34
] | python | en | ['en', 'error', 'th'] | False |
BothEncoderRankerAgent.eval_step | (self, batch) |
We pass the batch first in the biencoder, then filter with crossencoder.
|
We pass the batch first in the biencoder, then filter with crossencoder.
| def eval_step(self, batch):
"""
We pass the batch first in the biencoder, then filter with crossencoder.
"""
output_biencoder = self.biencoder.eval_step(batch)
if output_biencoder is None:
return None
new_candidate_vecs = [
self.biencoder.vectorize_fixed_candidates(cands[0 : self.top_n_bi])
for cands in output_biencoder.text_candidates
]
new_candidates = [
[c for c in cands[0 : self.top_n_bi]]
for cands in output_biencoder.text_candidates
if cands is not None
]
copy_batch = Batch(
text_vec=batch.text_vec,
candidate_vecs=new_candidate_vecs,
candidates=new_candidates,
)
return self.crossencoder.eval_step(copy_batch) | [
"def",
"eval_step",
"(",
"self",
",",
"batch",
")",
":",
"output_biencoder",
"=",
"self",
".",
"biencoder",
".",
"eval_step",
"(",
"batch",
")",
"if",
"output_biencoder",
"is",
"None",
":",
"return",
"None",
"new_candidate_vecs",
"=",
"[",
"self",
".",
"biencoder",
".",
"vectorize_fixed_candidates",
"(",
"cands",
"[",
"0",
":",
"self",
".",
"top_n_bi",
"]",
")",
"for",
"cands",
"in",
"output_biencoder",
".",
"text_candidates",
"]",
"new_candidates",
"=",
"[",
"[",
"c",
"for",
"c",
"in",
"cands",
"[",
"0",
":",
"self",
".",
"top_n_bi",
"]",
"]",
"for",
"cands",
"in",
"output_biencoder",
".",
"text_candidates",
"if",
"cands",
"is",
"not",
"None",
"]",
"copy_batch",
"=",
"Batch",
"(",
"text_vec",
"=",
"batch",
".",
"text_vec",
",",
"candidate_vecs",
"=",
"new_candidate_vecs",
",",
"candidates",
"=",
"new_candidates",
",",
")",
"return",
"self",
".",
"crossencoder",
".",
"eval_step",
"(",
"copy_batch",
")"
] | [
107,
4
] | [
128,
54
] | python | en | ['en', 'error', 'th'] | False |
DepthInstance3DBoxes.gravity_center | (self) | torch.Tensor: A tensor with center of each box. | torch.Tensor: A tensor with center of each box. | def gravity_center(self):
"""torch.Tensor: A tensor with center of each box."""
bottom_center = self.bottom_center
gravity_center = torch.zeros_like(bottom_center)
gravity_center[:, :2] = bottom_center[:, :2]
gravity_center[:, 2] = bottom_center[:, 2] + self.tensor[:, 5] * 0.5
return gravity_center | [
"def",
"gravity_center",
"(",
"self",
")",
":",
"bottom_center",
"=",
"self",
".",
"bottom_center",
"gravity_center",
"=",
"torch",
".",
"zeros_like",
"(",
"bottom_center",
")",
"gravity_center",
"[",
":",
",",
":",
"2",
"]",
"=",
"bottom_center",
"[",
":",
",",
":",
"2",
"]",
"gravity_center",
"[",
":",
",",
"2",
"]",
"=",
"bottom_center",
"[",
":",
",",
"2",
"]",
"+",
"self",
".",
"tensor",
"[",
":",
",",
"5",
"]",
"*",
"0.5",
"return",
"gravity_center"
] | [
36,
4
] | [
42,
29
] | python | en | ['en', 'en', 'en'] | True |
DepthInstance3DBoxes.corners | (self) | torch.Tensor: Coordinates of corners of all the boxes
in shape (N, 8, 3).
Convert the boxes to corners in clockwise order, in form of
``(x0y0z0, x0y0z1, x0y1z1, x0y1z0, x1y0z0, x1y0z1, x1y1z1, x1y1z0)``
.. code-block:: none
up z
front y ^
/ |
/ |
(x0, y1, z1) + ----------- + (x1, y1, z1)
/| / |
/ | / |
(x0, y0, z1) + ----------- + + (x1, y1, z0)
| / . | /
| / oriign | /
(x0, y0, z0) + ----------- + --------> right x
(x1, y0, z0)
| torch.Tensor: Coordinates of corners of all the boxes
in shape (N, 8, 3). | def corners(self):
"""torch.Tensor: Coordinates of corners of all the boxes
in shape (N, 8, 3).
Convert the boxes to corners in clockwise order, in form of
``(x0y0z0, x0y0z1, x0y1z1, x0y1z0, x1y0z0, x1y0z1, x1y1z1, x1y1z0)``
.. code-block:: none
up z
front y ^
/ |
/ |
(x0, y1, z1) + ----------- + (x1, y1, z1)
/| / |
/ | / |
(x0, y0, z1) + ----------- + + (x1, y1, z0)
| / . | /
| / oriign | /
(x0, y0, z0) + ----------- + --------> right x
(x1, y0, z0)
"""
# TODO: rotation_3d_in_axis function do not support
# empty tensor currently.
assert len(self.tensor) != 0
dims = self.dims
corners_norm = torch.from_numpy(
np.stack(np.unravel_index(np.arange(8), [2] * 3), axis=1)).to(
device=dims.device, dtype=dims.dtype)
corners_norm = corners_norm[[0, 1, 3, 2, 4, 5, 7, 6]]
# use relative origin (0.5, 0.5, 0)
corners_norm = corners_norm - dims.new_tensor([0.5, 0.5, 0])
corners = dims.view([-1, 1, 3]) * corners_norm.reshape([1, 8, 3])
# rotate around z axis
corners = rotation_3d_in_axis(corners, self.tensor[:, 6], axis=2)
corners += self.tensor[:, :3].view(-1, 1, 3)
return corners | [
"def",
"corners",
"(",
"self",
")",
":",
"# TODO: rotation_3d_in_axis function do not support",
"# empty tensor currently.",
"assert",
"len",
"(",
"self",
".",
"tensor",
")",
"!=",
"0",
"dims",
"=",
"self",
".",
"dims",
"corners_norm",
"=",
"torch",
".",
"from_numpy",
"(",
"np",
".",
"stack",
"(",
"np",
".",
"unravel_index",
"(",
"np",
".",
"arange",
"(",
"8",
")",
",",
"[",
"2",
"]",
"*",
"3",
")",
",",
"axis",
"=",
"1",
")",
")",
".",
"to",
"(",
"device",
"=",
"dims",
".",
"device",
",",
"dtype",
"=",
"dims",
".",
"dtype",
")",
"corners_norm",
"=",
"corners_norm",
"[",
"[",
"0",
",",
"1",
",",
"3",
",",
"2",
",",
"4",
",",
"5",
",",
"7",
",",
"6",
"]",
"]",
"# use relative origin (0.5, 0.5, 0)",
"corners_norm",
"=",
"corners_norm",
"-",
"dims",
".",
"new_tensor",
"(",
"[",
"0.5",
",",
"0.5",
",",
"0",
"]",
")",
"corners",
"=",
"dims",
".",
"view",
"(",
"[",
"-",
"1",
",",
"1",
",",
"3",
"]",
")",
"*",
"corners_norm",
".",
"reshape",
"(",
"[",
"1",
",",
"8",
",",
"3",
"]",
")",
"# rotate around z axis",
"corners",
"=",
"rotation_3d_in_axis",
"(",
"corners",
",",
"self",
".",
"tensor",
"[",
":",
",",
"6",
"]",
",",
"axis",
"=",
"2",
")",
"corners",
"+=",
"self",
".",
"tensor",
"[",
":",
",",
":",
"3",
"]",
".",
"view",
"(",
"-",
"1",
",",
"1",
",",
"3",
")",
"return",
"corners"
] | [
45,
4
] | [
83,
22
] | python | en | ['en', 'en', 'en'] | True |
DepthInstance3DBoxes.bev | (self) | torch.Tensor: A n x 5 tensor of 2D BEV box of each box
in XYWHR format. | torch.Tensor: A n x 5 tensor of 2D BEV box of each box
in XYWHR format. | def bev(self):
"""torch.Tensor: A n x 5 tensor of 2D BEV box of each box
in XYWHR format."""
return self.tensor[:, [0, 1, 3, 4, 6]] | [
"def",
"bev",
"(",
"self",
")",
":",
"return",
"self",
".",
"tensor",
"[",
":",
",",
"[",
"0",
",",
"1",
",",
"3",
",",
"4",
",",
"6",
"]",
"]"
] | [
86,
4
] | [
89,
46
] | python | en | ['en', 'vi', 'en'] | True |
DepthInstance3DBoxes.nearest_bev | (self) | torch.Tensor: A tensor of 2D BEV box of each box
without rotation. | torch.Tensor: A tensor of 2D BEV box of each box
without rotation. | def nearest_bev(self):
"""torch.Tensor: A tensor of 2D BEV box of each box
without rotation."""
# Obtain BEV boxes with rotation in XYWHR format
bev_rotated_boxes = self.bev
# convert the rotation to a valid range
rotations = bev_rotated_boxes[:, -1]
normed_rotations = torch.abs(limit_period(rotations, 0.5, np.pi))
# find the center of boxes
conditions = (normed_rotations > np.pi / 4)[..., None]
bboxes_xywh = torch.where(conditions, bev_rotated_boxes[:,
[0, 1, 3, 2]],
bev_rotated_boxes[:, :4])
centers = bboxes_xywh[:, :2]
dims = bboxes_xywh[:, 2:]
bev_boxes = torch.cat([centers - dims / 2, centers + dims / 2], dim=-1)
return bev_boxes | [
"def",
"nearest_bev",
"(",
"self",
")",
":",
"# Obtain BEV boxes with rotation in XYWHR format",
"bev_rotated_boxes",
"=",
"self",
".",
"bev",
"# convert the rotation to a valid range",
"rotations",
"=",
"bev_rotated_boxes",
"[",
":",
",",
"-",
"1",
"]",
"normed_rotations",
"=",
"torch",
".",
"abs",
"(",
"limit_period",
"(",
"rotations",
",",
"0.5",
",",
"np",
".",
"pi",
")",
")",
"# find the center of boxes",
"conditions",
"=",
"(",
"normed_rotations",
">",
"np",
".",
"pi",
"/",
"4",
")",
"[",
"...",
",",
"None",
"]",
"bboxes_xywh",
"=",
"torch",
".",
"where",
"(",
"conditions",
",",
"bev_rotated_boxes",
"[",
":",
",",
"[",
"0",
",",
"1",
",",
"3",
",",
"2",
"]",
"]",
",",
"bev_rotated_boxes",
"[",
":",
",",
":",
"4",
"]",
")",
"centers",
"=",
"bboxes_xywh",
"[",
":",
",",
":",
"2",
"]",
"dims",
"=",
"bboxes_xywh",
"[",
":",
",",
"2",
":",
"]",
"bev_boxes",
"=",
"torch",
".",
"cat",
"(",
"[",
"centers",
"-",
"dims",
"/",
"2",
",",
"centers",
"+",
"dims",
"/",
"2",
"]",
",",
"dim",
"=",
"-",
"1",
")",
"return",
"bev_boxes"
] | [
92,
4
] | [
110,
24
] | python | en | ['en', 'vi', 'en'] | True |
DepthInstance3DBoxes.rotate | (self, angle, points=None) | Rotate boxes with points (optional) with the given angle.
Args:
angle (float, torch.Tensor): Rotation angle.
points (torch.Tensor, numpy.ndarray, :obj:`BasePoints`, optional):
Points to rotate. Defaults to None.
Returns:
tuple or None: When ``points`` is None, the function returns \
None, otherwise it returns the rotated points and the \
rotation matrix ``rot_mat_T``.
| Rotate boxes with points (optional) with the given angle. | def rotate(self, angle, points=None):
"""Rotate boxes with points (optional) with the given angle.
Args:
angle (float, torch.Tensor): Rotation angle.
points (torch.Tensor, numpy.ndarray, :obj:`BasePoints`, optional):
Points to rotate. Defaults to None.
Returns:
tuple or None: When ``points`` is None, the function returns \
None, otherwise it returns the rotated points and the \
rotation matrix ``rot_mat_T``.
"""
if not isinstance(angle, torch.Tensor):
angle = self.tensor.new_tensor(angle)
rot_sin = torch.sin(angle)
rot_cos = torch.cos(angle)
rot_mat_T = self.tensor.new_tensor([[rot_cos, -rot_sin, 0],
[rot_sin, rot_cos, 0], [0, 0,
1]]).T
self.tensor[:, 0:3] = self.tensor[:, 0:3] @ rot_mat_T
if self.with_yaw:
self.tensor[:, 6] -= angle
else:
corners_rot = self.corners @ rot_mat_T
new_x_size = corners_rot[..., 0].max(
dim=1, keepdim=True)[0] - corners_rot[..., 0].min(
dim=1, keepdim=True)[0]
new_y_size = corners_rot[..., 1].max(
dim=1, keepdim=True)[0] - corners_rot[..., 1].min(
dim=1, keepdim=True)[0]
self.tensor[:, 3:5] = torch.cat((new_x_size, new_y_size), dim=-1)
if points is not None:
if isinstance(points, torch.Tensor):
points[:, :3] = points[:, :3] @ rot_mat_T
elif isinstance(points, np.ndarray):
rot_mat_T = rot_mat_T.numpy()
points[:, :3] = np.dot(points[:, :3], rot_mat_T)
elif isinstance(points, BasePoints):
# anti-clockwise
points.rotate(angle)
else:
raise ValueError
return points, rot_mat_T | [
"def",
"rotate",
"(",
"self",
",",
"angle",
",",
"points",
"=",
"None",
")",
":",
"if",
"not",
"isinstance",
"(",
"angle",
",",
"torch",
".",
"Tensor",
")",
":",
"angle",
"=",
"self",
".",
"tensor",
".",
"new_tensor",
"(",
"angle",
")",
"rot_sin",
"=",
"torch",
".",
"sin",
"(",
"angle",
")",
"rot_cos",
"=",
"torch",
".",
"cos",
"(",
"angle",
")",
"rot_mat_T",
"=",
"self",
".",
"tensor",
".",
"new_tensor",
"(",
"[",
"[",
"rot_cos",
",",
"-",
"rot_sin",
",",
"0",
"]",
",",
"[",
"rot_sin",
",",
"rot_cos",
",",
"0",
"]",
",",
"[",
"0",
",",
"0",
",",
"1",
"]",
"]",
")",
".",
"T",
"self",
".",
"tensor",
"[",
":",
",",
"0",
":",
"3",
"]",
"=",
"self",
".",
"tensor",
"[",
":",
",",
"0",
":",
"3",
"]",
"@",
"rot_mat_T",
"if",
"self",
".",
"with_yaw",
":",
"self",
".",
"tensor",
"[",
":",
",",
"6",
"]",
"-=",
"angle",
"else",
":",
"corners_rot",
"=",
"self",
".",
"corners",
"@",
"rot_mat_T",
"new_x_size",
"=",
"corners_rot",
"[",
"...",
",",
"0",
"]",
".",
"max",
"(",
"dim",
"=",
"1",
",",
"keepdim",
"=",
"True",
")",
"[",
"0",
"]",
"-",
"corners_rot",
"[",
"...",
",",
"0",
"]",
".",
"min",
"(",
"dim",
"=",
"1",
",",
"keepdim",
"=",
"True",
")",
"[",
"0",
"]",
"new_y_size",
"=",
"corners_rot",
"[",
"...",
",",
"1",
"]",
".",
"max",
"(",
"dim",
"=",
"1",
",",
"keepdim",
"=",
"True",
")",
"[",
"0",
"]",
"-",
"corners_rot",
"[",
"...",
",",
"1",
"]",
".",
"min",
"(",
"dim",
"=",
"1",
",",
"keepdim",
"=",
"True",
")",
"[",
"0",
"]",
"self",
".",
"tensor",
"[",
":",
",",
"3",
":",
"5",
"]",
"=",
"torch",
".",
"cat",
"(",
"(",
"new_x_size",
",",
"new_y_size",
")",
",",
"dim",
"=",
"-",
"1",
")",
"if",
"points",
"is",
"not",
"None",
":",
"if",
"isinstance",
"(",
"points",
",",
"torch",
".",
"Tensor",
")",
":",
"points",
"[",
":",
",",
":",
"3",
"]",
"=",
"points",
"[",
":",
",",
":",
"3",
"]",
"@",
"rot_mat_T",
"elif",
"isinstance",
"(",
"points",
",",
"np",
".",
"ndarray",
")",
":",
"rot_mat_T",
"=",
"rot_mat_T",
".",
"numpy",
"(",
")",
"points",
"[",
":",
",",
":",
"3",
"]",
"=",
"np",
".",
"dot",
"(",
"points",
"[",
":",
",",
":",
"3",
"]",
",",
"rot_mat_T",
")",
"elif",
"isinstance",
"(",
"points",
",",
"BasePoints",
")",
":",
"# anti-clockwise",
"points",
".",
"rotate",
"(",
"angle",
")",
"else",
":",
"raise",
"ValueError",
"return",
"points",
",",
"rot_mat_T"
] | [
112,
4
] | [
156,
36
] | python | en | ['en', 'en', 'en'] | True |
DepthInstance3DBoxes.flip | (self, bev_direction='horizontal', points=None) | Flip the boxes in BEV along given BEV direction.
In Depth coordinates, it flips x (horizontal) or y (vertical) axis.
Args:
bev_direction (str): Flip direction (horizontal or vertical).
points (torch.Tensor, numpy.ndarray, :obj:`BasePoints`, None):
Points to flip. Defaults to None.
Returns:
torch.Tensor, numpy.ndarray or None: Flipped points.
| Flip the boxes in BEV along given BEV direction. | def flip(self, bev_direction='horizontal', points=None):
"""Flip the boxes in BEV along given BEV direction.
In Depth coordinates, it flips x (horizontal) or y (vertical) axis.
Args:
bev_direction (str): Flip direction (horizontal or vertical).
points (torch.Tensor, numpy.ndarray, :obj:`BasePoints`, None):
Points to flip. Defaults to None.
Returns:
torch.Tensor, numpy.ndarray or None: Flipped points.
"""
assert bev_direction in ('horizontal', 'vertical')
if bev_direction == 'horizontal':
self.tensor[:, 0::7] = -self.tensor[:, 0::7]
if self.with_yaw:
self.tensor[:, 6] = -self.tensor[:, 6] + np.pi
elif bev_direction == 'vertical':
self.tensor[:, 1::7] = -self.tensor[:, 1::7]
if self.with_yaw:
self.tensor[:, 6] = -self.tensor[:, 6]
if points is not None:
assert isinstance(points, (torch.Tensor, np.ndarray, BasePoints))
if isinstance(points, (torch.Tensor, np.ndarray)):
if bev_direction == 'horizontal':
points[:, 0] = -points[:, 0]
elif bev_direction == 'vertical':
points[:, 1] = -points[:, 1]
elif isinstance(points, BasePoints):
points.flip(bev_direction)
return points | [
"def",
"flip",
"(",
"self",
",",
"bev_direction",
"=",
"'horizontal'",
",",
"points",
"=",
"None",
")",
":",
"assert",
"bev_direction",
"in",
"(",
"'horizontal'",
",",
"'vertical'",
")",
"if",
"bev_direction",
"==",
"'horizontal'",
":",
"self",
".",
"tensor",
"[",
":",
",",
"0",
":",
":",
"7",
"]",
"=",
"-",
"self",
".",
"tensor",
"[",
":",
",",
"0",
":",
":",
"7",
"]",
"if",
"self",
".",
"with_yaw",
":",
"self",
".",
"tensor",
"[",
":",
",",
"6",
"]",
"=",
"-",
"self",
".",
"tensor",
"[",
":",
",",
"6",
"]",
"+",
"np",
".",
"pi",
"elif",
"bev_direction",
"==",
"'vertical'",
":",
"self",
".",
"tensor",
"[",
":",
",",
"1",
":",
":",
"7",
"]",
"=",
"-",
"self",
".",
"tensor",
"[",
":",
",",
"1",
":",
":",
"7",
"]",
"if",
"self",
".",
"with_yaw",
":",
"self",
".",
"tensor",
"[",
":",
",",
"6",
"]",
"=",
"-",
"self",
".",
"tensor",
"[",
":",
",",
"6",
"]",
"if",
"points",
"is",
"not",
"None",
":",
"assert",
"isinstance",
"(",
"points",
",",
"(",
"torch",
".",
"Tensor",
",",
"np",
".",
"ndarray",
",",
"BasePoints",
")",
")",
"if",
"isinstance",
"(",
"points",
",",
"(",
"torch",
".",
"Tensor",
",",
"np",
".",
"ndarray",
")",
")",
":",
"if",
"bev_direction",
"==",
"'horizontal'",
":",
"points",
"[",
":",
",",
"0",
"]",
"=",
"-",
"points",
"[",
":",
",",
"0",
"]",
"elif",
"bev_direction",
"==",
"'vertical'",
":",
"points",
"[",
":",
",",
"1",
"]",
"=",
"-",
"points",
"[",
":",
",",
"1",
"]",
"elif",
"isinstance",
"(",
"points",
",",
"BasePoints",
")",
":",
"points",
".",
"flip",
"(",
"bev_direction",
")",
"return",
"points"
] | [
158,
4
] | [
190,
25
] | python | en | ['en', 'da', 'en'] | True |
DepthInstance3DBoxes.in_range_bev | (self, box_range) | Check whether the boxes are in the given range.
Args:
box_range (list | torch.Tensor): The range of box
(x_min, y_min, x_max, y_max).
Note:
In the original implementation of SECOND, checking whether
a box in the range checks whether the points are in a convex
polygon, we try to reduce the burdun for simpler cases.
Returns:
torch.Tensor: Indicating whether each box is inside \
the reference range.
| Check whether the boxes are in the given range. | def in_range_bev(self, box_range):
"""Check whether the boxes are in the given range.
Args:
box_range (list | torch.Tensor): The range of box
(x_min, y_min, x_max, y_max).
Note:
In the original implementation of SECOND, checking whether
a box in the range checks whether the points are in a convex
polygon, we try to reduce the burdun for simpler cases.
Returns:
torch.Tensor: Indicating whether each box is inside \
the reference range.
"""
in_range_flags = ((self.tensor[:, 0] > box_range[0])
& (self.tensor[:, 1] > box_range[1])
& (self.tensor[:, 0] < box_range[2])
& (self.tensor[:, 1] < box_range[3]))
return in_range_flags | [
"def",
"in_range_bev",
"(",
"self",
",",
"box_range",
")",
":",
"in_range_flags",
"=",
"(",
"(",
"self",
".",
"tensor",
"[",
":",
",",
"0",
"]",
">",
"box_range",
"[",
"0",
"]",
")",
"&",
"(",
"self",
".",
"tensor",
"[",
":",
",",
"1",
"]",
">",
"box_range",
"[",
"1",
"]",
")",
"&",
"(",
"self",
".",
"tensor",
"[",
":",
",",
"0",
"]",
"<",
"box_range",
"[",
"2",
"]",
")",
"&",
"(",
"self",
".",
"tensor",
"[",
":",
",",
"1",
"]",
"<",
"box_range",
"[",
"3",
"]",
")",
")",
"return",
"in_range_flags"
] | [
192,
4
] | [
212,
29
] | python | en | ['en', 'en', 'en'] | True |
DepthInstance3DBoxes.convert_to | (self, dst, rt_mat=None) | Convert self to ``dst`` mode.
Args:
dst (:obj:`BoxMode`): The target Box mode.
rt_mat (np.ndarray | torch.Tensor): The rotation and translation
matrix between different coordinates. Defaults to None.
The conversion from ``src`` coordinates to ``dst`` coordinates
usually comes along the change of sensors, e.g., from camera
to LiDAR. This requires a transformation matrix.
Returns:
:obj:`DepthInstance3DBoxes`: \
The converted box of the same type in the ``dst`` mode.
| Convert self to ``dst`` mode. | def convert_to(self, dst, rt_mat=None):
"""Convert self to ``dst`` mode.
Args:
dst (:obj:`BoxMode`): The target Box mode.
rt_mat (np.ndarray | torch.Tensor): The rotation and translation
matrix between different coordinates. Defaults to None.
The conversion from ``src`` coordinates to ``dst`` coordinates
usually comes along the change of sensors, e.g., from camera
to LiDAR. This requires a transformation matrix.
Returns:
:obj:`DepthInstance3DBoxes`: \
The converted box of the same type in the ``dst`` mode.
"""
from .box_3d_mode import Box3DMode
return Box3DMode.convert(
box=self, src=Box3DMode.DEPTH, dst=dst, rt_mat=rt_mat) | [
"def",
"convert_to",
"(",
"self",
",",
"dst",
",",
"rt_mat",
"=",
"None",
")",
":",
"from",
".",
"box_3d_mode",
"import",
"Box3DMode",
"return",
"Box3DMode",
".",
"convert",
"(",
"box",
"=",
"self",
",",
"src",
"=",
"Box3DMode",
".",
"DEPTH",
",",
"dst",
"=",
"dst",
",",
"rt_mat",
"=",
"rt_mat",
")"
] | [
214,
4
] | [
231,
66
] | python | en | ['en', 'en', 'en'] | True |
DepthInstance3DBoxes.points_in_boxes | (self, points) | Find points that are in boxes (CUDA).
Args:
points (torch.Tensor): Points in shape [1, M, 3] or [M, 3], \
3 dimensions are [x, y, z] in LiDAR coordinate.
Returns:
torch.Tensor: The index of boxes each point lies in with shape \
of (B, M, T).
| Find points that are in boxes (CUDA). | def points_in_boxes(self, points):
"""Find points that are in boxes (CUDA).
Args:
points (torch.Tensor): Points in shape [1, M, 3] or [M, 3], \
3 dimensions are [x, y, z] in LiDAR coordinate.
Returns:
torch.Tensor: The index of boxes each point lies in with shape \
of (B, M, T).
"""
from .box_3d_mode import Box3DMode
# to lidar
points_lidar = points.clone()
points_lidar = points_lidar[..., [1, 0, 2]]
points_lidar[..., 1] *= -1
if points.dim() == 2:
points_lidar = points_lidar.unsqueeze(0)
else:
assert points.dim() == 3 and points_lidar.shape[0] == 1
boxes_lidar = self.convert_to(Box3DMode.LIDAR).tensor
boxes_lidar = boxes_lidar.to(points.device).unsqueeze(0)
box_idxs_of_pts = points_in_boxes_batch(points_lidar, boxes_lidar)
return box_idxs_of_pts.squeeze(0) | [
"def",
"points_in_boxes",
"(",
"self",
",",
"points",
")",
":",
"from",
".",
"box_3d_mode",
"import",
"Box3DMode",
"# to lidar",
"points_lidar",
"=",
"points",
".",
"clone",
"(",
")",
"points_lidar",
"=",
"points_lidar",
"[",
"...",
",",
"[",
"1",
",",
"0",
",",
"2",
"]",
"]",
"points_lidar",
"[",
"...",
",",
"1",
"]",
"*=",
"-",
"1",
"if",
"points",
".",
"dim",
"(",
")",
"==",
"2",
":",
"points_lidar",
"=",
"points_lidar",
".",
"unsqueeze",
"(",
"0",
")",
"else",
":",
"assert",
"points",
".",
"dim",
"(",
")",
"==",
"3",
"and",
"points_lidar",
".",
"shape",
"[",
"0",
"]",
"==",
"1",
"boxes_lidar",
"=",
"self",
".",
"convert_to",
"(",
"Box3DMode",
".",
"LIDAR",
")",
".",
"tensor",
"boxes_lidar",
"=",
"boxes_lidar",
".",
"to",
"(",
"points",
".",
"device",
")",
".",
"unsqueeze",
"(",
"0",
")",
"box_idxs_of_pts",
"=",
"points_in_boxes_batch",
"(",
"points_lidar",
",",
"boxes_lidar",
")",
"return",
"box_idxs_of_pts",
".",
"squeeze",
"(",
"0",
")"
] | [
233,
4
] | [
259,
41
] | python | en | ['en', 'en', 'en'] | True |
DepthInstance3DBoxes.enlarged_box | (self, extra_width) | Enlarge the length, width and height boxes.
Args:
extra_width (float | torch.Tensor): Extra width to enlarge the box.
Returns:
:obj:`LiDARInstance3DBoxes`: Enlarged boxes.
| Enlarge the length, width and height boxes. | def enlarged_box(self, extra_width):
"""Enlarge the length, width and height boxes.
Args:
extra_width (float | torch.Tensor): Extra width to enlarge the box.
Returns:
:obj:`LiDARInstance3DBoxes`: Enlarged boxes.
"""
enlarged_boxes = self.tensor.clone()
enlarged_boxes[:, 3:6] += extra_width * 2
# bottom center z minus extra_width
enlarged_boxes[:, 2] -= extra_width
return self.new_box(enlarged_boxes) | [
"def",
"enlarged_box",
"(",
"self",
",",
"extra_width",
")",
":",
"enlarged_boxes",
"=",
"self",
".",
"tensor",
".",
"clone",
"(",
")",
"enlarged_boxes",
"[",
":",
",",
"3",
":",
"6",
"]",
"+=",
"extra_width",
"*",
"2",
"# bottom center z minus extra_width",
"enlarged_boxes",
"[",
":",
",",
"2",
"]",
"-=",
"extra_width",
"return",
"self",
".",
"new_box",
"(",
"enlarged_boxes",
")"
] | [
261,
4
] | [
274,
43
] | python | en | ['en', 'en', 'en'] | True |
DepthInstance3DBoxes.get_surface_line_center | (self) | Compute surface and line center of bounding boxes.
Returns:
torch.Tensor: Surface and line center of bounding boxes.
| Compute surface and line center of bounding boxes. | def get_surface_line_center(self):
"""Compute surface and line center of bounding boxes.
Returns:
torch.Tensor: Surface and line center of bounding boxes.
"""
obj_size = self.dims
center = self.gravity_center.view(-1, 1, 3)
batch_size = center.shape[0]
rot_sin = torch.sin(-self.yaw)
rot_cos = torch.cos(-self.yaw)
rot_mat_T = self.yaw.new_zeros(tuple(list(self.yaw.shape) + [3, 3]))
rot_mat_T[..., 0, 0] = rot_cos
rot_mat_T[..., 0, 1] = -rot_sin
rot_mat_T[..., 1, 0] = rot_sin
rot_mat_T[..., 1, 1] = rot_cos
rot_mat_T[..., 2, 2] = 1
# Get the object surface center
offset = obj_size.new_tensor([[0, 0, 1], [0, 0, -1], [0, 1, 0],
[0, -1, 0], [1, 0, 0], [-1, 0, 0]])
offset = offset.view(1, 6, 3) / 2
surface_3d = (offset *
obj_size.view(batch_size, 1, 3).repeat(1, 6, 1)).reshape(
-1, 3)
# Get the object line center
offset = obj_size.new_tensor([[1, 0, 1], [-1, 0, 1], [0, 1, 1],
[0, -1, 1], [1, 0, -1], [-1, 0, -1],
[0, 1, -1], [0, -1, -1], [1, 1, 0],
[1, -1, 0], [-1, 1, 0], [-1, -1, 0]])
offset = offset.view(1, 12, 3) / 2
line_3d = (offset *
obj_size.view(batch_size, 1, 3).repeat(1, 12, 1)).reshape(
-1, 3)
surface_rot = rot_mat_T.repeat(6, 1, 1)
surface_3d = torch.matmul(
surface_3d.unsqueeze(-2), surface_rot.transpose(2, 1)).squeeze(-2)
surface_center = center.repeat(1, 6, 1).reshape(-1, 3) + surface_3d
line_rot = rot_mat_T.repeat(12, 1, 1)
line_3d = torch.matmul(
line_3d.unsqueeze(-2), line_rot.transpose(2, 1)).squeeze(-2)
line_center = center.repeat(1, 12, 1).reshape(-1, 3) + line_3d
return surface_center, line_center | [
"def",
"get_surface_line_center",
"(",
"self",
")",
":",
"obj_size",
"=",
"self",
".",
"dims",
"center",
"=",
"self",
".",
"gravity_center",
".",
"view",
"(",
"-",
"1",
",",
"1",
",",
"3",
")",
"batch_size",
"=",
"center",
".",
"shape",
"[",
"0",
"]",
"rot_sin",
"=",
"torch",
".",
"sin",
"(",
"-",
"self",
".",
"yaw",
")",
"rot_cos",
"=",
"torch",
".",
"cos",
"(",
"-",
"self",
".",
"yaw",
")",
"rot_mat_T",
"=",
"self",
".",
"yaw",
".",
"new_zeros",
"(",
"tuple",
"(",
"list",
"(",
"self",
".",
"yaw",
".",
"shape",
")",
"+",
"[",
"3",
",",
"3",
"]",
")",
")",
"rot_mat_T",
"[",
"...",
",",
"0",
",",
"0",
"]",
"=",
"rot_cos",
"rot_mat_T",
"[",
"...",
",",
"0",
",",
"1",
"]",
"=",
"-",
"rot_sin",
"rot_mat_T",
"[",
"...",
",",
"1",
",",
"0",
"]",
"=",
"rot_sin",
"rot_mat_T",
"[",
"...",
",",
"1",
",",
"1",
"]",
"=",
"rot_cos",
"rot_mat_T",
"[",
"...",
",",
"2",
",",
"2",
"]",
"=",
"1",
"# Get the object surface center",
"offset",
"=",
"obj_size",
".",
"new_tensor",
"(",
"[",
"[",
"0",
",",
"0",
",",
"1",
"]",
",",
"[",
"0",
",",
"0",
",",
"-",
"1",
"]",
",",
"[",
"0",
",",
"1",
",",
"0",
"]",
",",
"[",
"0",
",",
"-",
"1",
",",
"0",
"]",
",",
"[",
"1",
",",
"0",
",",
"0",
"]",
",",
"[",
"-",
"1",
",",
"0",
",",
"0",
"]",
"]",
")",
"offset",
"=",
"offset",
".",
"view",
"(",
"1",
",",
"6",
",",
"3",
")",
"/",
"2",
"surface_3d",
"=",
"(",
"offset",
"*",
"obj_size",
".",
"view",
"(",
"batch_size",
",",
"1",
",",
"3",
")",
".",
"repeat",
"(",
"1",
",",
"6",
",",
"1",
")",
")",
".",
"reshape",
"(",
"-",
"1",
",",
"3",
")",
"# Get the object line center",
"offset",
"=",
"obj_size",
".",
"new_tensor",
"(",
"[",
"[",
"1",
",",
"0",
",",
"1",
"]",
",",
"[",
"-",
"1",
",",
"0",
",",
"1",
"]",
",",
"[",
"0",
",",
"1",
",",
"1",
"]",
",",
"[",
"0",
",",
"-",
"1",
",",
"1",
"]",
",",
"[",
"1",
",",
"0",
",",
"-",
"1",
"]",
",",
"[",
"-",
"1",
",",
"0",
",",
"-",
"1",
"]",
",",
"[",
"0",
",",
"1",
",",
"-",
"1",
"]",
",",
"[",
"0",
",",
"-",
"1",
",",
"-",
"1",
"]",
",",
"[",
"1",
",",
"1",
",",
"0",
"]",
",",
"[",
"1",
",",
"-",
"1",
",",
"0",
"]",
",",
"[",
"-",
"1",
",",
"1",
",",
"0",
"]",
",",
"[",
"-",
"1",
",",
"-",
"1",
",",
"0",
"]",
"]",
")",
"offset",
"=",
"offset",
".",
"view",
"(",
"1",
",",
"12",
",",
"3",
")",
"/",
"2",
"line_3d",
"=",
"(",
"offset",
"*",
"obj_size",
".",
"view",
"(",
"batch_size",
",",
"1",
",",
"3",
")",
".",
"repeat",
"(",
"1",
",",
"12",
",",
"1",
")",
")",
".",
"reshape",
"(",
"-",
"1",
",",
"3",
")",
"surface_rot",
"=",
"rot_mat_T",
".",
"repeat",
"(",
"6",
",",
"1",
",",
"1",
")",
"surface_3d",
"=",
"torch",
".",
"matmul",
"(",
"surface_3d",
".",
"unsqueeze",
"(",
"-",
"2",
")",
",",
"surface_rot",
".",
"transpose",
"(",
"2",
",",
"1",
")",
")",
".",
"squeeze",
"(",
"-",
"2",
")",
"surface_center",
"=",
"center",
".",
"repeat",
"(",
"1",
",",
"6",
",",
"1",
")",
".",
"reshape",
"(",
"-",
"1",
",",
"3",
")",
"+",
"surface_3d",
"line_rot",
"=",
"rot_mat_T",
".",
"repeat",
"(",
"12",
",",
"1",
",",
"1",
")",
"line_3d",
"=",
"torch",
".",
"matmul",
"(",
"line_3d",
".",
"unsqueeze",
"(",
"-",
"2",
")",
",",
"line_rot",
".",
"transpose",
"(",
"2",
",",
"1",
")",
")",
".",
"squeeze",
"(",
"-",
"2",
")",
"line_center",
"=",
"center",
".",
"repeat",
"(",
"1",
",",
"12",
",",
"1",
")",
".",
"reshape",
"(",
"-",
"1",
",",
"3",
")",
"+",
"line_3d",
"return",
"surface_center",
",",
"line_center"
] | [
276,
4
] | [
324,
42
] | python | en | ['en', 'en', 'en'] | True |
PersonalityCaptionsTeacher.add_cmdline_args | (
cls, parser: ParlaiParser, partial_opt: Optional[Opt] = None
) |
Add command line args.
|
Add command line args.
| def add_cmdline_args(
cls, parser: ParlaiParser, partial_opt: Optional[Opt] = None
) -> ParlaiParser:
"""
Add command line args.
"""
agent = parser.add_argument_group('Personality-Captions arguments')
agent.add_argument(
'--include-personality',
type='bool',
default=True,
help='Whether to provide personality to agent',
)
agent.add_argument(
'--include-image',
type='bool',
default=True,
help='Whether to provide image to agent',
)
agent.add_argument(
'--num-test-labels',
type=int,
default=1,
choices=[1, 5],
help='Provide model with either 1 or 5 possible '
'labels for each test example. The number of label '
'candidates for each case is 100 and 500 '
'respectively.',
)
agent.add_argument(
'--yfcc-path',
type=str,
default=None,
help='Path to yfcc images (if not downloaded '
'via the provided download script)',
)
return parser | [
"def",
"add_cmdline_args",
"(",
"cls",
",",
"parser",
":",
"ParlaiParser",
",",
"partial_opt",
":",
"Optional",
"[",
"Opt",
"]",
"=",
"None",
")",
"->",
"ParlaiParser",
":",
"agent",
"=",
"parser",
".",
"add_argument_group",
"(",
"'Personality-Captions arguments'",
")",
"agent",
".",
"add_argument",
"(",
"'--include-personality'",
",",
"type",
"=",
"'bool'",
",",
"default",
"=",
"True",
",",
"help",
"=",
"'Whether to provide personality to agent'",
",",
")",
"agent",
".",
"add_argument",
"(",
"'--include-image'",
",",
"type",
"=",
"'bool'",
",",
"default",
"=",
"True",
",",
"help",
"=",
"'Whether to provide image to agent'",
",",
")",
"agent",
".",
"add_argument",
"(",
"'--num-test-labels'",
",",
"type",
"=",
"int",
",",
"default",
"=",
"1",
",",
"choices",
"=",
"[",
"1",
",",
"5",
"]",
",",
"help",
"=",
"'Provide model with either 1 or 5 possible '",
"'labels for each test example. The number of label '",
"'candidates for each case is 100 and 500 '",
"'respectively.'",
",",
")",
"agent",
".",
"add_argument",
"(",
"'--yfcc-path'",
",",
"type",
"=",
"str",
",",
"default",
"=",
"None",
",",
"help",
"=",
"'Path to yfcc images (if not downloaded '",
"'via the provided download script)'",
",",
")",
"return",
"parser"
] | [
73,
4
] | [
109,
21
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTeacher.reset | (self) |
Reset teacher.
|
Reset teacher.
| def reset(self):
"""
Reset teacher.
"""
super().reset()
self.example = None | [
"def",
"reset",
"(",
"self",
")",
":",
"super",
"(",
")",
".",
"reset",
"(",
")",
"self",
".",
"example",
"=",
"None"
] | [
118,
4
] | [
123,
27
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTeacher.num_episodes | (self) |
Return number of episodes.
|
Return number of episodes.
| def num_episodes(self):
"""
Return number of episodes.
"""
return self.num_examples() | [
"def",
"num_episodes",
"(",
"self",
")",
":",
"return",
"self",
".",
"num_examples",
"(",
")"
] | [
125,
4
] | [
129,
34
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTeacher.num_examples | (self) |
Return number of examples.
|
Return number of examples.
| def num_examples(self):
"""
Return number of examples.
"""
return len(self.data) | [
"def",
"num_examples",
"(",
"self",
")",
":",
"return",
"len",
"(",
"self",
".",
"data",
")"
] | [
131,
4
] | [
135,
29
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTeacher.submit_load_request | (self, image_id) |
Submit a load request to the image loader.
:param image_id:
id of image to load
|
Submit a load request to the image loader. | def submit_load_request(self, image_id):
"""
Submit a load request to the image loader.
:param image_id:
id of image to load
"""
img_path = os.path.join(self.image_path, '{}.jpg'.format(image_id))
self.data_loader.request_load(
self.receive_data, self.image_loader.load, (img_path,)
) | [
"def",
"submit_load_request",
"(",
"self",
",",
"image_id",
")",
":",
"img_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"image_path",
",",
"'{}.jpg'",
".",
"format",
"(",
"image_id",
")",
")",
"self",
".",
"data_loader",
".",
"request_load",
"(",
"self",
".",
"receive_data",
",",
"self",
".",
"image_loader",
".",
"load",
",",
"(",
"img_path",
",",
")",
")"
] | [
137,
4
] | [
147,
9
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTeacher.get | (self, episode_idx, entry_idx=0) |
Get an example.
:param episode_idx:
index of episode in self.data
:param entry_idx:
optional, which entry in the episode to get
:return:
an example
|
Get an example. | def get(self, episode_idx, entry_idx=0):
"""
Get an example.
:param episode_idx:
index of episode in self.data
:param entry_idx:
optional, which entry in the episode to get
:return:
an example
"""
data = self.data[episode_idx]
action = {
'text': data['personality'] if self.include_personality else '',
'image_id': data['image_hash'],
'episode_done': True,
'labels': [data['comment']],
}
if self.num_test_labels == 5 and 'test' in self.datatype:
action['labels'] += data['additional_comments']
if 'candidates' in data:
if self.num_test_labels == 5 and 'test' in self.datatype:
action['label_candidates'] = data['500_candidates']
else:
action['label_candidates'] = data['candidates']
return action | [
"def",
"get",
"(",
"self",
",",
"episode_idx",
",",
"entry_idx",
"=",
"0",
")",
":",
"data",
"=",
"self",
".",
"data",
"[",
"episode_idx",
"]",
"action",
"=",
"{",
"'text'",
":",
"data",
"[",
"'personality'",
"]",
"if",
"self",
".",
"include_personality",
"else",
"''",
",",
"'image_id'",
":",
"data",
"[",
"'image_hash'",
"]",
",",
"'episode_done'",
":",
"True",
",",
"'labels'",
":",
"[",
"data",
"[",
"'comment'",
"]",
"]",
",",
"}",
"if",
"self",
".",
"num_test_labels",
"==",
"5",
"and",
"'test'",
"in",
"self",
".",
"datatype",
":",
"action",
"[",
"'labels'",
"]",
"+=",
"data",
"[",
"'additional_comments'",
"]",
"if",
"'candidates'",
"in",
"data",
":",
"if",
"self",
".",
"num_test_labels",
"==",
"5",
"and",
"'test'",
"in",
"self",
".",
"datatype",
":",
"action",
"[",
"'label_candidates'",
"]",
"=",
"data",
"[",
"'500_candidates'",
"]",
"else",
":",
"action",
"[",
"'label_candidates'",
"]",
"=",
"data",
"[",
"'candidates'",
"]",
"return",
"action"
] | [
149,
4
] | [
178,
21
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTeacher.next_example | (self) |
Return the next example from this dataset.
Queues next example.
|
Return the next example from this dataset. | def next_example(self):
"""
Return the next example from this dataset.
Queues next example.
"""
ready = None
load_image = self.image_mode != 'no_image_model' and self.include_image
# pull up the currently queued example
if self.example is not None:
# if self.image_mode != 'none' and 'image_id' in self.example:
if load_image and 'image_id' in self.example:
# move the image we loaded in the background into the example
image = self.data_queue.get()
self.example['image'] = image
ready = (self.example, self.imageEpochDone)
# get the next base example: super().next_example() calls self.get()
self.example, self.imageEpochDone = super().next_example()
# if self.image_mode != 'none' and 'image_id' in self.example:
if load_image and 'image_id' in self.example:
# load the next image in the background
image_id = self.example['image_id']
self.submit_load_request(image_id)
# Try to return the previously cached example
if ready is None:
return self.next_example()
else:
return ready | [
"def",
"next_example",
"(",
"self",
")",
":",
"ready",
"=",
"None",
"load_image",
"=",
"self",
".",
"image_mode",
"!=",
"'no_image_model'",
"and",
"self",
".",
"include_image",
"# pull up the currently queued example",
"if",
"self",
".",
"example",
"is",
"not",
"None",
":",
"# if self.image_mode != 'none' and 'image_id' in self.example:",
"if",
"load_image",
"and",
"'image_id'",
"in",
"self",
".",
"example",
":",
"# move the image we loaded in the background into the example",
"image",
"=",
"self",
".",
"data_queue",
".",
"get",
"(",
")",
"self",
".",
"example",
"[",
"'image'",
"]",
"=",
"image",
"ready",
"=",
"(",
"self",
".",
"example",
",",
"self",
".",
"imageEpochDone",
")",
"# get the next base example: super().next_example() calls self.get()",
"self",
".",
"example",
",",
"self",
".",
"imageEpochDone",
"=",
"super",
"(",
")",
".",
"next_example",
"(",
")",
"# if self.image_mode != 'none' and 'image_id' in self.example:",
"if",
"load_image",
"and",
"'image_id'",
"in",
"self",
".",
"example",
":",
"# load the next image in the background",
"image_id",
"=",
"self",
".",
"example",
"[",
"'image_id'",
"]",
"self",
".",
"submit_load_request",
"(",
"image_id",
")",
"# Try to return the previously cached example",
"if",
"ready",
"is",
"None",
":",
"return",
"self",
".",
"next_example",
"(",
")",
"else",
":",
"return",
"ready"
] | [
180,
4
] | [
207,
24
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTeacher.share | (self) |
Share appropriate attributes.
|
Share appropriate attributes.
| def share(self):
"""
Share appropriate attributes.
"""
shared = super().share()
shared['data'] = self.data
shared['image_loader'] = self.image_loader
return shared | [
"def",
"share",
"(",
"self",
")",
":",
"shared",
"=",
"super",
"(",
")",
".",
"share",
"(",
")",
"shared",
"[",
"'data'",
"]",
"=",
"self",
".",
"data",
"shared",
"[",
"'image_loader'",
"]",
"=",
"self",
".",
"image_loader",
"return",
"shared"
] | [
209,
4
] | [
216,
21
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTestTeacher.reset | (self) |
Reset teacher.
|
Reset teacher.
| def reset(self):
"""
Reset teacher.
"""
super().reset()
self.example = None | [
"def",
"reset",
"(",
"self",
")",
":",
"super",
"(",
")",
".",
"reset",
"(",
")",
"self",
".",
"example",
"=",
"None"
] | [
238,
4
] | [
243,
27
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTestTeacher.num_episodes | (self) |
Return number of episodes.
|
Return number of episodes.
| def num_episodes(self):
"""
Return number of episodes.
"""
return len(self.image_features) | [
"def",
"num_episodes",
"(",
"self",
")",
":",
"return",
"len",
"(",
"self",
".",
"image_features",
")"
] | [
245,
4
] | [
249,
39
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTestTeacher.num_examples | (self) |
Return number of examples.
|
Return number of examples.
| def num_examples(self):
"""
Return number of examples.
"""
return len(self.image_features) | [
"def",
"num_examples",
"(",
"self",
")",
":",
"return",
"len",
"(",
"self",
".",
"image_features",
")"
] | [
251,
4
] | [
255,
39
] | python | en | ['en', 'error', 'th'] | False |
PersonalityCaptionsTestTeacher.get | (self, episode_idx, entry_idx=0) |
Get an example.
:param episode_idx:
index of episode in self.data
:param entry_idx:
optional, which entry in the episode to get
:return:
an example
|
Get an example. | def get(self, episode_idx, entry_idx=0):
"""
Get an example.
:param episode_idx:
index of episode in self.data
:param entry_idx:
optional, which entry in the episode to get
:return:
an example
"""
data = self.data[episode_idx]
action = {
'text': data['personality'] if self.include_personality else '',
'image': self.image_features[data['image_hash']],
'episode_done': True,
'labels': [data['comment']],
}
if self.num_test_labels == 5 and 'test' in self.datatype:
action['labels'] += data['additional_comments']
if 'candidates' in data:
if self.num_test_labels == 5 and 'test' in self.datatype:
action['label_candidates'] = data['500_candidates']
else:
action['label_candidates'] = data['candidates']
return action | [
"def",
"get",
"(",
"self",
",",
"episode_idx",
",",
"entry_idx",
"=",
"0",
")",
":",
"data",
"=",
"self",
".",
"data",
"[",
"episode_idx",
"]",
"action",
"=",
"{",
"'text'",
":",
"data",
"[",
"'personality'",
"]",
"if",
"self",
".",
"include_personality",
"else",
"''",
",",
"'image'",
":",
"self",
".",
"image_features",
"[",
"data",
"[",
"'image_hash'",
"]",
"]",
",",
"'episode_done'",
":",
"True",
",",
"'labels'",
":",
"[",
"data",
"[",
"'comment'",
"]",
"]",
",",
"}",
"if",
"self",
".",
"num_test_labels",
"==",
"5",
"and",
"'test'",
"in",
"self",
".",
"datatype",
":",
"action",
"[",
"'labels'",
"]",
"+=",
"data",
"[",
"'additional_comments'",
"]",
"if",
"'candidates'",
"in",
"data",
":",
"if",
"self",
".",
"num_test_labels",
"==",
"5",
"and",
"'test'",
"in",
"self",
".",
"datatype",
":",
"action",
"[",
"'label_candidates'",
"]",
"=",
"data",
"[",
"'500_candidates'",
"]",
"else",
":",
"action",
"[",
"'label_candidates'",
"]",
"=",
"data",
"[",
"'candidates'",
"]",
"return",
"action"
] | [
257,
4
] | [
286,
21
] | python | en | ['en', 'error', 'th'] | False |
setup_args | () |
Set up args.
:return: A parser that takes in command line arguments for chat services (debug, config-path, password), and a port.
|
Set up args. | def setup_args():
"""
Set up args.
:return: A parser that takes in command line arguments for chat services (debug, config-path, password), and a port.
"""
parser = ParlaiParser(False, False)
parser.add_parlai_data_path()
parser.add_chatservice_args()
parser_grp = parser.add_argument_group('Browser Chat')
parser_grp.add_argument(
'--port', default=35496, type=int, help='Port to run the browser chat server'
)
return parser.parse_args() | [
"def",
"setup_args",
"(",
")",
":",
"parser",
"=",
"ParlaiParser",
"(",
"False",
",",
"False",
")",
"parser",
".",
"add_parlai_data_path",
"(",
")",
"parser",
".",
"add_chatservice_args",
"(",
")",
"parser_grp",
"=",
"parser",
".",
"add_argument_group",
"(",
"'Browser Chat'",
")",
"parser_grp",
".",
"add_argument",
"(",
"'--port'",
",",
"default",
"=",
"35496",
",",
"type",
"=",
"int",
",",
"help",
"=",
"'Port to run the browser chat server'",
")",
"return",
"parser",
".",
"parse_args",
"(",
")"
] | [
19,
0
] | [
32,
30
] | python | en | ['en', 'error', 'th'] | False |
run | (opt) |
Run BrowserManager.
|
Run BrowserManager.
| def run(opt):
"""
Run BrowserManager.
"""
opt['service'] = SERVICE_NAME
manager = BrowserManager(opt)
try:
manager.start_task()
finally:
manager.shutdown() | [
"def",
"run",
"(",
"opt",
")",
":",
"opt",
"[",
"'service'",
"]",
"=",
"SERVICE_NAME",
"manager",
"=",
"BrowserManager",
"(",
"opt",
")",
"try",
":",
"manager",
".",
"start_task",
"(",
")",
"finally",
":",
"manager",
".",
"shutdown",
"(",
")"
] | [
35,
0
] | [
44,
26
] | python | en | ['en', 'error', 'th'] | False |
Bottleneck.__init__ | (self,
inplanes,
planes,
groups=1,
base_width=4,
base_channels=64,
**kwargs) | Bottleneck block for ResNeXt.
If style is "pytorch", the stride-two layer is the 3x3 conv layer, if
it is "caffe", the stride-two layer is the first 1x1 conv layer.
| Bottleneck block for ResNeXt. | def __init__(self,
inplanes,
planes,
groups=1,
base_width=4,
base_channels=64,
**kwargs):
"""Bottleneck block for ResNeXt.
If style is "pytorch", the stride-two layer is the 3x3 conv layer, if
it is "caffe", the stride-two layer is the first 1x1 conv layer.
"""
super(Bottleneck, self).__init__(inplanes, planes, **kwargs)
if groups == 1:
width = self.planes
else:
width = math.floor(self.planes *
(base_width / base_channels)) * groups
self.norm1_name, norm1 = build_norm_layer(
self.norm_cfg, width, postfix=1)
self.norm2_name, norm2 = build_norm_layer(
self.norm_cfg, width, postfix=2)
self.norm3_name, norm3 = build_norm_layer(
self.norm_cfg, self.planes * self.expansion, postfix=3)
self.conv1 = build_conv_layer(
self.conv_cfg,
self.inplanes,
width,
kernel_size=1,
stride=self.conv1_stride,
bias=False)
self.add_module(self.norm1_name, norm1)
fallback_on_stride = False
self.with_modulated_dcn = False
if self.with_dcn:
fallback_on_stride = self.dcn.pop('fallback_on_stride', False)
if not self.with_dcn or fallback_on_stride:
self.conv2 = build_conv_layer(
self.conv_cfg,
width,
width,
kernel_size=3,
stride=self.conv2_stride,
padding=self.dilation,
dilation=self.dilation,
groups=groups,
bias=False)
else:
assert self.conv_cfg is None, 'conv_cfg must be None for DCN'
self.conv2 = build_conv_layer(
self.dcn,
width,
width,
kernel_size=3,
stride=self.conv2_stride,
padding=self.dilation,
dilation=self.dilation,
groups=groups,
bias=False)
self.add_module(self.norm2_name, norm2)
self.conv3 = build_conv_layer(
self.conv_cfg,
width,
self.planes * self.expansion,
kernel_size=1,
bias=False)
self.add_module(self.norm3_name, norm3) | [
"def",
"__init__",
"(",
"self",
",",
"inplanes",
",",
"planes",
",",
"groups",
"=",
"1",
",",
"base_width",
"=",
"4",
",",
"base_channels",
"=",
"64",
",",
"*",
"*",
"kwargs",
")",
":",
"super",
"(",
"Bottleneck",
",",
"self",
")",
".",
"__init__",
"(",
"inplanes",
",",
"planes",
",",
"*",
"*",
"kwargs",
")",
"if",
"groups",
"==",
"1",
":",
"width",
"=",
"self",
".",
"planes",
"else",
":",
"width",
"=",
"math",
".",
"floor",
"(",
"self",
".",
"planes",
"*",
"(",
"base_width",
"/",
"base_channels",
")",
")",
"*",
"groups",
"self",
".",
"norm1_name",
",",
"norm1",
"=",
"build_norm_layer",
"(",
"self",
".",
"norm_cfg",
",",
"width",
",",
"postfix",
"=",
"1",
")",
"self",
".",
"norm2_name",
",",
"norm2",
"=",
"build_norm_layer",
"(",
"self",
".",
"norm_cfg",
",",
"width",
",",
"postfix",
"=",
"2",
")",
"self",
".",
"norm3_name",
",",
"norm3",
"=",
"build_norm_layer",
"(",
"self",
".",
"norm_cfg",
",",
"self",
".",
"planes",
"*",
"self",
".",
"expansion",
",",
"postfix",
"=",
"3",
")",
"self",
".",
"conv1",
"=",
"build_conv_layer",
"(",
"self",
".",
"conv_cfg",
",",
"self",
".",
"inplanes",
",",
"width",
",",
"kernel_size",
"=",
"1",
",",
"stride",
"=",
"self",
".",
"conv1_stride",
",",
"bias",
"=",
"False",
")",
"self",
".",
"add_module",
"(",
"self",
".",
"norm1_name",
",",
"norm1",
")",
"fallback_on_stride",
"=",
"False",
"self",
".",
"with_modulated_dcn",
"=",
"False",
"if",
"self",
".",
"with_dcn",
":",
"fallback_on_stride",
"=",
"self",
".",
"dcn",
".",
"pop",
"(",
"'fallback_on_stride'",
",",
"False",
")",
"if",
"not",
"self",
".",
"with_dcn",
"or",
"fallback_on_stride",
":",
"self",
".",
"conv2",
"=",
"build_conv_layer",
"(",
"self",
".",
"conv_cfg",
",",
"width",
",",
"width",
",",
"kernel_size",
"=",
"3",
",",
"stride",
"=",
"self",
".",
"conv2_stride",
",",
"padding",
"=",
"self",
".",
"dilation",
",",
"dilation",
"=",
"self",
".",
"dilation",
",",
"groups",
"=",
"groups",
",",
"bias",
"=",
"False",
")",
"else",
":",
"assert",
"self",
".",
"conv_cfg",
"is",
"None",
",",
"'conv_cfg must be None for DCN'",
"self",
".",
"conv2",
"=",
"build_conv_layer",
"(",
"self",
".",
"dcn",
",",
"width",
",",
"width",
",",
"kernel_size",
"=",
"3",
",",
"stride",
"=",
"self",
".",
"conv2_stride",
",",
"padding",
"=",
"self",
".",
"dilation",
",",
"dilation",
"=",
"self",
".",
"dilation",
",",
"groups",
"=",
"groups",
",",
"bias",
"=",
"False",
")",
"self",
".",
"add_module",
"(",
"self",
".",
"norm2_name",
",",
"norm2",
")",
"self",
".",
"conv3",
"=",
"build_conv_layer",
"(",
"self",
".",
"conv_cfg",
",",
"width",
",",
"self",
".",
"planes",
"*",
"self",
".",
"expansion",
",",
"kernel_size",
"=",
"1",
",",
"bias",
"=",
"False",
")",
"self",
".",
"add_module",
"(",
"self",
".",
"norm3_name",
",",
"norm3",
")"
] | [
13,
4
] | [
83,
47
] | python | en | ['en', 'no', 'en'] | True |
Font.color | (self) |
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
- A list or array of any of the above
Returns
-------
str|numpy.ndarray
|
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
- A list or array of any of the above | def color(self):
"""
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
- A list or array of any of the above
Returns
-------
str|numpy.ndarray
"""
return self["color"] | [
"def",
"color",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"color\"",
"]"
] | [
15,
4
] | [
64,
28
] | python | en | ['en', 'error', 'th'] | False |
Font.colorsrc | (self) |
Sets the source reference on Chart Studio Cloud for color .
The 'colorsrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
|
Sets the source reference on Chart Studio Cloud for color .
The 'colorsrc' property must be specified as a string or
as a plotly.grid_objs.Column object | def colorsrc(self):
"""
Sets the source reference on Chart Studio Cloud for color .
The 'colorsrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
"""
return self["colorsrc"] | [
"def",
"colorsrc",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"colorsrc\"",
"]"
] | [
73,
4
] | [
84,
31
] | python | en | ['en', 'error', 'th'] | False |
Font.family | (self) |
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".
The 'family' property is a string and must be specified as:
- A non-empty string
- A tuple, list, or one-dimensional numpy array of the above
Returns
-------
str|numpy.ndarray
|
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".
The 'family' property is a string and must be specified as:
- A non-empty string
- A tuple, list, or one-dimensional numpy array of the above | def family(self):
"""
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".
The 'family' property is a string and must be specified as:
- A non-empty string
- A tuple, list, or one-dimensional numpy array of the above
Returns
-------
str|numpy.ndarray
"""
return self["family"] | [
"def",
"family",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"family\"",
"]"
] | [
93,
4
] | [
116,
29
] | python | en | ['en', 'error', 'th'] | False |
Font.familysrc | (self) |
Sets the source reference on Chart Studio Cloud for family .
The 'familysrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
|
Sets the source reference on Chart Studio Cloud for family .
The 'familysrc' property must be specified as a string or
as a plotly.grid_objs.Column object | def familysrc(self):
"""
Sets the source reference on Chart Studio Cloud for family .
The 'familysrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
"""
return self["familysrc"] | [
"def",
"familysrc",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"familysrc\"",
"]"
] | [
125,
4
] | [
136,
32
] | python | en | ['en', 'error', 'th'] | False |
Font.size | (self) |
The 'size' property is a number and may be specified as:
- An int or float in the interval [1, inf]
- A tuple, list, or one-dimensional numpy array of the above
Returns
-------
int|float|numpy.ndarray
|
The 'size' property is a number and may be specified as:
- An int or float in the interval [1, inf]
- A tuple, list, or one-dimensional numpy array of the above | def size(self):
"""
The 'size' property is a number and may be specified as:
- An int or float in the interval [1, inf]
- A tuple, list, or one-dimensional numpy array of the above
Returns
-------
int|float|numpy.ndarray
"""
return self["size"] | [
"def",
"size",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"size\"",
"]"
] | [
145,
4
] | [
155,
27
] | python | en | ['en', 'error', 'th'] | False |
Font.sizesrc | (self) |
Sets the source reference on Chart Studio Cloud for size .
The 'sizesrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
|
Sets the source reference on Chart Studio Cloud for size .
The 'sizesrc' property must be specified as a string or
as a plotly.grid_objs.Column object | def sizesrc(self):
"""
Sets the source reference on Chart Studio Cloud for size .
The 'sizesrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
"""
return self["sizesrc"] | [
"def",
"sizesrc",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"sizesrc\"",
"]"
] | [
164,
4
] | [
175,
30
] | python | en | ['en', 'error', 'th'] | False |
Font.__init__ | (
self,
arg=None,
color=None,
colorsrc=None,
family=None,
familysrc=None,
size=None,
sizesrc=None,
**kwargs
) |
Construct a new Font object
Sets the font used in hover labels.
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.splom.hoverlabel.Font`
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 .
size
sizesrc
Sets the source reference on Chart Studio Cloud for
size .
Returns
-------
Font
|
Construct a new Font object
Sets the font used in hover labels. | def __init__(
self,
arg=None,
color=None,
colorsrc=None,
family=None,
familysrc=None,
size=None,
sizesrc=None,
**kwargs
):
"""
Construct a new Font object
Sets the font used in hover labels.
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.splom.hoverlabel.Font`
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 .
size
sizesrc
Sets the source reference on Chart Studio Cloud for
size .
Returns
-------
Font
"""
super(Font, self).__init__("font")
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.splom.hoverlabel.Font
constructor must be a dict or
an instance of :class:`plotly.graph_objs.splom.hoverlabel.Font`"""
)
# 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("color", None)
_v = color if color is not None else _v
if _v is not None:
self["color"] = _v
_v = arg.pop("colorsrc", None)
_v = colorsrc if colorsrc is not None else _v
if _v is not None:
self["colorsrc"] = _v
_v = arg.pop("family", None)
_v = family if family is not None else _v
if _v is not None:
self["family"] = _v
_v = arg.pop("familysrc", None)
_v = familysrc if familysrc is not None else _v
if _v is not None:
self["familysrc"] = _v
_v = arg.pop("size", None)
_v = size if size is not None else _v
if _v is not None:
self["size"] = _v
_v = arg.pop("sizesrc", None)
_v = sizesrc if sizesrc is not None else _v
if _v is not None:
self["sizesrc"] = _v
# Process unknown kwargs
# ----------------------
self._process_kwargs(**dict(arg, **kwargs))
# Reset skip_invalid
# ------------------
self._skip_invalid = False | [
"def",
"__init__",
"(",
"self",
",",
"arg",
"=",
"None",
",",
"color",
"=",
"None",
",",
"colorsrc",
"=",
"None",
",",
"family",
"=",
"None",
",",
"familysrc",
"=",
"None",
",",
"size",
"=",
"None",
",",
"sizesrc",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"super",
"(",
"Font",
",",
"self",
")",
".",
"__init__",
"(",
"\"font\"",
")",
"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",
"(",
"\"\"\"\\\nThe first argument to the plotly.graph_objs.splom.hoverlabel.Font \nconstructor must be a dict or \nan instance of :class:`plotly.graph_objs.splom.hoverlabel.Font`\"\"\"",
")",
"# 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",
"(",
"\"color\"",
",",
"None",
")",
"_v",
"=",
"color",
"if",
"color",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"color\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"colorsrc\"",
",",
"None",
")",
"_v",
"=",
"colorsrc",
"if",
"colorsrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"colorsrc\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"family\"",
",",
"None",
")",
"_v",
"=",
"family",
"if",
"family",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"family\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"familysrc\"",
",",
"None",
")",
"_v",
"=",
"familysrc",
"if",
"familysrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"familysrc\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"size\"",
",",
"None",
")",
"_v",
"=",
"size",
"if",
"size",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"size\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"sizesrc\"",
",",
"None",
")",
"_v",
"=",
"sizesrc",
"if",
"sizesrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"sizesrc\"",
"]",
"=",
"_v",
"# Process unknown kwargs",
"# ----------------------",
"self",
".",
"_process_kwargs",
"(",
"*",
"*",
"dict",
"(",
"arg",
",",
"*",
"*",
"kwargs",
")",
")",
"# Reset skip_invalid",
"# ------------------",
"self",
".",
"_skip_invalid",
"=",
"False"
] | [
215,
4
] | [
329,
34
] | python | en | ['en', 'error', 'th'] | False |
AccountDB.__cmdset_storage_get | (self) |
Getter. Allows for value = self.name. Returns a list of cmdset_storage.
|
Getter. Allows for value = self.name. Returns a list of cmdset_storage.
| def __cmdset_storage_get(self):
"""
Getter. Allows for value = self.name. Returns a list of cmdset_storage.
"""
storage = self.db_cmdset_storage
# we need to check so storage is not None
return [path.strip() for path in storage.split(',')] if storage else [] | [
"def",
"__cmdset_storage_get",
"(",
"self",
")",
":",
"storage",
"=",
"self",
".",
"db_cmdset_storage",
"# we need to check so storage is not None",
"return",
"[",
"path",
".",
"strip",
"(",
")",
"for",
"path",
"in",
"storage",
".",
"split",
"(",
"','",
")",
"]",
"if",
"storage",
"else",
"[",
"]"
] | [
109,
4
] | [
115,
79
] | python | en | ['en', 'error', 'th'] | False |
AccountDB.__cmdset_storage_set | (self, value) |
Setter. Allows for self.name = value. Stores as a comma-separated
string.
|
Setter. Allows for self.name = value. Stores as a comma-separated
string.
| def __cmdset_storage_set(self, value):
"""
Setter. Allows for self.name = value. Stores as a comma-separated
string.
"""
_SA(self, "db_cmdset_storage", ",".join(str(val).strip() for val in make_iter(value)))
_GA(self, "save")() | [
"def",
"__cmdset_storage_set",
"(",
"self",
",",
"value",
")",
":",
"_SA",
"(",
"self",
",",
"\"db_cmdset_storage\"",
",",
"\",\"",
".",
"join",
"(",
"str",
"(",
"val",
")",
".",
"strip",
"(",
")",
"for",
"val",
"in",
"make_iter",
"(",
"value",
")",
")",
")",
"_GA",
"(",
"self",
",",
"\"save\"",
")",
"(",
")"
] | [
118,
4
] | [
124,
27
] | python | en | ['en', 'error', 'th'] | False |
AccountDB.__cmdset_storage_del | (self) | Deleter. Allows for del self.name | Deleter. Allows for del self.name | def __cmdset_storage_del(self):
"Deleter. Allows for del self.name"
_SA(self, "db_cmdset_storage", None)
_GA(self, "save")() | [
"def",
"__cmdset_storage_del",
"(",
"self",
")",
":",
"_SA",
"(",
"self",
",",
"\"db_cmdset_storage\"",
",",
"None",
")",
"_GA",
"(",
"self",
",",
"\"save\"",
")",
"(",
")"
] | [
127,
4
] | [
130,
27
] | python | ca | ['ca', 'en', 'it'] | False |
AccountDB.__uid_get | (self) | Getter. Retrieves the user id | Getter. Retrieves the user id | def __uid_get(self):
"Getter. Retrieves the user id"
return self.id | [
"def",
"__uid_get",
"(",
"self",
")",
":",
"return",
"self",
".",
"id"
] | [
159,
4
] | [
161,
22
] | python | en | ['en', 'en', 'en'] | True |
build_figure_py | (
trace_node,
base_package,
base_classname,
fig_classname,
data_validator,
layout_validator,
frame_validator,
subplot_nodes,
layout_array_nodes,
) |
Parameters
----------
trace_node : PlotlyNode
Root trace node (the node that is the parent of all of the
individual trace nodes like bar, scatter, etc.)
base_package : str
Package that the figure's superclass resides in
base_classname : str
Name of the figure's superclass
fig_classname : str
Name of the Figure class to be generated
data_validator : BaseDataValidator
DataValidator instance
layout_validator : CompoundValidator
LayoutValidator instance
frame_validator : CompoundArrayValidator
FrameValidator instance
subplot_nodes: list of str
List of names of all of the layout subplot properties
layout_array_nodes: list of PlotlyNode
List of array nodes under layout that can be positioned using xref/yref
Returns
-------
str
Source code for figure class definition
| def build_figure_py(
trace_node,
base_package,
base_classname,
fig_classname,
data_validator,
layout_validator,
frame_validator,
subplot_nodes,
layout_array_nodes,
):
"""
Parameters
----------
trace_node : PlotlyNode
Root trace node (the node that is the parent of all of the
individual trace nodes like bar, scatter, etc.)
base_package : str
Package that the figure's superclass resides in
base_classname : str
Name of the figure's superclass
fig_classname : str
Name of the Figure class to be generated
data_validator : BaseDataValidator
DataValidator instance
layout_validator : CompoundValidator
LayoutValidator instance
frame_validator : CompoundArrayValidator
FrameValidator instance
subplot_nodes: list of str
List of names of all of the layout subplot properties
layout_array_nodes: list of PlotlyNode
List of array nodes under layout that can be positioned using xref/yref
Returns
-------
str
Source code for figure class definition
"""
# Initialize source code buffer
# -----------------------------
buffer = StringIO()
# Get list of trace type nodes
# ----------------------------
trace_nodes = trace_node.child_compound_datatypes
# Write imports
# -------------
# ### Import base class ###
buffer.write(f"from plotly.{base_package} import {base_classname}\n")
# Write class definition
# ----------------------
buffer.write(
f"""
class {fig_classname}({base_classname}):\n"""
)
# ### Constructor ###
# Build constructor description strings
data_description = reindent_validator_description(data_validator, 8)
layout_description = reindent_validator_description(layout_validator, 8)
frames_description = reindent_validator_description(frame_validator, 8)
buffer.write(
f"""
def __init__(self, data=None, layout=None,
frames=None, skip_invalid=False, **kwargs):
\"\"\"
Create a new :class:{fig_classname} instance
Parameters
----------
data
{data_description}
layout
{layout_description}
frames
{frames_description}
skip_invalid: bool
If True, invalid properties in the figure specification will be
skipped silently. If False (default) invalid properties in the
figure specification will result in a ValueError
Raises
------
ValueError
if a property in the specification of data, layout, or frames
is invalid AND skip_invalid is False
\"\"\"
super({fig_classname} ,self).__init__(data, layout,
frames, skip_invalid,
**kwargs)
"""
)
# ### add_trace methods for each trace type ###
for trace_node in trace_nodes:
include_secondary_y = bool(
[d for d in trace_node.child_datatypes if d.name_property == "yaxis"]
)
# #### Function signature ####
buffer.write(
f"""
def add_{trace_node.plotly_name}(self"""
)
# #### Function params####
param_extras = ["row", "col"]
if include_secondary_y:
param_extras.append("secondary_y")
add_constructor_params(
buffer, trace_node.child_datatypes, append_extras=param_extras
)
# #### Docstring ####
header = f"Add a new {trace_node.name_datatype_class} trace"
doc_extras = [
(
"row : int or None (default)",
"Subplot row index (starting from 1) for the trace to be "
"added. Only valid if figure was created using "
"`plotly.tools.make_subplots`",
),
(
"col : int or None (default)",
"Subplot col index (starting from 1) for the trace to be "
"added. Only valid if figure was created using "
"`plotly.tools.make_subplots`",
),
]
if include_secondary_y:
doc_extras.append(
(
"secondary_y: boolean or None (default None)",
"""\
If True, associate this trace with the secondary y-axis of the
subplot at the specified row and col. Only valid if all of the
following conditions are satisfied:
* The figure was created using `plotly.subplots.make_subplots`.
* The row and col arguments are not None
* The subplot at the specified row and col has type xy
(which is the default) and secondary_y True. These
properties are specified in the specs argument to
make_subplots. See the make_subplots docstring for more info.\
""",
)
)
add_docstring(
buffer,
trace_node,
header,
append_extras=doc_extras,
return_type=fig_classname,
)
# #### Function body ####
buffer.write(
f"""
from plotly.graph_objs import {trace_node.name_datatype_class}
new_trace = {trace_node.name_datatype_class}(
"""
)
for i, subtype_node in enumerate(trace_node.child_datatypes):
subtype_prop_name = subtype_node.name_property
buffer.write(
f"""
{subtype_prop_name}={subtype_prop_name},"""
)
buffer.write(
f"""
**kwargs)"""
)
if include_secondary_y:
secondary_y_kwarg = ", secondary_y=secondary_y"
else:
secondary_y_kwarg = ""
buffer.write(
f"""
return self.add_trace(
new_trace, row=row, col=col{secondary_y_kwarg})"""
)
# update layout subplots
# ----------------------
inflect_eng = inflect.engine()
for subplot_node in subplot_nodes:
singular_name = subplot_node.name_property
plural_name = inflect_eng.plural_noun(singular_name)
if singular_name == "yaxis":
secondary_y_1 = ", secondary_y=None"
secondary_y_2 = ", secondary_y=secondary_y"
secondary_y_docstring = f"""
secondary_y: boolean or None (default None)
* If True, only select yaxis objects associated with the secondary
y-axis of the subplot.
* If False, only select yaxis objects associated with the primary
y-axis of the subplot.
* If None (the default), do not filter yaxis objects based on
a secondary y-axis condition.
To select yaxis objects by secondary y-axis, the Figure must
have been created using plotly.subplots.make_subplots. See
the docstring for the specs argument to make_subplots for more
info on creating subplots with secondary y-axes."""
else:
secondary_y_1 = ""
secondary_y_2 = ""
secondary_y_docstring = ""
buffer.write(
f"""
def select_{plural_name}(
self, selector=None, row=None, col=None{secondary_y_1}):
\"\"\"
Select {singular_name} subplot objects from a particular subplot cell
and/or {singular_name} subplot objects that satisfy custom selection
criteria.
Parameters
----------
selector: dict or None (default None)
Dict to use as selection criteria.
{singular_name} objects will be selected if they contain
properties corresponding to all of the dictionary's keys, with
values that exactly match the supplied values. If None
(the default), all {singular_name} objects are selected.
row, col: int or None (default None)
Subplot row and column index of {singular_name} objects to select.
To select {singular_name} objects by row and column, the Figure
must have been created using plotly.subplots.make_subplots.
If None (the default), all {singular_name} objects are selected.\
{secondary_y_docstring}
Returns
-------
generator
Generator that iterates through all of the {singular_name}
objects that satisfy all of the specified selection criteria
\"\"\"
return self._select_layout_subplots_by_prefix(
'{singular_name}', selector, row, col{secondary_y_2})
def for_each_{singular_name}(
self, fn, selector=None, row=None, col=None{secondary_y_1}):
\"\"\"
Apply a function to all {singular_name} objects that satisfy the
specified selection criteria
Parameters
----------
fn:
Function that inputs a single {singular_name} object.
selector: dict or None (default None)
Dict to use as selection criteria.
{singular_name} objects will be selected if they contain
properties corresponding to all of the dictionary's keys, with
values that exactly match the supplied values. If None
(the default), all {singular_name} objects are selected.
row, col: int or None (default None)
Subplot row and column index of {singular_name} objects to select.
To select {singular_name} objects by row and column, the Figure
must have been created using plotly.subplots.make_subplots.
If None (the default), all {singular_name} objects are selected.\
{secondary_y_docstring}
Returns
-------
self
Returns the Figure object that the method was called on
\"\"\"
for obj in self.select_{plural_name}(
selector=selector, row=row, col=col{secondary_y_2}):
fn(obj)
return self
def update_{plural_name}(
self,
patch=None,
selector=None,
overwrite=False,
row=None, col=None{secondary_y_1},
**kwargs):
\"\"\"
Perform a property update operation on all {singular_name} objects
that satisfy the specified selection criteria
Parameters
----------
patch: dict
Dictionary of property updates to be applied to all
{singular_name} objects that satisfy the selection criteria.
selector: dict or None (default None)
Dict to use as selection criteria.
{singular_name} objects will be selected if they contain
properties corresponding to all of the dictionary's keys, with
values that exactly match the supplied values. If None
(the default), all {singular_name} objects are selected.
overwrite: bool
If True, overwrite existing properties. If False, apply updates
to existing properties recursively, preserving existing
properties that are not specified in the update operation.
row, col: int or None (default None)
Subplot row and column index of {singular_name} objects to select.
To select {singular_name} objects by row and column, the Figure
must have been created using plotly.subplots.make_subplots.
If None (the default), all {singular_name} objects are selected.\
{secondary_y_docstring}
**kwargs
Additional property updates to apply to each selected
{singular_name} object. If a property is specified in
both patch and in **kwargs then the one in **kwargs
takes precedence.
Returns
-------
self
Returns the Figure object that the method was called on
\"\"\"
for obj in self.select_{plural_name}(
selector=selector, row=row, col=col{secondary_y_2}):
obj.update(patch, overwrite=overwrite, **kwargs)
return self"""
)
# update annotations/shapes/images
# --------------------------------
for node in layout_array_nodes:
singular_name = node.plotly_name
plural_name = node.name_property
if singular_name == "image":
# Rename image to layout_image to avoid conflict with an image trace
method_prefix = "layout_"
else:
method_prefix = ""
buffer.write(
f"""
def select_{method_prefix}{plural_name}(
self, selector=None, row=None, col=None, secondary_y=None
):
\"\"\"
Select {plural_name} from a particular subplot cell and/or {plural_name}
that satisfy custom selection criteria.
Parameters
----------
selector: dict or None (default None)
Dict to use as selection criteria.
Annotations will be selected if they contain properties corresponding
to all of the dictionary's keys, with values that exactly match
the supplied values. If None (the default), all {plural_name} are
selected.
row, col: int or None (default None)
Subplot row and column index of {plural_name} to select.
To select {plural_name} by row and column, the Figure must have been
created using plotly.subplots.make_subplots. To select only those
{singular_name} that are in paper coordinates, set row and col to the
string 'paper'. If None (the default), all {plural_name} are selected.
secondary_y: boolean or None (default None)
* If True, only select {plural_name} associated with the secondary
y-axis of the subplot.
* If False, only select {plural_name} associated with the primary
y-axis of the subplot.
* If None (the default), do not filter {plural_name} based on secondary
y-axis.
To select {plural_name} by secondary y-axis, the Figure must have been
created using plotly.subplots.make_subplots. See the docstring
for the specs argument to make_subplots for more info on
creating subplots with secondary y-axes.
Returns
-------
generator
Generator that iterates through all of the {plural_name} that satisfy
all of the specified selection criteria
\"\"\"
return self._select_annotations_like(
"{plural_name}", selector=selector, row=row, col=col, secondary_y=secondary_y
)
def for_each_{method_prefix}{singular_name}(
self, fn, selector=None, row=None, col=None, secondary_y=None
):
\"\"\"
Apply a function to all {plural_name} that satisfy the specified selection
criteria
Parameters
----------
fn:
Function that inputs a single {singular_name} object.
selector: dict or None (default None)
Dict to use as selection criteria.
Traces will be selected if they contain properties corresponding
to all of the dictionary's keys, with values that exactly match
the supplied values. If None (the default), all {plural_name} are
selected.
row, col: int or None (default None)
Subplot row and column index of {plural_name} to select.
To select {plural_name} by row and column, the Figure must have been
created using plotly.subplots.make_subplots. To select only those
{plural_name} that are in paper coordinates, set row and col to the
string 'paper'. If None (the default), all {plural_name} are selected.
secondary_y: boolean or None (default None)
* If True, only select {plural_name} associated with the secondary
y-axis of the subplot.
* If False, only select {plural_name} associated with the primary
y-axis of the subplot.
* If None (the default), do not filter {plural_name} based on secondary
y-axis.
To select {plural_name} by secondary y-axis, the Figure must have been
created using plotly.subplots.make_subplots. See the docstring
for the specs argument to make_subplots for more info on
creating subplots with secondary y-axes.
Returns
-------
self
Returns the Figure object that the method was called on
\"\"\"
for obj in self._select_annotations_like(
prop='{plural_name}',
selector=selector,
row=row,
col=col,
secondary_y=secondary_y,
):
fn(obj)
return self
def update_{method_prefix}{plural_name}(
self,
patch=None,
selector=None,
row=None,
col=None,
secondary_y=None,
**kwargs
):
\"\"\"
Perform a property update operation on all {plural_name} that satisfy the
specified selection criteria
Parameters
----------
patch: dict or None (default None)
Dictionary of property updates to be applied to all {plural_name} that
satisfy the selection criteria.
selector: dict or None (default None)
Dict to use as selection criteria.
Traces will be selected if they contain properties corresponding
to all of the dictionary's keys, with values that exactly match
the supplied values. If None (the default), all {plural_name} are
selected.
row, col: int or None (default None)
Subplot row and column index of {plural_name} to select.
To select {plural_name} by row and column, the Figure must have been
created using plotly.subplots.make_subplots. To select only those
{singular_name} that are in paper coordinates, set row and col to the
string 'paper'. If None (the default), all {plural_name} are selected.
secondary_y: boolean or None (default None)
* If True, only select {plural_name} associated with the secondary
y-axis of the subplot.
* If False, only select {plural_name} associated with the primary
y-axis of the subplot.
* If None (the default), do not filter {plural_name} based on secondary
y-axis.
To select {plural_name} by secondary y-axis, the Figure must have been
created using plotly.subplots.make_subplots. See the docstring
for the specs argument to make_subplots for more info on
creating subplots with secondary y-axes.
**kwargs
Additional property updates to apply to each selected {singular_name}. If
a property is specified in both patch and in **kwargs then the
one in **kwargs takes precedence.
Returns
-------
self
Returns the Figure object that the method was called on
\"\"\"
for obj in self._select_annotations_like(
prop='{plural_name}',
selector=selector,
row=row,
col=col,
secondary_y=secondary_y,
):
obj.update(patch, **kwargs)
return self
"""
)
# Add layout array items
buffer.write(
f"""
def add_{method_prefix}{singular_name}(self"""
)
add_constructor_params(
buffer,
node.child_datatypes,
prepend_extras=["arg"],
append_extras=["row", "col", "secondary_y"],
)
prepend_extras = [
(
"arg",
f"instance of {node.name_datatype_class} or dict with "
"compatible properties",
)
]
append_extras = [
("row", f"Subplot row for {singular_name}"),
("col", f"Subplot column for {singular_name}"),
("secondary_y", f"Whether to add {singular_name} to secondary y-axis"),
]
add_docstring(
buffer,
node,
header=f"Create and add a new {singular_name} to the figure's layout",
prepend_extras=prepend_extras,
append_extras=append_extras,
return_type=fig_classname,
)
# #### Function body ####
buffer.write(
f"""
from plotly.graph_objs import layout as _layout
new_obj = _layout.{node.name_datatype_class}(arg,
"""
)
for i, subtype_node in enumerate(node.child_datatypes):
subtype_prop_name = subtype_node.name_property
buffer.write(
f"""
{subtype_prop_name}={subtype_prop_name},"""
)
buffer.write("""**kwargs)""")
buffer.write(
f"""
return self._add_annotation_like(
'{singular_name}',
'{plural_name}',
new_obj,
row=row,
col=col,
secondary_y=secondary_y,
)"""
)
# Return source string
# --------------------
buffer.write("\n")
return buffer.getvalue() | [
"def",
"build_figure_py",
"(",
"trace_node",
",",
"base_package",
",",
"base_classname",
",",
"fig_classname",
",",
"data_validator",
",",
"layout_validator",
",",
"frame_validator",
",",
"subplot_nodes",
",",
"layout_array_nodes",
",",
")",
":",
"# Initialize source code buffer",
"# -----------------------------",
"buffer",
"=",
"StringIO",
"(",
")",
"# Get list of trace type nodes",
"# ----------------------------",
"trace_nodes",
"=",
"trace_node",
".",
"child_compound_datatypes",
"# Write imports",
"# -------------",
"# ### Import base class ###",
"buffer",
".",
"write",
"(",
"f\"from plotly.{base_package} import {base_classname}\\n\"",
")",
"# Write class definition",
"# ----------------------",
"buffer",
".",
"write",
"(",
"f\"\"\"\n\nclass {fig_classname}({base_classname}):\\n\"\"\"",
")",
"# ### Constructor ###",
"# Build constructor description strings",
"data_description",
"=",
"reindent_validator_description",
"(",
"data_validator",
",",
"8",
")",
"layout_description",
"=",
"reindent_validator_description",
"(",
"layout_validator",
",",
"8",
")",
"frames_description",
"=",
"reindent_validator_description",
"(",
"frame_validator",
",",
"8",
")",
"buffer",
".",
"write",
"(",
"f\"\"\"\n def __init__(self, data=None, layout=None,\n frames=None, skip_invalid=False, **kwargs):\n \\\"\\\"\\\"\n Create a new :class:{fig_classname} instance\n \n Parameters\n ----------\n data\n {data_description}\n \n layout\n {layout_description}\n \n frames\n {frames_description}\n \n skip_invalid: bool\n If True, invalid properties in the figure specification will be\n skipped silently. If False (default) invalid properties in the\n figure specification will result in a ValueError\n\n Raises\n ------\n ValueError\n if a property in the specification of data, layout, or frames\n is invalid AND skip_invalid is False\n \\\"\\\"\\\"\n super({fig_classname} ,self).__init__(data, layout,\n frames, skip_invalid,\n **kwargs)\n \"\"\"",
")",
"# ### add_trace methods for each trace type ###",
"for",
"trace_node",
"in",
"trace_nodes",
":",
"include_secondary_y",
"=",
"bool",
"(",
"[",
"d",
"for",
"d",
"in",
"trace_node",
".",
"child_datatypes",
"if",
"d",
".",
"name_property",
"==",
"\"yaxis\"",
"]",
")",
"# #### Function signature ####",
"buffer",
".",
"write",
"(",
"f\"\"\"\n def add_{trace_node.plotly_name}(self\"\"\"",
")",
"# #### Function params####",
"param_extras",
"=",
"[",
"\"row\"",
",",
"\"col\"",
"]",
"if",
"include_secondary_y",
":",
"param_extras",
".",
"append",
"(",
"\"secondary_y\"",
")",
"add_constructor_params",
"(",
"buffer",
",",
"trace_node",
".",
"child_datatypes",
",",
"append_extras",
"=",
"param_extras",
")",
"# #### Docstring ####",
"header",
"=",
"f\"Add a new {trace_node.name_datatype_class} trace\"",
"doc_extras",
"=",
"[",
"(",
"\"row : int or None (default)\"",
",",
"\"Subplot row index (starting from 1) for the trace to be \"",
"\"added. Only valid if figure was created using \"",
"\"`plotly.tools.make_subplots`\"",
",",
")",
",",
"(",
"\"col : int or None (default)\"",
",",
"\"Subplot col index (starting from 1) for the trace to be \"",
"\"added. Only valid if figure was created using \"",
"\"`plotly.tools.make_subplots`\"",
",",
")",
",",
"]",
"if",
"include_secondary_y",
":",
"doc_extras",
".",
"append",
"(",
"(",
"\"secondary_y: boolean or None (default None)\"",
",",
"\"\"\"\\\n If True, associate this trace with the secondary y-axis of the\n subplot at the specified row and col. Only valid if all of the\n following conditions are satisfied:\n * The figure was created using `plotly.subplots.make_subplots`.\n * The row and col arguments are not None\n * The subplot at the specified row and col has type xy\n (which is the default) and secondary_y True. These\n properties are specified in the specs argument to\n make_subplots. See the make_subplots docstring for more info.\\\n\"\"\"",
",",
")",
")",
"add_docstring",
"(",
"buffer",
",",
"trace_node",
",",
"header",
",",
"append_extras",
"=",
"doc_extras",
",",
"return_type",
"=",
"fig_classname",
",",
")",
"# #### Function body ####",
"buffer",
".",
"write",
"(",
"f\"\"\"\n from plotly.graph_objs import {trace_node.name_datatype_class}\n new_trace = {trace_node.name_datatype_class}(\n \"\"\"",
")",
"for",
"i",
",",
"subtype_node",
"in",
"enumerate",
"(",
"trace_node",
".",
"child_datatypes",
")",
":",
"subtype_prop_name",
"=",
"subtype_node",
".",
"name_property",
"buffer",
".",
"write",
"(",
"f\"\"\"\n {subtype_prop_name}={subtype_prop_name},\"\"\"",
")",
"buffer",
".",
"write",
"(",
"f\"\"\"\n **kwargs)\"\"\"",
")",
"if",
"include_secondary_y",
":",
"secondary_y_kwarg",
"=",
"\", secondary_y=secondary_y\"",
"else",
":",
"secondary_y_kwarg",
"=",
"\"\"",
"buffer",
".",
"write",
"(",
"f\"\"\"\n return self.add_trace(\n new_trace, row=row, col=col{secondary_y_kwarg})\"\"\"",
")",
"# update layout subplots",
"# ----------------------",
"inflect_eng",
"=",
"inflect",
".",
"engine",
"(",
")",
"for",
"subplot_node",
"in",
"subplot_nodes",
":",
"singular_name",
"=",
"subplot_node",
".",
"name_property",
"plural_name",
"=",
"inflect_eng",
".",
"plural_noun",
"(",
"singular_name",
")",
"if",
"singular_name",
"==",
"\"yaxis\"",
":",
"secondary_y_1",
"=",
"\", secondary_y=None\"",
"secondary_y_2",
"=",
"\", secondary_y=secondary_y\"",
"secondary_y_docstring",
"=",
"f\"\"\"\n secondary_y: boolean or None (default None)\n * If True, only select yaxis objects associated with the secondary\n y-axis of the subplot.\n * If False, only select yaxis objects associated with the primary\n y-axis of the subplot.\n * If None (the default), do not filter yaxis objects based on\n a secondary y-axis condition. \n \n To select yaxis objects by secondary y-axis, the Figure must\n have been created using plotly.subplots.make_subplots. See\n the docstring for the specs argument to make_subplots for more\n info on creating subplots with secondary y-axes.\"\"\"",
"else",
":",
"secondary_y_1",
"=",
"\"\"",
"secondary_y_2",
"=",
"\"\"",
"secondary_y_docstring",
"=",
"\"\"",
"buffer",
".",
"write",
"(",
"f\"\"\"\n\n def select_{plural_name}(\n self, selector=None, row=None, col=None{secondary_y_1}):\n \\\"\\\"\\\"\n Select {singular_name} subplot objects from a particular subplot cell\n and/or {singular_name} subplot objects that satisfy custom selection\n criteria.\n\n Parameters\n ----------\n selector: dict or None (default None)\n Dict to use as selection criteria.\n {singular_name} objects will be selected if they contain\n properties corresponding to all of the dictionary's keys, with\n values that exactly match the supplied values. If None\n (the default), all {singular_name} objects are selected.\n row, col: int or None (default None)\n Subplot row and column index of {singular_name} objects to select.\n To select {singular_name} objects by row and column, the Figure\n must have been created using plotly.subplots.make_subplots.\n If None (the default), all {singular_name} objects are selected.\\\n{secondary_y_docstring}\n Returns\n -------\n generator\n Generator that iterates through all of the {singular_name}\n objects that satisfy all of the specified selection criteria\n \\\"\\\"\\\"\n\n return self._select_layout_subplots_by_prefix(\n '{singular_name}', selector, row, col{secondary_y_2})\n\n def for_each_{singular_name}(\n self, fn, selector=None, row=None, col=None{secondary_y_1}):\n \\\"\\\"\\\"\n Apply a function to all {singular_name} objects that satisfy the\n specified selection criteria\n \n Parameters\n ----------\n fn:\n Function that inputs a single {singular_name} object.\n selector: dict or None (default None)\n Dict to use as selection criteria.\n {singular_name} objects will be selected if they contain\n properties corresponding to all of the dictionary's keys, with\n values that exactly match the supplied values. If None\n (the default), all {singular_name} objects are selected.\n row, col: int or None (default None)\n Subplot row and column index of {singular_name} objects to select.\n To select {singular_name} objects by row and column, the Figure\n must have been created using plotly.subplots.make_subplots.\n If None (the default), all {singular_name} objects are selected.\\\n{secondary_y_docstring}\n Returns\n -------\n self\n Returns the Figure object that the method was called on\n \\\"\\\"\\\"\n for obj in self.select_{plural_name}(\n selector=selector, row=row, col=col{secondary_y_2}):\n fn(obj)\n\n return self\n\n def update_{plural_name}(\n self,\n patch=None,\n selector=None,\n overwrite=False,\n row=None, col=None{secondary_y_1},\n **kwargs):\n \\\"\\\"\\\"\n Perform a property update operation on all {singular_name} objects\n that satisfy the specified selection criteria\n \n Parameters\n ----------\n patch: dict\n Dictionary of property updates to be applied to all\n {singular_name} objects that satisfy the selection criteria.\n selector: dict or None (default None)\n Dict to use as selection criteria.\n {singular_name} objects will be selected if they contain\n properties corresponding to all of the dictionary's keys, with\n values that exactly match the supplied values. If None\n (the default), all {singular_name} objects are selected.\n overwrite: bool\n If True, overwrite existing properties. If False, apply updates\n to existing properties recursively, preserving existing\n properties that are not specified in the update operation.\n row, col: int or None (default None)\n Subplot row and column index of {singular_name} objects to select.\n To select {singular_name} objects by row and column, the Figure\n must have been created using plotly.subplots.make_subplots.\n If None (the default), all {singular_name} objects are selected.\\\n{secondary_y_docstring}\n **kwargs\n Additional property updates to apply to each selected\n {singular_name} object. If a property is specified in\n both patch and in **kwargs then the one in **kwargs\n takes precedence.\n Returns\n -------\n self\n Returns the Figure object that the method was called on\n \\\"\\\"\\\"\n for obj in self.select_{plural_name}(\n selector=selector, row=row, col=col{secondary_y_2}):\n obj.update(patch, overwrite=overwrite, **kwargs)\n\n return self\"\"\"",
")",
"# update annotations/shapes/images",
"# --------------------------------",
"for",
"node",
"in",
"layout_array_nodes",
":",
"singular_name",
"=",
"node",
".",
"plotly_name",
"plural_name",
"=",
"node",
".",
"name_property",
"if",
"singular_name",
"==",
"\"image\"",
":",
"# Rename image to layout_image to avoid conflict with an image trace",
"method_prefix",
"=",
"\"layout_\"",
"else",
":",
"method_prefix",
"=",
"\"\"",
"buffer",
".",
"write",
"(",
"f\"\"\"\n def select_{method_prefix}{plural_name}(\n self, selector=None, row=None, col=None, secondary_y=None\n ):\n \\\"\\\"\\\"\n Select {plural_name} from a particular subplot cell and/or {plural_name}\n that satisfy custom selection criteria.\n\n Parameters\n ----------\n selector: dict or None (default None)\n Dict to use as selection criteria.\n Annotations will be selected if they contain properties corresponding\n to all of the dictionary's keys, with values that exactly match\n the supplied values. If None (the default), all {plural_name} are\n selected.\n row, col: int or None (default None)\n Subplot row and column index of {plural_name} to select.\n To select {plural_name} by row and column, the Figure must have been\n created using plotly.subplots.make_subplots. To select only those\n {singular_name} that are in paper coordinates, set row and col to the\n string 'paper'. If None (the default), all {plural_name} are selected.\n secondary_y: boolean or None (default None)\n * If True, only select {plural_name} associated with the secondary\n y-axis of the subplot.\n * If False, only select {plural_name} associated with the primary\n y-axis of the subplot.\n * If None (the default), do not filter {plural_name} based on secondary\n y-axis.\n\n To select {plural_name} by secondary y-axis, the Figure must have been\n created using plotly.subplots.make_subplots. See the docstring\n for the specs argument to make_subplots for more info on\n creating subplots with secondary y-axes.\n Returns\n -------\n generator\n Generator that iterates through all of the {plural_name} that satisfy\n all of the specified selection criteria\n \\\"\\\"\\\"\n return self._select_annotations_like(\n \"{plural_name}\", selector=selector, row=row, col=col, secondary_y=secondary_y\n )\n\n def for_each_{method_prefix}{singular_name}(\n self, fn, selector=None, row=None, col=None, secondary_y=None\n ):\n \\\"\\\"\\\"\n Apply a function to all {plural_name} that satisfy the specified selection\n criteria\n\n Parameters\n ----------\n fn:\n Function that inputs a single {singular_name} object.\n selector: dict or None (default None)\n Dict to use as selection criteria.\n Traces will be selected if they contain properties corresponding\n to all of the dictionary's keys, with values that exactly match\n the supplied values. If None (the default), all {plural_name} are\n selected.\n row, col: int or None (default None)\n Subplot row and column index of {plural_name} to select.\n To select {plural_name} by row and column, the Figure must have been\n created using plotly.subplots.make_subplots. To select only those\n {plural_name} that are in paper coordinates, set row and col to the\n string 'paper'. If None (the default), all {plural_name} are selected.\n secondary_y: boolean or None (default None)\n * If True, only select {plural_name} associated with the secondary\n y-axis of the subplot.\n * If False, only select {plural_name} associated with the primary\n y-axis of the subplot.\n * If None (the default), do not filter {plural_name} based on secondary\n y-axis.\n\n To select {plural_name} by secondary y-axis, the Figure must have been\n created using plotly.subplots.make_subplots. See the docstring\n for the specs argument to make_subplots for more info on\n creating subplots with secondary y-axes.\n Returns\n -------\n self\n Returns the Figure object that the method was called on\n \\\"\\\"\\\"\n for obj in self._select_annotations_like(\n prop='{plural_name}',\n selector=selector,\n row=row,\n col=col,\n secondary_y=secondary_y,\n ):\n fn(obj)\n\n return self\n\n def update_{method_prefix}{plural_name}(\n self,\n patch=None,\n selector=None,\n row=None,\n col=None,\n secondary_y=None,\n **kwargs\n ):\n \\\"\\\"\\\"\n Perform a property update operation on all {plural_name} that satisfy the\n specified selection criteria\n\n Parameters\n ----------\n patch: dict or None (default None)\n Dictionary of property updates to be applied to all {plural_name} that\n satisfy the selection criteria.\n selector: dict or None (default None)\n Dict to use as selection criteria.\n Traces will be selected if they contain properties corresponding\n to all of the dictionary's keys, with values that exactly match\n the supplied values. If None (the default), all {plural_name} are\n selected.\n row, col: int or None (default None)\n Subplot row and column index of {plural_name} to select.\n To select {plural_name} by row and column, the Figure must have been\n created using plotly.subplots.make_subplots. To select only those\n {singular_name} that are in paper coordinates, set row and col to the\n string 'paper'. If None (the default), all {plural_name} are selected.\n secondary_y: boolean or None (default None)\n * If True, only select {plural_name} associated with the secondary\n y-axis of the subplot.\n * If False, only select {plural_name} associated with the primary\n y-axis of the subplot.\n * If None (the default), do not filter {plural_name} based on secondary\n y-axis.\n\n To select {plural_name} by secondary y-axis, the Figure must have been\n created using plotly.subplots.make_subplots. See the docstring\n for the specs argument to make_subplots for more info on\n creating subplots with secondary y-axes.\n **kwargs\n Additional property updates to apply to each selected {singular_name}. If\n a property is specified in both patch and in **kwargs then the\n one in **kwargs takes precedence.\n\n Returns\n -------\n self\n Returns the Figure object that the method was called on\n \\\"\\\"\\\"\n for obj in self._select_annotations_like(\n prop='{plural_name}',\n selector=selector,\n row=row,\n col=col,\n secondary_y=secondary_y,\n ):\n obj.update(patch, **kwargs)\n\n return self\n\"\"\"",
")",
"# Add layout array items",
"buffer",
".",
"write",
"(",
"f\"\"\"\n def add_{method_prefix}{singular_name}(self\"\"\"",
")",
"add_constructor_params",
"(",
"buffer",
",",
"node",
".",
"child_datatypes",
",",
"prepend_extras",
"=",
"[",
"\"arg\"",
"]",
",",
"append_extras",
"=",
"[",
"\"row\"",
",",
"\"col\"",
",",
"\"secondary_y\"",
"]",
",",
")",
"prepend_extras",
"=",
"[",
"(",
"\"arg\"",
",",
"f\"instance of {node.name_datatype_class} or dict with \"",
"\"compatible properties\"",
",",
")",
"]",
"append_extras",
"=",
"[",
"(",
"\"row\"",
",",
"f\"Subplot row for {singular_name}\"",
")",
",",
"(",
"\"col\"",
",",
"f\"Subplot column for {singular_name}\"",
")",
",",
"(",
"\"secondary_y\"",
",",
"f\"Whether to add {singular_name} to secondary y-axis\"",
")",
",",
"]",
"add_docstring",
"(",
"buffer",
",",
"node",
",",
"header",
"=",
"f\"Create and add a new {singular_name} to the figure's layout\"",
",",
"prepend_extras",
"=",
"prepend_extras",
",",
"append_extras",
"=",
"append_extras",
",",
"return_type",
"=",
"fig_classname",
",",
")",
"# #### Function body ####",
"buffer",
".",
"write",
"(",
"f\"\"\"\n from plotly.graph_objs import layout as _layout\n new_obj = _layout.{node.name_datatype_class}(arg,\n \"\"\"",
")",
"for",
"i",
",",
"subtype_node",
"in",
"enumerate",
"(",
"node",
".",
"child_datatypes",
")",
":",
"subtype_prop_name",
"=",
"subtype_node",
".",
"name_property",
"buffer",
".",
"write",
"(",
"f\"\"\"\n {subtype_prop_name}={subtype_prop_name},\"\"\"",
")",
"buffer",
".",
"write",
"(",
"\"\"\"**kwargs)\"\"\"",
")",
"buffer",
".",
"write",
"(",
"f\"\"\"\n return self._add_annotation_like(\n '{singular_name}',\n '{plural_name}',\n new_obj,\n row=row,\n col=col,\n secondary_y=secondary_y,\n )\"\"\"",
")",
"# Return source string",
"# --------------------",
"buffer",
".",
"write",
"(",
"\"\\n\"",
")",
"return",
"buffer",
".",
"getvalue",
"(",
")"
] | [
18,
0
] | [
597,
28
] | python | en | ['en', 'error', 'th'] | False |
|
write_figure_classes | (
outdir,
trace_node,
data_validator,
layout_validator,
frame_validator,
subplot_nodes,
layout_array_nodes,
) |
Construct source code for the Figure and FigureWidget classes and
write to graph_objs/_figure.py and graph_objs/_figurewidget.py
respectively
Parameters
----------
outdir : str
Root outdir in which the graph_objs package should reside
trace_node : PlotlyNode
Root trace node (the node that is the parent of all of the
individual trace nodes like bar, scatter, etc.)
data_validator : BaseDataValidator
DataValidator instance
layout_validator : CompoundValidator
LayoutValidator instance
frame_validator : CompoundArrayValidator
FrameValidator instance
subplot_nodes: list of PlotlyNode
List of names of all of the layout subplot properties
layout_array_nodes: list of PlotlyNode
List of array nodes under layout that can be positioned using xref/yref
Returns
-------
None
|
Construct source code for the Figure and FigureWidget classes and
write to graph_objs/_figure.py and graph_objs/_figurewidget.py
respectively | def write_figure_classes(
outdir,
trace_node,
data_validator,
layout_validator,
frame_validator,
subplot_nodes,
layout_array_nodes,
):
"""
Construct source code for the Figure and FigureWidget classes and
write to graph_objs/_figure.py and graph_objs/_figurewidget.py
respectively
Parameters
----------
outdir : str
Root outdir in which the graph_objs package should reside
trace_node : PlotlyNode
Root trace node (the node that is the parent of all of the
individual trace nodes like bar, scatter, etc.)
data_validator : BaseDataValidator
DataValidator instance
layout_validator : CompoundValidator
LayoutValidator instance
frame_validator : CompoundArrayValidator
FrameValidator instance
subplot_nodes: list of PlotlyNode
List of names of all of the layout subplot properties
layout_array_nodes: list of PlotlyNode
List of array nodes under layout that can be positioned using xref/yref
Returns
-------
None
"""
# Validate inputs
# ---------------
if trace_node.node_path:
raise ValueError(
f"Expected root trace node.\n"
f'Received node with path "{trace_node.path_str}"'
)
# Loop over figure types
# ----------------------
base_figures = [
("basewidget", "BaseFigureWidget", "FigureWidget"),
("basedatatypes", "BaseFigure", "Figure"),
]
for base_package, base_classname, fig_classname in base_figures:
# ### Build figure source code string ###
figure_source = build_figure_py(
trace_node,
base_package,
base_classname,
fig_classname,
data_validator,
layout_validator,
frame_validator,
subplot_nodes,
layout_array_nodes,
)
# ### Format and write to file###
filepath = opath.join(outdir, "graph_objs", f"_{fig_classname.lower()}.py")
write_source_py(figure_source, filepath) | [
"def",
"write_figure_classes",
"(",
"outdir",
",",
"trace_node",
",",
"data_validator",
",",
"layout_validator",
",",
"frame_validator",
",",
"subplot_nodes",
",",
"layout_array_nodes",
",",
")",
":",
"# Validate inputs",
"# ---------------",
"if",
"trace_node",
".",
"node_path",
":",
"raise",
"ValueError",
"(",
"f\"Expected root trace node.\\n\"",
"f'Received node with path \"{trace_node.path_str}\"'",
")",
"# Loop over figure types",
"# ----------------------",
"base_figures",
"=",
"[",
"(",
"\"basewidget\"",
",",
"\"BaseFigureWidget\"",
",",
"\"FigureWidget\"",
")",
",",
"(",
"\"basedatatypes\"",
",",
"\"BaseFigure\"",
",",
"\"Figure\"",
")",
",",
"]",
"for",
"base_package",
",",
"base_classname",
",",
"fig_classname",
"in",
"base_figures",
":",
"# ### Build figure source code string ###",
"figure_source",
"=",
"build_figure_py",
"(",
"trace_node",
",",
"base_package",
",",
"base_classname",
",",
"fig_classname",
",",
"data_validator",
",",
"layout_validator",
",",
"frame_validator",
",",
"subplot_nodes",
",",
"layout_array_nodes",
",",
")",
"# ### Format and write to file###",
"filepath",
"=",
"opath",
".",
"join",
"(",
"outdir",
",",
"\"graph_objs\"",
",",
"f\"_{fig_classname.lower()}.py\"",
")",
"write_source_py",
"(",
"figure_source",
",",
"filepath",
")"
] | [
600,
0
] | [
668,
48
] | python | en | ['en', 'error', 'th'] | False |
ForwardHandler.handle | (self, context: RequestContext, responder: BaseResponder) | Message handler implementation. | Message handler implementation. | async def handle(self, context: RequestContext, responder: BaseResponder):
"""Message handler implementation."""
self._logger.debug("ForwardHandler called with context %s", context)
assert isinstance(context.message, Forward)
if not context.message_receipt.recipient_verkey:
raise HandlerException("Cannot forward message: unknown recipient")
self._logger.info(
"Received forward for: %s", context.message_receipt.recipient_verkey
)
packed = context.message.msg.encode("ascii")
rt_mgr = RoutingManager(context)
target = context.message.to
try:
recipient = await rt_mgr.get_recipient(target)
except RoutingManagerError:
self._logger.exception("Error resolving recipient for forwarded message")
return
# Note: not currently vetting the state of the connection here
self._logger.info(
f"Forwarding message to connection: {recipient.connection_id}"
)
await responder.send(packed, connection_id=recipient.connection_id) | [
"async",
"def",
"handle",
"(",
"self",
",",
"context",
":",
"RequestContext",
",",
"responder",
":",
"BaseResponder",
")",
":",
"self",
".",
"_logger",
".",
"debug",
"(",
"\"ForwardHandler called with context %s\"",
",",
"context",
")",
"assert",
"isinstance",
"(",
"context",
".",
"message",
",",
"Forward",
")",
"if",
"not",
"context",
".",
"message_receipt",
".",
"recipient_verkey",
":",
"raise",
"HandlerException",
"(",
"\"Cannot forward message: unknown recipient\"",
")",
"self",
".",
"_logger",
".",
"info",
"(",
"\"Received forward for: %s\"",
",",
"context",
".",
"message_receipt",
".",
"recipient_verkey",
")",
"packed",
"=",
"context",
".",
"message",
".",
"msg",
".",
"encode",
"(",
"\"ascii\"",
")",
"rt_mgr",
"=",
"RoutingManager",
"(",
"context",
")",
"target",
"=",
"context",
".",
"message",
".",
"to",
"try",
":",
"recipient",
"=",
"await",
"rt_mgr",
".",
"get_recipient",
"(",
"target",
")",
"except",
"RoutingManagerError",
":",
"self",
".",
"_logger",
".",
"exception",
"(",
"\"Error resolving recipient for forwarded message\"",
")",
"return",
"# Note: not currently vetting the state of the connection here",
"self",
".",
"_logger",
".",
"info",
"(",
"f\"Forwarding message to connection: {recipient.connection_id}\"",
")",
"await",
"responder",
".",
"send",
"(",
"packed",
",",
"connection_id",
"=",
"recipient",
".",
"connection_id",
")"
] | [
16,
4
] | [
41,
75
] | python | da | ['da', 'da', 'en'] | True |
parse_webhook_url | (url) | Parse and check validity of Discord webhook URL
by performing a get request and checking existence
of 'id' and 'token' in the JSON response.
| Parse and check validity of Discord webhook URL
by performing a get request and checking existence
of 'id' and 'token' in the JSON response.
| def parse_webhook_url(url):
"""Parse and check validity of Discord webhook URL
by performing a get request and checking existence
of 'id' and 'token' in the JSON response.
"""
if not url:
return None, None
resp = requests.get(url, timeout=10).json()
_id = int(resp["id"])
token = resp["token"]
return _id, token | [
"def",
"parse_webhook_url",
"(",
"url",
")",
":",
"if",
"not",
"url",
":",
"return",
"None",
",",
"None",
"resp",
"=",
"requests",
".",
"get",
"(",
"url",
",",
"timeout",
"=",
"10",
")",
".",
"json",
"(",
")",
"_id",
"=",
"int",
"(",
"resp",
"[",
"\"id\"",
"]",
")",
"token",
"=",
"resp",
"[",
"\"token\"",
"]",
"return",
"_id",
",",
"token"
] | [
53,
0
] | [
63,
21
] | python | en | ['en', 'en', 'en'] | True |
AWSAccess.__init__ | (
self,
resource_name: str = None,
profile_name: str = None,
aws_access_key_id: str = None,
aws_secret_access_key: str = None,
region_name: str = None,
) |
AWSAccess - takes care of basic AWS access (e.g. session, client, resource), getting some basic AWS information, and mock support for testing.
:param resource_name: AWS resource name (e.g. s3, dynamodb, sqs, sns, etc.). Can be None if just testing the connection.
# Provide either: profile name or access key ID/secret access key pair
:param profile_name: AWS profile name
:param aws_access_key_id: AWS access key (required if secret_access_key given)
:param aws_secret_access_key: AWS secret access key (required if access_key_id given)
:param region_name: AWS region (may be optional - see AWS docs)
|
AWSAccess - takes care of basic AWS access (e.g. session, client, resource), getting some basic AWS information, and mock support for testing. | def __init__(
self,
resource_name: str = None,
profile_name: str = None,
aws_access_key_id: str = None,
aws_secret_access_key: str = None,
region_name: str = None,
):
"""
AWSAccess - takes care of basic AWS access (e.g. session, client, resource), getting some basic AWS information, and mock support for testing.
:param resource_name: AWS resource name (e.g. s3, dynamodb, sqs, sns, etc.). Can be None if just testing the connection.
# Provide either: profile name or access key ID/secret access key pair
:param profile_name: AWS profile name
:param aws_access_key_id: AWS access key (required if secret_access_key given)
:param aws_secret_access_key: AWS secret access key (required if access_key_id given)
:param region_name: AWS region (may be optional - see AWS docs)
"""
import boto3 # import here to facilitate mocking
self.resource_name = resource_name
self.profile_name = profile_name
self.aws_access_key_id = aws_access_key_id
self.aws_secret_access_key = aws_secret_access_key
self.region_name = region_name
self._moto_mock = None
self._aws_keys_save = {}
# use keys in AWS config
# https://docs.aws.amazon.com/cli/latest/userguide/cli-config-files.html
kwargs = {}
for k in ["profile_name", "aws_access_key_id", "aws_secret_access_key", "region_name"]:
if getattr(self, k) is not None:
kwargs[k] = getattr(self, k)
self.session = boto3.session.Session(**kwargs)
if is_mock():
# moto mock AWS
for aws_key in ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SECURITY_TOKEN", "AWS_SESSION_TOKEN"]:
self._aws_keys_save[aws_key] = os.environ.get(aws_key) # will be None if not set
os.environ[aws_key] = "testing"
if self.resource_name == "s3":
from moto import mock_s3 as moto_mock
elif self.resource_name == "sns":
from moto import mock_sns as moto_mock
elif self.resource_name == "sqs":
from moto import mock_sqs as moto_mock
elif self.resource_name == "dynamodb":
from moto import mock_dynamodb2 as moto_mock
else:
from moto import mock_iam as moto_mock
self._moto_mock = moto_mock()
self._moto_mock.start()
region = "us-east-1"
self.resource = boto3.resource(self.resource_name, region_name=region) # type: ignore
self.client = boto3.client(self.resource_name, region_name=region) # type: ignore
if self.resource_name == "s3":
self.resource.create_bucket(Bucket="testawsimple") # todo: put this in the test code
elif self.resource_name is None:
# just the session, but not the client or resource
self.client = None
self.resource = None
else:
# real AWS (no mock)
self.client = self.session.client(self.resource_name, config=self._get_config()) # type: ignore
self.resource = self.session.resource(self.resource_name, config=self._get_config()) | [
"def",
"__init__",
"(",
"self",
",",
"resource_name",
":",
"str",
"=",
"None",
",",
"profile_name",
":",
"str",
"=",
"None",
",",
"aws_access_key_id",
":",
"str",
"=",
"None",
",",
"aws_secret_access_key",
":",
"str",
"=",
"None",
",",
"region_name",
":",
"str",
"=",
"None",
",",
")",
":",
"import",
"boto3",
"# import here to facilitate mocking",
"self",
".",
"resource_name",
"=",
"resource_name",
"self",
".",
"profile_name",
"=",
"profile_name",
"self",
".",
"aws_access_key_id",
"=",
"aws_access_key_id",
"self",
".",
"aws_secret_access_key",
"=",
"aws_secret_access_key",
"self",
".",
"region_name",
"=",
"region_name",
"self",
".",
"_moto_mock",
"=",
"None",
"self",
".",
"_aws_keys_save",
"=",
"{",
"}",
"# use keys in AWS config",
"# https://docs.aws.amazon.com/cli/latest/userguide/cli-config-files.html",
"kwargs",
"=",
"{",
"}",
"for",
"k",
"in",
"[",
"\"profile_name\"",
",",
"\"aws_access_key_id\"",
",",
"\"aws_secret_access_key\"",
",",
"\"region_name\"",
"]",
":",
"if",
"getattr",
"(",
"self",
",",
"k",
")",
"is",
"not",
"None",
":",
"kwargs",
"[",
"k",
"]",
"=",
"getattr",
"(",
"self",
",",
"k",
")",
"self",
".",
"session",
"=",
"boto3",
".",
"session",
".",
"Session",
"(",
"*",
"*",
"kwargs",
")",
"if",
"is_mock",
"(",
")",
":",
"# moto mock AWS",
"for",
"aws_key",
"in",
"[",
"\"AWS_ACCESS_KEY_ID\"",
",",
"\"AWS_SECRET_ACCESS_KEY\"",
",",
"\"AWS_SECURITY_TOKEN\"",
",",
"\"AWS_SESSION_TOKEN\"",
"]",
":",
"self",
".",
"_aws_keys_save",
"[",
"aws_key",
"]",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"aws_key",
")",
"# will be None if not set",
"os",
".",
"environ",
"[",
"aws_key",
"]",
"=",
"\"testing\"",
"if",
"self",
".",
"resource_name",
"==",
"\"s3\"",
":",
"from",
"moto",
"import",
"mock_s3",
"as",
"moto_mock",
"elif",
"self",
".",
"resource_name",
"==",
"\"sns\"",
":",
"from",
"moto",
"import",
"mock_sns",
"as",
"moto_mock",
"elif",
"self",
".",
"resource_name",
"==",
"\"sqs\"",
":",
"from",
"moto",
"import",
"mock_sqs",
"as",
"moto_mock",
"elif",
"self",
".",
"resource_name",
"==",
"\"dynamodb\"",
":",
"from",
"moto",
"import",
"mock_dynamodb2",
"as",
"moto_mock",
"else",
":",
"from",
"moto",
"import",
"mock_iam",
"as",
"moto_mock",
"self",
".",
"_moto_mock",
"=",
"moto_mock",
"(",
")",
"self",
".",
"_moto_mock",
".",
"start",
"(",
")",
"region",
"=",
"\"us-east-1\"",
"self",
".",
"resource",
"=",
"boto3",
".",
"resource",
"(",
"self",
".",
"resource_name",
",",
"region_name",
"=",
"region",
")",
"# type: ignore",
"self",
".",
"client",
"=",
"boto3",
".",
"client",
"(",
"self",
".",
"resource_name",
",",
"region_name",
"=",
"region",
")",
"# type: ignore",
"if",
"self",
".",
"resource_name",
"==",
"\"s3\"",
":",
"self",
".",
"resource",
".",
"create_bucket",
"(",
"Bucket",
"=",
"\"testawsimple\"",
")",
"# todo: put this in the test code",
"elif",
"self",
".",
"resource_name",
"is",
"None",
":",
"# just the session, but not the client or resource",
"self",
".",
"client",
"=",
"None",
"self",
".",
"resource",
"=",
"None",
"else",
":",
"# real AWS (no mock)",
"self",
".",
"client",
"=",
"self",
".",
"session",
".",
"client",
"(",
"self",
".",
"resource_name",
",",
"config",
"=",
"self",
".",
"_get_config",
"(",
")",
")",
"# type: ignore",
"self",
".",
"resource",
"=",
"self",
".",
"session",
".",
"resource",
"(",
"self",
".",
"resource_name",
",",
"config",
"=",
"self",
".",
"_get_config",
"(",
")",
")"
] | [
17,
4
] | [
90,
96
] | python | en | ['en', 'error', 'th'] | False |
AWSAccess.get_region | (self) |
Get current selected AWS region
:return: region string
|
Get current selected AWS region | def get_region(self) -> Union[str, None]:
"""
Get current selected AWS region
:return: region string
"""
return self.session.region_name | [
"def",
"get_region",
"(",
"self",
")",
"->",
"Union",
"[",
"str",
",",
"None",
"]",
":",
"return",
"self",
".",
"session",
".",
"region_name"
] | [
99,
4
] | [
105,
39
] | python | en | ['en', 'error', 'th'] | False |
AWSAccess.get_access_key | (self) |
Get current access key string
:return: access key
|
Get current access key string | def get_access_key(self) -> Union[str, None]:
"""
Get current access key string
:return: access key
"""
return self.session.get_credentials().access_key | [
"def",
"get_access_key",
"(",
"self",
")",
"->",
"Union",
"[",
"str",
",",
"None",
"]",
":",
"return",
"self",
".",
"session",
".",
"get_credentials",
"(",
")",
".",
"access_key"
] | [
107,
4
] | [
113,
56
] | python | en | ['en', 'error', 'th'] | False |
AWSAccess.get_account_id | (self) |
Get AWS account ID
:return: account ID
|
Get AWS account ID | def get_account_id(self):
"""
Get AWS account ID
:return: account ID
"""
arn = self.session.resource("iam").CurrentUser().arn
log.info("current user {arn=}")
return arn.split(":")[4] | [
"def",
"get_account_id",
"(",
"self",
")",
":",
"arn",
"=",
"self",
".",
"session",
".",
"resource",
"(",
"\"iam\"",
")",
".",
"CurrentUser",
"(",
")",
".",
"arn",
"log",
".",
"info",
"(",
"\"current user {arn=}\"",
")",
"return",
"arn",
".",
"split",
"(",
"\":\"",
")",
"[",
"4",
"]"
] | [
115,
4
] | [
123,
32
] | python | en | ['en', 'error', 'th'] | False |
AWSAccess.test | (self) |
Basic connection/capability test
:return: True if connection OK
|
Basic connection/capability test | def test(self) -> bool:
"""
Basic connection/capability test
:return: True if connection OK
"""
resources = self.session.get_available_resources() # boto3 will throw an error if there's an issue here
if self.resource_name is not None and self.resource_name not in resources:
raise PermissionError(self.resource_name) # we don't have permission to the specified resource
return True | [
"def",
"test",
"(",
"self",
")",
"->",
"bool",
":",
"resources",
"=",
"self",
".",
"session",
".",
"get_available_resources",
"(",
")",
"# boto3 will throw an error if there's an issue here",
"if",
"self",
".",
"resource_name",
"is",
"not",
"None",
"and",
"self",
".",
"resource_name",
"not",
"in",
"resources",
":",
"raise",
"PermissionError",
"(",
"self",
".",
"resource_name",
")",
"# we don't have permission to the specified resource",
"return",
"True"
] | [
125,
4
] | [
135,
19
] | python | en | ['en', 'error', 'th'] | False |
AWSAccess.is_mocked | (self) |
Return True if currently mocking the AWS interface (e.g. for testing).
:return: True if mocked
|
Return True if currently mocking the AWS interface (e.g. for testing). | def is_mocked(self) -> bool:
"""
Return True if currently mocking the AWS interface (e.g. for testing).
:return: True if mocked
"""
return self._moto_mock is not None | [
"def",
"is_mocked",
"(",
"self",
")",
"->",
"bool",
":",
"return",
"self",
".",
"_moto_mock",
"is",
"not",
"None"
] | [
137,
4
] | [
143,
42
] | python | en | ['en', 'error', 'th'] | False |
init_detector | (config, checkpoint=None, device='cuda:0') | Initialize a detector from config file.
Args:
config (str or :obj:`mmcv.Config`): Config file path or the config
object.
checkpoint (str, optional): Checkpoint path. If left as None, the model
will not load any weights.
Returns:
nn.Module: The constructed detector.
| Initialize a detector from config file. | def init_detector(config, checkpoint=None, device='cuda:0'):
"""Initialize a detector from config file.
Args:
config (str or :obj:`mmcv.Config`): Config file path or the config
object.
checkpoint (str, optional): Checkpoint path. If left as None, the model
will not load any weights.
Returns:
nn.Module: The constructed detector.
"""
if isinstance(config, str):
config = mmcv.Config.fromfile(config)
elif not isinstance(config, mmcv.Config):
raise TypeError('config must be a filename or Config object, '
f'but got {type(config)}')
config.model.pretrained = None
model = build_detector(config.model, test_cfg=config.test_cfg)
if checkpoint is not None:
checkpoint = load_checkpoint(model, checkpoint)
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
warnings.simplefilter('once')
warnings.warn('Class names are not saved in the checkpoint\'s '
'meta data, use COCO classes by default.')
model.CLASSES = get_classes('coco')
model.cfg = config # save the config in the model for convenience
model.to(device)
model.eval()
return model | [
"def",
"init_detector",
"(",
"config",
",",
"checkpoint",
"=",
"None",
",",
"device",
"=",
"'cuda:0'",
")",
":",
"if",
"isinstance",
"(",
"config",
",",
"str",
")",
":",
"config",
"=",
"mmcv",
".",
"Config",
".",
"fromfile",
"(",
"config",
")",
"elif",
"not",
"isinstance",
"(",
"config",
",",
"mmcv",
".",
"Config",
")",
":",
"raise",
"TypeError",
"(",
"'config must be a filename or Config object, '",
"f'but got {type(config)}'",
")",
"config",
".",
"model",
".",
"pretrained",
"=",
"None",
"model",
"=",
"build_detector",
"(",
"config",
".",
"model",
",",
"test_cfg",
"=",
"config",
".",
"test_cfg",
")",
"if",
"checkpoint",
"is",
"not",
"None",
":",
"checkpoint",
"=",
"load_checkpoint",
"(",
"model",
",",
"checkpoint",
")",
"if",
"'CLASSES'",
"in",
"checkpoint",
"[",
"'meta'",
"]",
":",
"model",
".",
"CLASSES",
"=",
"checkpoint",
"[",
"'meta'",
"]",
"[",
"'CLASSES'",
"]",
"else",
":",
"warnings",
".",
"simplefilter",
"(",
"'once'",
")",
"warnings",
".",
"warn",
"(",
"'Class names are not saved in the checkpoint\\'s '",
"'meta data, use COCO classes by default.'",
")",
"model",
".",
"CLASSES",
"=",
"get_classes",
"(",
"'coco'",
")",
"model",
".",
"cfg",
"=",
"config",
"# save the config in the model for convenience",
"model",
".",
"to",
"(",
"device",
")",
"model",
".",
"eval",
"(",
")",
"return",
"model"
] | [
14,
0
] | [
45,
16
] | python | en | ['en', 'en', 'en'] | True |
inference_detector | (model, img) | Inference image(s) with the detector.
Args:
model (nn.Module): The loaded detector.
imgs (str/ndarray or list[str/ndarray]): Either image files or loaded
images.
Returns:
If imgs is a str, a generator will be returned, otherwise return the
detection results directly.
| Inference image(s) with the detector. | def inference_detector(model, img):
"""Inference image(s) with the detector.
Args:
model (nn.Module): The loaded detector.
imgs (str/ndarray or list[str/ndarray]): Either image files or loaded
images.
Returns:
If imgs is a str, a generator will be returned, otherwise return the
detection results directly.
"""
cfg = model.cfg
device = next(model.parameters()).device # model device
# build the data pipeline
test_pipeline = [LoadImage()] + cfg.data.test.pipeline[1:]
test_pipeline = Compose(test_pipeline)
# prepare data
data = dict(img=img)
data = test_pipeline(data)
data = collate([data], samples_per_gpu=1)
if next(model.parameters()).is_cuda:
# scatter to specified GPU
data = scatter(data, [device])[0]
else:
# Use torchvision ops for CPU mode instead
for m in model.modules():
if isinstance(m, (RoIPool, RoIAlign)):
if not m.aligned:
# aligned=False is not implemented on CPU
# set use_torchvision on-the-fly
m.use_torchvision = True
warnings.warn('We set use_torchvision=True in CPU mode.')
# just get the actual data from DataContainer
data['img_metas'] = data['img_metas'][0].data
# forward the model
with torch.no_grad():
result = model(return_loss=False, rescale=True, **data)
return result | [
"def",
"inference_detector",
"(",
"model",
",",
"img",
")",
":",
"cfg",
"=",
"model",
".",
"cfg",
"device",
"=",
"next",
"(",
"model",
".",
"parameters",
"(",
")",
")",
".",
"device",
"# model device",
"# build the data pipeline",
"test_pipeline",
"=",
"[",
"LoadImage",
"(",
")",
"]",
"+",
"cfg",
".",
"data",
".",
"test",
".",
"pipeline",
"[",
"1",
":",
"]",
"test_pipeline",
"=",
"Compose",
"(",
"test_pipeline",
")",
"# prepare data",
"data",
"=",
"dict",
"(",
"img",
"=",
"img",
")",
"data",
"=",
"test_pipeline",
"(",
"data",
")",
"data",
"=",
"collate",
"(",
"[",
"data",
"]",
",",
"samples_per_gpu",
"=",
"1",
")",
"if",
"next",
"(",
"model",
".",
"parameters",
"(",
")",
")",
".",
"is_cuda",
":",
"# scatter to specified GPU",
"data",
"=",
"scatter",
"(",
"data",
",",
"[",
"device",
"]",
")",
"[",
"0",
"]",
"else",
":",
"# Use torchvision ops for CPU mode instead",
"for",
"m",
"in",
"model",
".",
"modules",
"(",
")",
":",
"if",
"isinstance",
"(",
"m",
",",
"(",
"RoIPool",
",",
"RoIAlign",
")",
")",
":",
"if",
"not",
"m",
".",
"aligned",
":",
"# aligned=False is not implemented on CPU",
"# set use_torchvision on-the-fly",
"m",
".",
"use_torchvision",
"=",
"True",
"warnings",
".",
"warn",
"(",
"'We set use_torchvision=True in CPU mode.'",
")",
"# just get the actual data from DataContainer",
"data",
"[",
"'img_metas'",
"]",
"=",
"data",
"[",
"'img_metas'",
"]",
"[",
"0",
"]",
".",
"data",
"# forward the model",
"with",
"torch",
".",
"no_grad",
"(",
")",
":",
"result",
"=",
"model",
"(",
"return_loss",
"=",
"False",
",",
"rescale",
"=",
"True",
",",
"*",
"*",
"data",
")",
"return",
"result"
] | [
75,
0
] | [
114,
17
] | python | en | ['en', 'en', 'en'] | True |
async_inference_detector | (model, img) | Async inference image(s) with the detector.
Args:
model (nn.Module): The loaded detector.
imgs (str/ndarray or list[str/ndarray]): Either image files or loaded
images.
Returns:
Awaitable detection results.
| Async inference image(s) with the detector. | async def async_inference_detector(model, img):
"""Async inference image(s) with the detector.
Args:
model (nn.Module): The loaded detector.
imgs (str/ndarray or list[str/ndarray]): Either image files or loaded
images.
Returns:
Awaitable detection results.
"""
cfg = model.cfg
device = next(model.parameters()).device # model device
# build the data pipeline
test_pipeline = [LoadImage()] + cfg.data.test.pipeline[1:]
test_pipeline = Compose(test_pipeline)
# prepare data
data = dict(img=img)
data = test_pipeline(data)
data = scatter(collate([data], samples_per_gpu=1), [device])[0]
# We don't restore `torch.is_grad_enabled()` value during concurrent
# inference since execution can overlap
torch.set_grad_enabled(False)
result = await model.aforward_test(rescale=True, **data)
return result | [
"async",
"def",
"async_inference_detector",
"(",
"model",
",",
"img",
")",
":",
"cfg",
"=",
"model",
".",
"cfg",
"device",
"=",
"next",
"(",
"model",
".",
"parameters",
"(",
")",
")",
".",
"device",
"# model device",
"# build the data pipeline",
"test_pipeline",
"=",
"[",
"LoadImage",
"(",
")",
"]",
"+",
"cfg",
".",
"data",
".",
"test",
".",
"pipeline",
"[",
"1",
":",
"]",
"test_pipeline",
"=",
"Compose",
"(",
"test_pipeline",
")",
"# prepare data",
"data",
"=",
"dict",
"(",
"img",
"=",
"img",
")",
"data",
"=",
"test_pipeline",
"(",
"data",
")",
"data",
"=",
"scatter",
"(",
"collate",
"(",
"[",
"data",
"]",
",",
"samples_per_gpu",
"=",
"1",
")",
",",
"[",
"device",
"]",
")",
"[",
"0",
"]",
"# We don't restore `torch.is_grad_enabled()` value during concurrent",
"# inference since execution can overlap",
"torch",
".",
"set_grad_enabled",
"(",
"False",
")",
"result",
"=",
"await",
"model",
".",
"aforward_test",
"(",
"rescale",
"=",
"True",
",",
"*",
"*",
"data",
")",
"return",
"result"
] | [
117,
0
] | [
142,
17
] | python | en | ['en', 'en', 'en'] | True |
show_result_pyplot | (model, img, result, score_thr=0.3, fig_size=(15, 10)) | Visualize the detection results on the image.
Args:
model (nn.Module): The loaded detector.
img (str or np.ndarray): Image filename or loaded image.
result (tuple[list] or list): The detection result, can be either
(bbox, segm) or just bbox.
score_thr (float): The threshold to visualize the bboxes and masks.
fig_size (tuple): Figure size of the pyplot figure.
| Visualize the detection results on the image. | def show_result_pyplot(model, img, result, score_thr=0.3, fig_size=(15, 10)):
"""Visualize the detection results on the image.
Args:
model (nn.Module): The loaded detector.
img (str or np.ndarray): Image filename or loaded image.
result (tuple[list] or list): The detection result, can be either
(bbox, segm) or just bbox.
score_thr (float): The threshold to visualize the bboxes and masks.
fig_size (tuple): Figure size of the pyplot figure.
"""
if hasattr(model, 'module'):
model = model.module
img = model.show_result(img, result, score_thr=score_thr, show=False)
plt.figure(figsize=fig_size)
plt.imshow(mmcv.bgr2rgb(img))
plt.show() | [
"def",
"show_result_pyplot",
"(",
"model",
",",
"img",
",",
"result",
",",
"score_thr",
"=",
"0.3",
",",
"fig_size",
"=",
"(",
"15",
",",
"10",
")",
")",
":",
"if",
"hasattr",
"(",
"model",
",",
"'module'",
")",
":",
"model",
"=",
"model",
".",
"module",
"img",
"=",
"model",
".",
"show_result",
"(",
"img",
",",
"result",
",",
"score_thr",
"=",
"score_thr",
",",
"show",
"=",
"False",
")",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"fig_size",
")",
"plt",
".",
"imshow",
"(",
"mmcv",
".",
"bgr2rgb",
"(",
"img",
")",
")",
"plt",
".",
"show",
"(",
")"
] | [
145,
0
] | [
161,
14
] | python | en | ['en', 'en', 'en'] | True |
LoadImage.__call__ | (self, results) | Call function to load images into results.
Args:
results (dict): A result dict contains the file name
of the image to be read.
Returns:
dict: ``results`` will be returned containing loaded image.
| Call function to load images into results. | def __call__(self, results):
"""Call function to load images into results.
Args:
results (dict): A result dict contains the file name
of the image to be read.
Returns:
dict: ``results`` will be returned containing loaded image.
"""
if isinstance(results['img'], str):
results['filename'] = results['img']
results['ori_filename'] = results['img']
else:
results['filename'] = None
results['ori_filename'] = None
img = mmcv.imread(results['img'])
results['img'] = img
results['img_fields'] = ['img']
results['img_shape'] = img.shape
results['ori_shape'] = img.shape
return results | [
"def",
"__call__",
"(",
"self",
",",
"results",
")",
":",
"if",
"isinstance",
"(",
"results",
"[",
"'img'",
"]",
",",
"str",
")",
":",
"results",
"[",
"'filename'",
"]",
"=",
"results",
"[",
"'img'",
"]",
"results",
"[",
"'ori_filename'",
"]",
"=",
"results",
"[",
"'img'",
"]",
"else",
":",
"results",
"[",
"'filename'",
"]",
"=",
"None",
"results",
"[",
"'ori_filename'",
"]",
"=",
"None",
"img",
"=",
"mmcv",
".",
"imread",
"(",
"results",
"[",
"'img'",
"]",
")",
"results",
"[",
"'img'",
"]",
"=",
"img",
"results",
"[",
"'img_fields'",
"]",
"=",
"[",
"'img'",
"]",
"results",
"[",
"'img_shape'",
"]",
"=",
"img",
".",
"shape",
"results",
"[",
"'ori_shape'",
"]",
"=",
"img",
".",
"shape",
"return",
"results"
] | [
51,
4
] | [
72,
22
] | python | en | ['en', 'en', 'en'] | True |
DatatypeHelper.fold | (cls, datatype: str) |
Extract the fold part of the datatype.
:param datatype:
parlai datatype
:return: the fold
>>> DatatypeHelper.fold("train:ordered")
... "train"
|
Extract the fold part of the datatype. | def fold(cls, datatype: str) -> str:
"""
Extract the fold part of the datatype.
:param datatype:
parlai datatype
:return: the fold
>>> DatatypeHelper.fold("train:ordered")
... "train"
"""
return datatype.split(':')[0] | [
"def",
"fold",
"(",
"cls",
",",
"datatype",
":",
"str",
")",
"->",
"str",
":",
"return",
"datatype",
".",
"split",
"(",
"':'",
")",
"[",
"0",
"]"
] | [
16,
4
] | [
28,
37
] | python | en | ['en', 'error', 'th'] | False |
DatatypeHelper.should_cycle | (cls, datatype: str) |
Return whether we should cycle data based on the datatype.
:param datatype:
parlai datatype
:return should_cycle:
given datatype, return whether we should cycle
|
Return whether we should cycle data based on the datatype. | def should_cycle(cls, datatype: str) -> bool:
"""
Return whether we should cycle data based on the datatype.
:param datatype:
parlai datatype
:return should_cycle:
given datatype, return whether we should cycle
"""
assert datatype is not None, 'datatype must not be none'
return (
'train' in datatype
and 'evalmode' not in datatype
and 'ordered' not in datatype
) | [
"def",
"should_cycle",
"(",
"cls",
",",
"datatype",
":",
"str",
")",
"->",
"bool",
":",
"assert",
"datatype",
"is",
"not",
"None",
",",
"'datatype must not be none'",
"return",
"(",
"'train'",
"in",
"datatype",
"and",
"'evalmode'",
"not",
"in",
"datatype",
"and",
"'ordered'",
"not",
"in",
"datatype",
")"
] | [
31,
4
] | [
46,
9
] | python | en | ['en', 'error', 'th'] | False |
DatatypeHelper.should_shuffle | (cls, datatype: str) |
Return whether we should shuffle data based on the datatype.
:param datatype:
parlai datatype
:return should_shuffle:
given datatype, return whether we should shuffle
|
Return whether we should shuffle data based on the datatype. | def should_shuffle(cls, datatype: str) -> bool:
"""
Return whether we should shuffle data based on the datatype.
:param datatype:
parlai datatype
:return should_shuffle:
given datatype, return whether we should shuffle
"""
assert datatype is not None, 'datatype must not be none'
return (
'train' in datatype
and 'evalmode' not in datatype
and 'ordered' not in datatype
and 'stream' not in datatype
) | [
"def",
"should_shuffle",
"(",
"cls",
",",
"datatype",
":",
"str",
")",
"->",
"bool",
":",
"assert",
"datatype",
"is",
"not",
"None",
",",
"'datatype must not be none'",
"return",
"(",
"'train'",
"in",
"datatype",
"and",
"'evalmode'",
"not",
"in",
"datatype",
"and",
"'ordered'",
"not",
"in",
"datatype",
"and",
"'stream'",
"not",
"in",
"datatype",
")"
] | [
49,
4
] | [
65,
9
] | python | en | ['en', 'error', 'th'] | False |
DatatypeHelper.is_training | (cls, datatype: str) |
Return whether we should return eval_labels or labels.
:param datatype:
parlai datatype
:return is_training:
given datatype, return whether we should return eval_labels or labels
|
Return whether we should return eval_labels or labels. | def is_training(cls, datatype: str) -> bool:
"""
Return whether we should return eval_labels or labels.
:param datatype:
parlai datatype
:return is_training:
given datatype, return whether we should return eval_labels or labels
"""
assert datatype is not None, 'datatype must not be none'
return 'train' in datatype and 'evalmode' not in datatype | [
"def",
"is_training",
"(",
"cls",
",",
"datatype",
":",
"str",
")",
"->",
"bool",
":",
"assert",
"datatype",
"is",
"not",
"None",
",",
"'datatype must not be none'",
"return",
"'train'",
"in",
"datatype",
"and",
"'evalmode'",
"not",
"in",
"datatype"
] | [
68,
4
] | [
79,
65
] | python | en | ['en', 'error', 'th'] | False |
Line.autocolorscale | (self) |
Determines whether the colorscale is a default palette
(`autocolorscale: true`) or the palette determined by
`marker.line.colorscale`. Has an effect only if in
`marker.line.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.
The 'autocolorscale' property must be specified as a bool
(either True, or False)
Returns
-------
bool
|
Determines whether the colorscale is a default palette
(`autocolorscale: true`) or the palette determined by
`marker.line.colorscale`. Has an effect only if in
`marker.line.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.
The 'autocolorscale' property must be specified as a bool
(either True, or False) | def autocolorscale(self):
"""
Determines whether the colorscale is a default palette
(`autocolorscale: true`) or the palette determined by
`marker.line.colorscale`. Has an effect only if in
`marker.line.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.
The 'autocolorscale' property must be specified as a bool
(either True, or False)
Returns
-------
bool
"""
return self["autocolorscale"] | [
"def",
"autocolorscale",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"autocolorscale\"",
"]"
] | [
28,
4
] | [
45,
37
] | python | en | ['en', 'error', 'th'] | False |
Line.cauto | (self) |
Determines whether or not the color domain is computed with
respect to the input data (here in `marker.line.color`) or the
bounds set in `marker.line.cmin` and `marker.line.cmax` Has an
effect only if in `marker.line.color`is set to a numerical
array. Defaults to `false` when `marker.line.cmin` and
`marker.line.cmax` are set by the user.
The 'cauto' property must be specified as a bool
(either True, or False)
Returns
-------
bool
|
Determines whether or not the color domain is computed with
respect to the input data (here in `marker.line.color`) or the
bounds set in `marker.line.cmin` and `marker.line.cmax` Has an
effect only if in `marker.line.color`is set to a numerical
array. Defaults to `false` when `marker.line.cmin` and
`marker.line.cmax` are set by the user.
The 'cauto' property must be specified as a bool
(either True, or False) | def cauto(self):
"""
Determines whether or not the color domain is computed with
respect to the input data (here in `marker.line.color`) or the
bounds set in `marker.line.cmin` and `marker.line.cmax` Has an
effect only if in `marker.line.color`is set to a numerical
array. Defaults to `false` when `marker.line.cmin` and
`marker.line.cmax` are set by the user.
The 'cauto' property must be specified as a bool
(either True, or False)
Returns
-------
bool
"""
return self["cauto"] | [
"def",
"cauto",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"cauto\"",
"]"
] | [
54,
4
] | [
70,
28
] | python | en | ['en', 'error', 'th'] | False |
Line.cmax | (self) |
Sets the upper bound of the color domain. Has an effect only if
in `marker.line.color`is set to a numerical array. Value should
have the same units as in `marker.line.color` and if set,
`marker.line.cmin` must be set as well.
The 'cmax' property is a number and may be specified as:
- An int or float
Returns
-------
int|float
|
Sets the upper bound of the color domain. Has an effect only if
in `marker.line.color`is set to a numerical array. Value should
have the same units as in `marker.line.color` and if set,
`marker.line.cmin` must be set as well.
The 'cmax' property is a number and may be specified as:
- An int or float | def cmax(self):
"""
Sets the upper bound of the color domain. Has an effect only if
in `marker.line.color`is set to a numerical array. Value should
have the same units as in `marker.line.color` and if set,
`marker.line.cmin` must be set as well.
The 'cmax' property is a number and may be specified as:
- An int or float
Returns
-------
int|float
"""
return self["cmax"] | [
"def",
"cmax",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"cmax\"",
"]"
] | [
79,
4
] | [
93,
27
] | python | en | ['en', 'error', 'th'] | False |
Line.cmid | (self) |
Sets the mid-point of the color domain by scaling
`marker.line.cmin` and/or `marker.line.cmax` to be equidistant
to this point. Has an effect only if in `marker.line.color`is
set to a numerical array. Value should have the same units as
in `marker.line.color`. Has no effect when `marker.line.cauto`
is `false`.
The 'cmid' property is a number and may be specified as:
- An int or float
Returns
-------
int|float
|
Sets the mid-point of the color domain by scaling
`marker.line.cmin` and/or `marker.line.cmax` to be equidistant
to this point. Has an effect only if in `marker.line.color`is
set to a numerical array. Value should have the same units as
in `marker.line.color`. Has no effect when `marker.line.cauto`
is `false`.
The 'cmid' property is a number and may be specified as:
- An int or float | def cmid(self):
"""
Sets the mid-point of the color domain by scaling
`marker.line.cmin` and/or `marker.line.cmax` to be equidistant
to this point. Has an effect only if in `marker.line.color`is
set to a numerical array. Value should have the same units as
in `marker.line.color`. Has no effect when `marker.line.cauto`
is `false`.
The 'cmid' property is a number and may be specified as:
- An int or float
Returns
-------
int|float
"""
return self["cmid"] | [
"def",
"cmid",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"cmid\"",
"]"
] | [
102,
4
] | [
118,
27
] | python | en | ['en', 'error', 'th'] | False |
Line.cmin | (self) |
Sets the lower bound of the color domain. Has an effect only if
in `marker.line.color`is set to a numerical array. Value should
have the same units as in `marker.line.color` and if set,
`marker.line.cmax` must be set as well.
The 'cmin' property is a number and may be specified as:
- An int or float
Returns
-------
int|float
|
Sets the lower bound of the color domain. Has an effect only if
in `marker.line.color`is set to a numerical array. Value should
have the same units as in `marker.line.color` and if set,
`marker.line.cmax` must be set as well.
The 'cmin' property is a number and may be specified as:
- An int or float | def cmin(self):
"""
Sets the lower bound of the color domain. Has an effect only if
in `marker.line.color`is set to a numerical array. Value should
have the same units as in `marker.line.color` and if set,
`marker.line.cmax` must be set as well.
The 'cmin' property is a number and may be specified as:
- An int or float
Returns
-------
int|float
"""
return self["cmin"] | [
"def",
"cmin",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"cmin\"",
"]"
] | [
127,
4
] | [
141,
27
] | python | en | ['en', 'error', 'th'] | False |
Line.color | (self) |
Sets themarker.linecolor. 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.line.cmin` and `marker.line.cmax` if set.
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
- A number that will be interpreted as a color
according to scattergeo.marker.line.colorscale
- A list or array of any of the above
Returns
-------
str|numpy.ndarray
|
Sets themarker.linecolor. 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.line.cmin` and `marker.line.cmax` if set.
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
- A number that will be interpreted as a color
according to scattergeo.marker.line.colorscale
- A list or array of any of the above | def color(self):
"""
Sets themarker.linecolor. 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.line.cmin` and `marker.line.cmax` if set.
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
- A number that will be interpreted as a color
according to scattergeo.marker.line.colorscale
- A list or array of any of the above
Returns
-------
str|numpy.ndarray
"""
return self["color"] | [
"def",
"color",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"color\"",
"]"
] | [
150,
4
] | [
206,
28
] | python | en | ['en', 'error', 'th'] | False |
Line.coloraxis | (self) |
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.
The 'coloraxis' property is an identifier of a particular
subplot, of type 'coloraxis', that may be specified as the string 'coloraxis'
optionally followed by an integer >= 1
(e.g. 'coloraxis', 'coloraxis1', 'coloraxis2', 'coloraxis3', etc.)
Returns
-------
str
|
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.
The 'coloraxis' property is an identifier of a particular
subplot, of type 'coloraxis', that may be specified as the string 'coloraxis'
optionally followed by an integer >= 1
(e.g. 'coloraxis', 'coloraxis1', 'coloraxis2', 'coloraxis3', etc.) | def coloraxis(self):
"""
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.
The 'coloraxis' property is an identifier of a particular
subplot, of type 'coloraxis', that may be specified as the string 'coloraxis'
optionally followed by an integer >= 1
(e.g. 'coloraxis', 'coloraxis1', 'coloraxis2', 'coloraxis3', etc.)
Returns
-------
str
"""
return self["coloraxis"] | [
"def",
"coloraxis",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"coloraxis\"",
"]"
] | [
215,
4
] | [
233,
32
] | python | en | ['en', 'error', 'th'] | False |
Line.colorscale | (self) |
Sets the colorscale. Has an effect only if in
`marker.line.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.line.cmin` and `marker.line.cmax`.
Alternatively, `colorscale` may be a palette name string of the
following list: Greys,YlGnBu,Greens,YlOrRd,Bluered,RdBu,Reds,Bl
ues,Picnic,Rainbow,Portland,Jet,Hot,Blackbody,Earth,Electric,Vi
ridis,Cividis.
The 'colorscale' property is a colorscale and may be
specified as:
- A list of colors that will be spaced evenly to create the colorscale.
Many predefined colorscale lists are included in the sequential, diverging,
and cyclical modules in the plotly.colors package.
- A list of 2-element lists where the first element is the
normalized color level value (starting at 0 and ending at 1),
and the second item is a valid color string.
(e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']])
- One of the following named colorscales:
['aggrnyl', 'agsunset', 'algae', 'amp', 'armyrose', 'balance',
'blackbody', 'bluered', 'blues', 'blugrn', 'bluyl', 'brbg',
'brwnyl', 'bugn', 'bupu', 'burg', 'burgyl', 'cividis', 'curl',
'darkmint', 'deep', 'delta', 'dense', 'earth', 'edge', 'electric',
'emrld', 'fall', 'geyser', 'gnbu', 'gray', 'greens', 'greys',
'haline', 'hot', 'hsv', 'ice', 'icefire', 'inferno', 'jet',
'magenta', 'magma', 'matter', 'mint', 'mrybm', 'mygbm', 'oranges',
'orrd', 'oryel', 'peach', 'phase', 'picnic', 'pinkyl', 'piyg',
'plasma', 'plotly3', 'portland', 'prgn', 'pubu', 'pubugn', 'puor',
'purd', 'purp', 'purples', 'purpor', 'rainbow', 'rdbu', 'rdgy',
'rdpu', 'rdylbu', 'rdylgn', 'redor', 'reds', 'solar', 'spectral',
'speed', 'sunset', 'sunsetdark', 'teal', 'tealgrn', 'tealrose',
'tempo', 'temps', 'thermal', 'tropic', 'turbid', 'twilight',
'viridis', 'ylgn', 'ylgnbu', 'ylorbr', 'ylorrd'].
Appending '_r' to a named colorscale reverses it.
Returns
-------
str
|
Sets the colorscale. Has an effect only if in
`marker.line.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.line.cmin` and `marker.line.cmax`.
Alternatively, `colorscale` may be a palette name string of the
following list: Greys,YlGnBu,Greens,YlOrRd,Bluered,RdBu,Reds,Bl
ues,Picnic,Rainbow,Portland,Jet,Hot,Blackbody,Earth,Electric,Vi
ridis,Cividis.
The 'colorscale' property is a colorscale and may be
specified as:
- A list of colors that will be spaced evenly to create the colorscale.
Many predefined colorscale lists are included in the sequential, diverging,
and cyclical modules in the plotly.colors package.
- A list of 2-element lists where the first element is the
normalized color level value (starting at 0 and ending at 1),
and the second item is a valid color string.
(e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']])
- One of the following named colorscales:
['aggrnyl', 'agsunset', 'algae', 'amp', 'armyrose', 'balance',
'blackbody', 'bluered', 'blues', 'blugrn', 'bluyl', 'brbg',
'brwnyl', 'bugn', 'bupu', 'burg', 'burgyl', 'cividis', 'curl',
'darkmint', 'deep', 'delta', 'dense', 'earth', 'edge', 'electric',
'emrld', 'fall', 'geyser', 'gnbu', 'gray', 'greens', 'greys',
'haline', 'hot', 'hsv', 'ice', 'icefire', 'inferno', 'jet',
'magenta', 'magma', 'matter', 'mint', 'mrybm', 'mygbm', 'oranges',
'orrd', 'oryel', 'peach', 'phase', 'picnic', 'pinkyl', 'piyg',
'plasma', 'plotly3', 'portland', 'prgn', 'pubu', 'pubugn', 'puor',
'purd', 'purp', 'purples', 'purpor', 'rainbow', 'rdbu', 'rdgy',
'rdpu', 'rdylbu', 'rdylgn', 'redor', 'reds', 'solar', 'spectral',
'speed', 'sunset', 'sunsetdark', 'teal', 'tealgrn', 'tealrose',
'tempo', 'temps', 'thermal', 'tropic', 'turbid', 'twilight',
'viridis', 'ylgn', 'ylgnbu', 'ylorbr', 'ylorrd'].
Appending '_r' to a named colorscale reverses it. | def colorscale(self):
"""
Sets the colorscale. Has an effect only if in
`marker.line.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.line.cmin` and `marker.line.cmax`.
Alternatively, `colorscale` may be a palette name string of the
following list: Greys,YlGnBu,Greens,YlOrRd,Bluered,RdBu,Reds,Bl
ues,Picnic,Rainbow,Portland,Jet,Hot,Blackbody,Earth,Electric,Vi
ridis,Cividis.
The 'colorscale' property is a colorscale and may be
specified as:
- A list of colors that will be spaced evenly to create the colorscale.
Many predefined colorscale lists are included in the sequential, diverging,
and cyclical modules in the plotly.colors package.
- A list of 2-element lists where the first element is the
normalized color level value (starting at 0 and ending at 1),
and the second item is a valid color string.
(e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']])
- One of the following named colorscales:
['aggrnyl', 'agsunset', 'algae', 'amp', 'armyrose', 'balance',
'blackbody', 'bluered', 'blues', 'blugrn', 'bluyl', 'brbg',
'brwnyl', 'bugn', 'bupu', 'burg', 'burgyl', 'cividis', 'curl',
'darkmint', 'deep', 'delta', 'dense', 'earth', 'edge', 'electric',
'emrld', 'fall', 'geyser', 'gnbu', 'gray', 'greens', 'greys',
'haline', 'hot', 'hsv', 'ice', 'icefire', 'inferno', 'jet',
'magenta', 'magma', 'matter', 'mint', 'mrybm', 'mygbm', 'oranges',
'orrd', 'oryel', 'peach', 'phase', 'picnic', 'pinkyl', 'piyg',
'plasma', 'plotly3', 'portland', 'prgn', 'pubu', 'pubugn', 'puor',
'purd', 'purp', 'purples', 'purpor', 'rainbow', 'rdbu', 'rdgy',
'rdpu', 'rdylbu', 'rdylgn', 'redor', 'reds', 'solar', 'spectral',
'speed', 'sunset', 'sunsetdark', 'teal', 'tealgrn', 'tealrose',
'tempo', 'temps', 'thermal', 'tropic', 'turbid', 'twilight',
'viridis', 'ylgn', 'ylgnbu', 'ylorbr', 'ylorrd'].
Appending '_r' to a named colorscale reverses it.
Returns
-------
str
"""
return self["colorscale"] | [
"def",
"colorscale",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"colorscale\"",
"]"
] | [
242,
4
] | [
287,
33
] | python | en | ['en', 'error', 'th'] | False |
Line.colorsrc | (self) |
Sets the source reference on Chart Studio Cloud for color .
The 'colorsrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
|
Sets the source reference on Chart Studio Cloud for color .
The 'colorsrc' property must be specified as a string or
as a plotly.grid_objs.Column object | def colorsrc(self):
"""
Sets the source reference on Chart Studio Cloud for color .
The 'colorsrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
"""
return self["colorsrc"] | [
"def",
"colorsrc",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"colorsrc\"",
"]"
] | [
296,
4
] | [
307,
31
] | python | en | ['en', 'error', 'th'] | False |
Line.reversescale | (self) |
Reverses the color mapping if true. Has an effect only if in
`marker.line.color`is set to a numerical array. If true,
`marker.line.cmin` will correspond to the last color in the
array and `marker.line.cmax` will correspond to the first
color.
The 'reversescale' property must be specified as a bool
(either True, or False)
Returns
-------
bool
|
Reverses the color mapping if true. Has an effect only if in
`marker.line.color`is set to a numerical array. If true,
`marker.line.cmin` will correspond to the last color in the
array and `marker.line.cmax` will correspond to the first
color.
The 'reversescale' property must be specified as a bool
(either True, or False) | def reversescale(self):
"""
Reverses the color mapping if true. Has an effect only if in
`marker.line.color`is set to a numerical array. If true,
`marker.line.cmin` will correspond to the last color in the
array and `marker.line.cmax` will correspond to the first
color.
The 'reversescale' property must be specified as a bool
(either True, or False)
Returns
-------
bool
"""
return self["reversescale"] | [
"def",
"reversescale",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"reversescale\"",
"]"
] | [
316,
4
] | [
331,
35
] | python | en | ['en', 'error', 'th'] | False |
Line.width | (self) |
Sets the width (in px) of the lines bounding the marker points.
The 'width' property is a number and may be specified as:
- An int or float in the interval [0, inf]
- A tuple, list, or one-dimensional numpy array of the above
Returns
-------
int|float|numpy.ndarray
|
Sets the width (in px) of the lines bounding the marker points.
The 'width' property is a number and may be specified as:
- An int or float in the interval [0, inf]
- A tuple, list, or one-dimensional numpy array of the above | def width(self):
"""
Sets the width (in px) of the lines bounding the marker points.
The 'width' property is a number and may be specified as:
- An int or float in the interval [0, inf]
- A tuple, list, or one-dimensional numpy array of the above
Returns
-------
int|float|numpy.ndarray
"""
return self["width"] | [
"def",
"width",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"width\"",
"]"
] | [
340,
4
] | [
352,
28
] | python | en | ['en', 'error', 'th'] | False |
Line.widthsrc | (self) |
Sets the source reference on Chart Studio Cloud for width .
The 'widthsrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
|
Sets the source reference on Chart Studio Cloud for width .
The 'widthsrc' property must be specified as a string or
as a plotly.grid_objs.Column object | def widthsrc(self):
"""
Sets the source reference on Chart Studio Cloud for width .
The 'widthsrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
"""
return self["widthsrc"] | [
"def",
"widthsrc",
"(",
"self",
")",
":",
"return",
"self",
"[",
"\"widthsrc\"",
"]"
] | [
361,
4
] | [
372,
31
] | python | en | ['en', 'error', 'th'] | False |
Line.__init__ | (
self,
arg=None,
autocolorscale=None,
cauto=None,
cmax=None,
cmid=None,
cmin=None,
color=None,
coloraxis=None,
colorscale=None,
colorsrc=None,
reversescale=None,
width=None,
widthsrc=None,
**kwargs
) |
Construct a new Line object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.scattergeo.marker.Line`
autocolorscale
Determines whether the colorscale is a default palette
(`autocolorscale: true`) or the palette determined by
`marker.line.colorscale`. Has an effect only if in
`marker.line.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.line.color`) or the bounds set in
`marker.line.cmin` and `marker.line.cmax` Has an
effect only if in `marker.line.color`is set to a
numerical array. Defaults to `false` when
`marker.line.cmin` and `marker.line.cmax` are set by
the user.
cmax
Sets the upper bound of the color domain. Has an effect
only if in `marker.line.color`is set to a numerical
array. Value should have the same units as in
`marker.line.color` and if set, `marker.line.cmin` must
be set as well.
cmid
Sets the mid-point of the color domain by scaling
`marker.line.cmin` and/or `marker.line.cmax` to be
equidistant to this point. Has an effect only if in
`marker.line.color`is set to a numerical array. Value
should have the same units as in `marker.line.color`.
Has no effect when `marker.line.cauto` is `false`.
cmin
Sets the lower bound of the color domain. Has an effect
only if in `marker.line.color`is set to a numerical
array. Value should have the same units as in
`marker.line.color` and if set, `marker.line.cmax` must
be set as well.
color
Sets themarker.linecolor. 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.line.cmin` and
`marker.line.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.
colorscale
Sets the colorscale. Has an effect only if in
`marker.line.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.line.cmin` and `marker.line.cmax`.
Alternatively, `colorscale` may be a palette name
string of the following list: Greys,YlGnBu,Greens,YlOrR
d,Bluered,RdBu,Reds,Blues,Picnic,Rainbow,Portland,Jet,H
ot,Blackbody,Earth,Electric,Viridis,Cividis.
colorsrc
Sets the source reference on Chart Studio Cloud for
color .
reversescale
Reverses the color mapping if true. Has an effect only
if in `marker.line.color`is set to a numerical array.
If true, `marker.line.cmin` will correspond to the last
color in the array and `marker.line.cmax` will
correspond to the first color.
width
Sets the width (in px) of the lines bounding the marker
points.
widthsrc
Sets the source reference on Chart Studio Cloud for
width .
Returns
-------
Line
|
Construct a new Line object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.scattergeo.marker.Line`
autocolorscale
Determines whether the colorscale is a default palette
(`autocolorscale: true`) or the palette determined by
`marker.line.colorscale`. Has an effect only if in
`marker.line.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.line.color`) or the bounds set in
`marker.line.cmin` and `marker.line.cmax` Has an
effect only if in `marker.line.color`is set to a
numerical array. Defaults to `false` when
`marker.line.cmin` and `marker.line.cmax` are set by
the user.
cmax
Sets the upper bound of the color domain. Has an effect
only if in `marker.line.color`is set to a numerical
array. Value should have the same units as in
`marker.line.color` and if set, `marker.line.cmin` must
be set as well.
cmid
Sets the mid-point of the color domain by scaling
`marker.line.cmin` and/or `marker.line.cmax` to be
equidistant to this point. Has an effect only if in
`marker.line.color`is set to a numerical array. Value
should have the same units as in `marker.line.color`.
Has no effect when `marker.line.cauto` is `false`.
cmin
Sets the lower bound of the color domain. Has an effect
only if in `marker.line.color`is set to a numerical
array. Value should have the same units as in
`marker.line.color` and if set, `marker.line.cmax` must
be set as well.
color
Sets themarker.linecolor. 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.line.cmin` and
`marker.line.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.
colorscale
Sets the colorscale. Has an effect only if in
`marker.line.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.line.cmin` and `marker.line.cmax`.
Alternatively, `colorscale` may be a palette name
string of the following list: Greys,YlGnBu,Greens,YlOrR
d,Bluered,RdBu,Reds,Blues,Picnic,Rainbow,Portland,Jet,H
ot,Blackbody,Earth,Electric,Viridis,Cividis.
colorsrc
Sets the source reference on Chart Studio Cloud for
color .
reversescale
Reverses the color mapping if true. Has an effect only
if in `marker.line.color`is set to a numerical array.
If true, `marker.line.cmin` will correspond to the last
color in the array and `marker.line.cmax` will
correspond to the first color.
width
Sets the width (in px) of the lines bounding the marker
points.
widthsrc
Sets the source reference on Chart Studio Cloud for
width . | def __init__(
self,
arg=None,
autocolorscale=None,
cauto=None,
cmax=None,
cmid=None,
cmin=None,
color=None,
coloraxis=None,
colorscale=None,
colorsrc=None,
reversescale=None,
width=None,
widthsrc=None,
**kwargs
):
"""
Construct a new Line object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.scattergeo.marker.Line`
autocolorscale
Determines whether the colorscale is a default palette
(`autocolorscale: true`) or the palette determined by
`marker.line.colorscale`. Has an effect only if in
`marker.line.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.line.color`) or the bounds set in
`marker.line.cmin` and `marker.line.cmax` Has an
effect only if in `marker.line.color`is set to a
numerical array. Defaults to `false` when
`marker.line.cmin` and `marker.line.cmax` are set by
the user.
cmax
Sets the upper bound of the color domain. Has an effect
only if in `marker.line.color`is set to a numerical
array. Value should have the same units as in
`marker.line.color` and if set, `marker.line.cmin` must
be set as well.
cmid
Sets the mid-point of the color domain by scaling
`marker.line.cmin` and/or `marker.line.cmax` to be
equidistant to this point. Has an effect only if in
`marker.line.color`is set to a numerical array. Value
should have the same units as in `marker.line.color`.
Has no effect when `marker.line.cauto` is `false`.
cmin
Sets the lower bound of the color domain. Has an effect
only if in `marker.line.color`is set to a numerical
array. Value should have the same units as in
`marker.line.color` and if set, `marker.line.cmax` must
be set as well.
color
Sets themarker.linecolor. 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.line.cmin` and
`marker.line.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.
colorscale
Sets the colorscale. Has an effect only if in
`marker.line.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.line.cmin` and `marker.line.cmax`.
Alternatively, `colorscale` may be a palette name
string of the following list: Greys,YlGnBu,Greens,YlOrR
d,Bluered,RdBu,Reds,Blues,Picnic,Rainbow,Portland,Jet,H
ot,Blackbody,Earth,Electric,Viridis,Cividis.
colorsrc
Sets the source reference on Chart Studio Cloud for
color .
reversescale
Reverses the color mapping if true. Has an effect only
if in `marker.line.color`is set to a numerical array.
If true, `marker.line.cmin` will correspond to the last
color in the array and `marker.line.cmax` will
correspond to the first color.
width
Sets the width (in px) of the lines bounding the marker
points.
widthsrc
Sets the source reference on Chart Studio Cloud for
width .
Returns
-------
Line
"""
super(Line, self).__init__("line")
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.scattergeo.marker.Line
constructor must be a dict or
an instance of :class:`plotly.graph_objs.scattergeo.marker.Line`"""
)
# 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("autocolorscale", None)
_v = autocolorscale if autocolorscale is not None else _v
if _v is not None:
self["autocolorscale"] = _v
_v = arg.pop("cauto", None)
_v = cauto if cauto is not None else _v
if _v is not None:
self["cauto"] = _v
_v = arg.pop("cmax", None)
_v = cmax if cmax is not None else _v
if _v is not None:
self["cmax"] = _v
_v = arg.pop("cmid", None)
_v = cmid if cmid is not None else _v
if _v is not None:
self["cmid"] = _v
_v = arg.pop("cmin", None)
_v = cmin if cmin is not None else _v
if _v is not None:
self["cmin"] = _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("coloraxis", None)
_v = coloraxis if coloraxis is not None else _v
if _v is not None:
self["coloraxis"] = _v
_v = arg.pop("colorscale", None)
_v = colorscale if colorscale is not None else _v
if _v is not None:
self["colorscale"] = _v
_v = arg.pop("colorsrc", None)
_v = colorsrc if colorsrc is not None else _v
if _v is not None:
self["colorsrc"] = _v
_v = arg.pop("reversescale", None)
_v = reversescale if reversescale is not None else _v
if _v is not None:
self["reversescale"] = _v
_v = arg.pop("width", None)
_v = width if width is not None else _v
if _v is not None:
self["width"] = _v
_v = arg.pop("widthsrc", None)
_v = widthsrc if widthsrc is not None else _v
if _v is not None:
self["widthsrc"] = _v
# Process unknown kwargs
# ----------------------
self._process_kwargs(**dict(arg, **kwargs))
# Reset skip_invalid
# ------------------
self._skip_invalid = False | [
"def",
"__init__",
"(",
"self",
",",
"arg",
"=",
"None",
",",
"autocolorscale",
"=",
"None",
",",
"cauto",
"=",
"None",
",",
"cmax",
"=",
"None",
",",
"cmid",
"=",
"None",
",",
"cmin",
"=",
"None",
",",
"color",
"=",
"None",
",",
"coloraxis",
"=",
"None",
",",
"colorscale",
"=",
"None",
",",
"colorsrc",
"=",
"None",
",",
"reversescale",
"=",
"None",
",",
"width",
"=",
"None",
",",
"widthsrc",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"super",
"(",
"Line",
",",
"self",
")",
".",
"__init__",
"(",
"\"line\"",
")",
"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",
"(",
"\"\"\"\\\nThe first argument to the plotly.graph_objs.scattergeo.marker.Line \nconstructor must be a dict or \nan instance of :class:`plotly.graph_objs.scattergeo.marker.Line`\"\"\"",
")",
"# 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",
"(",
"\"autocolorscale\"",
",",
"None",
")",
"_v",
"=",
"autocolorscale",
"if",
"autocolorscale",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"autocolorscale\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"cauto\"",
",",
"None",
")",
"_v",
"=",
"cauto",
"if",
"cauto",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"cauto\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"cmax\"",
",",
"None",
")",
"_v",
"=",
"cmax",
"if",
"cmax",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"cmax\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"cmid\"",
",",
"None",
")",
"_v",
"=",
"cmid",
"if",
"cmid",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"cmid\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"cmin\"",
",",
"None",
")",
"_v",
"=",
"cmin",
"if",
"cmin",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"cmin\"",
"]",
"=",
"_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",
"(",
"\"coloraxis\"",
",",
"None",
")",
"_v",
"=",
"coloraxis",
"if",
"coloraxis",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"coloraxis\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"colorscale\"",
",",
"None",
")",
"_v",
"=",
"colorscale",
"if",
"colorscale",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"colorscale\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"colorsrc\"",
",",
"None",
")",
"_v",
"=",
"colorsrc",
"if",
"colorsrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"colorsrc\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"reversescale\"",
",",
"None",
")",
"_v",
"=",
"reversescale",
"if",
"reversescale",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"reversescale\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"width\"",
",",
"None",
")",
"_v",
"=",
"width",
"if",
"width",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"width\"",
"]",
"=",
"_v",
"_v",
"=",
"arg",
".",
"pop",
"(",
"\"widthsrc\"",
",",
"None",
")",
"_v",
"=",
"widthsrc",
"if",
"widthsrc",
"is",
"not",
"None",
"else",
"_v",
"if",
"_v",
"is",
"not",
"None",
":",
"self",
"[",
"\"widthsrc\"",
"]",
"=",
"_v",
"# Process unknown kwargs",
"# ----------------------",
"self",
".",
"_process_kwargs",
"(",
"*",
"*",
"dict",
"(",
"arg",
",",
"*",
"*",
"kwargs",
")",
")",
"# Reset skip_invalid",
"# ------------------",
"self",
".",
"_skip_invalid",
"=",
"False"
] | [
464,
4
] | [
658,
34
] | python | en | ['en', 'error', 'th'] | False |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.