1from plotly.basedatatypes import BaseTraceType as _BaseTraceType 2import copy as _copy 3 4 5class Scatterpolar(_BaseTraceType): 6 7 # class properties 8 # -------------------- 9 _parent_path_str = "" 10 _path_str = "scatterpolar" 11 _valid_props = { 12 "cliponaxis", 13 "connectgaps", 14 "customdata", 15 "customdatasrc", 16 "dr", 17 "dtheta", 18 "fill", 19 "fillcolor", 20 "hoverinfo", 21 "hoverinfosrc", 22 "hoverlabel", 23 "hoveron", 24 "hovertemplate", 25 "hovertemplatesrc", 26 "hovertext", 27 "hovertextsrc", 28 "ids", 29 "idssrc", 30 "legendgroup", 31 "line", 32 "marker", 33 "meta", 34 "metasrc", 35 "mode", 36 "name", 37 "opacity", 38 "r", 39 "r0", 40 "rsrc", 41 "selected", 42 "selectedpoints", 43 "showlegend", 44 "stream", 45 "subplot", 46 "text", 47 "textfont", 48 "textposition", 49 "textpositionsrc", 50 "textsrc", 51 "texttemplate", 52 "texttemplatesrc", 53 "theta", 54 "theta0", 55 "thetasrc", 56 "thetaunit", 57 "type", 58 "uid", 59 "uirevision", 60 "unselected", 61 "visible", 62 } 63 64 # cliponaxis 65 # ---------- 66 @property 67 def cliponaxis(self): 68 """ 69 Determines whether or not markers and text nodes are clipped 70 about the subplot axes. To show markers and text nodes above 71 axis lines and tick labels, make sure to set `xaxis.layer` and 72 `yaxis.layer` to *below traces*. 73 74 The 'cliponaxis' property must be specified as a bool 75 (either True, or False) 76 77 Returns 78 ------- 79 bool 80 """ 81 return self["cliponaxis"] 82 83 @cliponaxis.setter 84 def cliponaxis(self, val): 85 self["cliponaxis"] = val 86 87 # connectgaps 88 # ----------- 89 @property 90 def connectgaps(self): 91 """ 92 Determines whether or not gaps (i.e. {nan} or missing values) 93 in the provided data arrays are connected. 94 95 The 'connectgaps' property must be specified as a bool 96 (either True, or False) 97 98 Returns 99 ------- 100 bool 101 """ 102 return self["connectgaps"] 103 104 @connectgaps.setter 105 def connectgaps(self, val): 106 self["connectgaps"] = val 107 108 # customdata 109 # ---------- 110 @property 111 def customdata(self): 112 """ 113 Assigns extra data each datum. This may be useful when 114 listening to hover, click and selection events. Note that, 115 "scatter" traces also appends customdata items in the markers 116 DOM elements 117 118 The 'customdata' property is an array that may be specified as a tuple, 119 list, numpy array, or pandas Series 120 121 Returns 122 ------- 123 numpy.ndarray 124 """ 125 return self["customdata"] 126 127 @customdata.setter 128 def customdata(self, val): 129 self["customdata"] = val 130 131 # customdatasrc 132 # ------------- 133 @property 134 def customdatasrc(self): 135 """ 136 Sets the source reference on Chart Studio Cloud for customdata 137 . 138 139 The 'customdatasrc' property must be specified as a string or 140 as a plotly.grid_objs.Column object 141 142 Returns 143 ------- 144 str 145 """ 146 return self["customdatasrc"] 147 148 @customdatasrc.setter 149 def customdatasrc(self, val): 150 self["customdatasrc"] = val 151 152 # dr 153 # -- 154 @property 155 def dr(self): 156 """ 157 Sets the r coordinate step. 158 159 The 'dr' property is a number and may be specified as: 160 - An int or float 161 162 Returns 163 ------- 164 int|float 165 """ 166 return self["dr"] 167 168 @dr.setter 169 def dr(self, val): 170 self["dr"] = val 171 172 # dtheta 173 # ------ 174 @property 175 def dtheta(self): 176 """ 177 Sets the theta coordinate step. By default, the `dtheta` step 178 equals the subplot's period divided by the length of the `r` 179 coordinates. 180 181 The 'dtheta' property is a number and may be specified as: 182 - An int or float 183 184 Returns 185 ------- 186 int|float 187 """ 188 return self["dtheta"] 189 190 @dtheta.setter 191 def dtheta(self, val): 192 self["dtheta"] = val 193 194 # fill 195 # ---- 196 @property 197 def fill(self): 198 """ 199 Sets the area to fill with a solid color. Use with `fillcolor` 200 if not "none". scatterpolar has a subset of the options 201 available to scatter. "toself" connects the endpoints of the 202 trace (or each segment of the trace if it has gaps) into a 203 closed shape. "tonext" fills the space between two traces if 204 one completely encloses the other (eg consecutive contour 205 lines), and behaves like "toself" if there is no trace before 206 it. "tonext" should not be used if one trace does not enclose 207 the other. 208 209 The 'fill' property is an enumeration that may be specified as: 210 - One of the following enumeration values: 211 ['none', 'toself', 'tonext'] 212 213 Returns 214 ------- 215 Any 216 """ 217 return self["fill"] 218 219 @fill.setter 220 def fill(self, val): 221 self["fill"] = val 222 223 # fillcolor 224 # --------- 225 @property 226 def fillcolor(self): 227 """ 228 Sets the fill color. Defaults to a half-transparent variant of 229 the line color, marker color, or marker line color, whichever 230 is available. 231 232 The 'fillcolor' property is a color and may be specified as: 233 - A hex string (e.g. '#ff0000') 234 - An rgb/rgba string (e.g. 'rgb(255,0,0)') 235 - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') 236 - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') 237 - A named CSS color: 238 aliceblue, antiquewhite, aqua, aquamarine, azure, 239 beige, bisque, black, blanchedalmond, blue, 240 blueviolet, brown, burlywood, cadetblue, 241 chartreuse, chocolate, coral, cornflowerblue, 242 cornsilk, crimson, cyan, darkblue, darkcyan, 243 darkgoldenrod, darkgray, darkgrey, darkgreen, 244 darkkhaki, darkmagenta, darkolivegreen, darkorange, 245 darkorchid, darkred, darksalmon, darkseagreen, 246 darkslateblue, darkslategray, darkslategrey, 247 darkturquoise, darkviolet, deeppink, deepskyblue, 248 dimgray, dimgrey, dodgerblue, firebrick, 249 floralwhite, forestgreen, fuchsia, gainsboro, 250 ghostwhite, gold, goldenrod, gray, grey, green, 251 greenyellow, honeydew, hotpink, indianred, indigo, 252 ivory, khaki, lavender, lavenderblush, lawngreen, 253 lemonchiffon, lightblue, lightcoral, lightcyan, 254 lightgoldenrodyellow, lightgray, lightgrey, 255 lightgreen, lightpink, lightsalmon, lightseagreen, 256 lightskyblue, lightslategray, lightslategrey, 257 lightsteelblue, lightyellow, lime, limegreen, 258 linen, magenta, maroon, mediumaquamarine, 259 mediumblue, mediumorchid, mediumpurple, 260 mediumseagreen, mediumslateblue, mediumspringgreen, 261 mediumturquoise, mediumvioletred, midnightblue, 262 mintcream, mistyrose, moccasin, navajowhite, navy, 263 oldlace, olive, olivedrab, orange, orangered, 264 orchid, palegoldenrod, palegreen, paleturquoise, 265 palevioletred, papayawhip, peachpuff, peru, pink, 266 plum, powderblue, purple, red, rosybrown, 267 royalblue, rebeccapurple, saddlebrown, salmon, 268 sandybrown, seagreen, seashell, sienna, silver, 269 skyblue, slateblue, slategray, slategrey, snow, 270 springgreen, steelblue, tan, teal, thistle, tomato, 271 turquoise, violet, wheat, white, whitesmoke, 272 yellow, yellowgreen 273 274 Returns 275 ------- 276 str 277 """ 278 return self["fillcolor"] 279 280 @fillcolor.setter 281 def fillcolor(self, val): 282 self["fillcolor"] = val 283 284 # hoverinfo 285 # --------- 286 @property 287 def hoverinfo(self): 288 """ 289 Determines which trace information appear on hover. If `none` 290 or `skip` are set, no information is displayed upon hovering. 291 But, if `none` is set, click and hover events are still fired. 292 293 The 'hoverinfo' property is a flaglist and may be specified 294 as a string containing: 295 - Any combination of ['r', 'theta', 'text', 'name'] joined with '+' characters 296 (e.g. 'r+theta') 297 OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') 298 - A list or array of the above 299 300 Returns 301 ------- 302 Any|numpy.ndarray 303 """ 304 return self["hoverinfo"] 305 306 @hoverinfo.setter 307 def hoverinfo(self, val): 308 self["hoverinfo"] = val 309 310 # hoverinfosrc 311 # ------------ 312 @property 313 def hoverinfosrc(self): 314 """ 315 Sets the source reference on Chart Studio Cloud for hoverinfo 316 . 317 318 The 'hoverinfosrc' property must be specified as a string or 319 as a plotly.grid_objs.Column object 320 321 Returns 322 ------- 323 str 324 """ 325 return self["hoverinfosrc"] 326 327 @hoverinfosrc.setter 328 def hoverinfosrc(self, val): 329 self["hoverinfosrc"] = val 330 331 # hoverlabel 332 # ---------- 333 @property 334 def hoverlabel(self): 335 """ 336 The 'hoverlabel' property is an instance of Hoverlabel 337 that may be specified as: 338 - An instance of :class:`plotly.graph_objs.scatterpolar.Hoverlabel` 339 - A dict of string/value properties that will be passed 340 to the Hoverlabel constructor 341 342 Supported dict properties: 343 344 align 345 Sets the horizontal alignment of the text 346 content within hover label box. Has an effect 347 only if the hover label text spans more two or 348 more lines 349 alignsrc 350 Sets the source reference on Chart Studio Cloud 351 for align . 352 bgcolor 353 Sets the background color of the hover labels 354 for this trace 355 bgcolorsrc 356 Sets the source reference on Chart Studio Cloud 357 for bgcolor . 358 bordercolor 359 Sets the border color of the hover labels for 360 this trace. 361 bordercolorsrc 362 Sets the source reference on Chart Studio Cloud 363 for bordercolor . 364 font 365 Sets the font used in hover labels. 366 namelength 367 Sets the default length (in number of 368 characters) of the trace name in the hover 369 labels for all traces. -1 shows the whole name 370 regardless of length. 0-3 shows the first 0-3 371 characters, and an integer >3 will show the 372 whole name if it is less than that many 373 characters, but if it is longer, will truncate 374 to `namelength - 3` characters and add an 375 ellipsis. 376 namelengthsrc 377 Sets the source reference on Chart Studio Cloud 378 for namelength . 379 380 Returns 381 ------- 382 plotly.graph_objs.scatterpolar.Hoverlabel 383 """ 384 return self["hoverlabel"] 385 386 @hoverlabel.setter 387 def hoverlabel(self, val): 388 self["hoverlabel"] = val 389 390 # hoveron 391 # ------- 392 @property 393 def hoveron(self): 394 """ 395 Do the hover effects highlight individual points (markers or 396 line points) or do they highlight filled regions? If the fill 397 is "toself" or "tonext" and there are no markers or text, then 398 the default is "fills", otherwise it is "points". 399 400 The 'hoveron' property is a flaglist and may be specified 401 as a string containing: 402 - Any combination of ['points', 'fills'] joined with '+' characters 403 (e.g. 'points+fills') 404 405 Returns 406 ------- 407 Any 408 """ 409 return self["hoveron"] 410 411 @hoveron.setter 412 def hoveron(self, val): 413 self["hoveron"] = val 414 415 # hovertemplate 416 # ------------- 417 @property 418 def hovertemplate(self): 419 """ 420 Template string used for rendering the information that appear 421 on hover box. Note that this will override `hoverinfo`. 422 Variables are inserted using %{variable}, for example "y: 423 %{y}". Numbers are formatted using d3-format's syntax 424 %{variable:d3-format}, for example "Price: %{y:$.2f}". 425 https://github.com/d3/d3-3.x-api- 426 reference/blob/master/Formatting.md#d3_format for details on 427 the formatting syntax. Dates are formatted using d3-time- 428 format's syntax %{variable|d3-time-format}, for example "Day: 429 %{2019-01-01|%A}". https://github.com/d3/d3-time- 430 format#locale_format for details on the date formatting syntax. 431 The variables available in `hovertemplate` are the ones emitted 432 as event data described at this link 433 https://plotly.com/javascript/plotlyjs-events/#event-data. 434 Additionally, every attributes that can be specified per-point 435 (the ones that are `arrayOk: true`) are available. Anything 436 contained in tag `<extra>` is displayed in the secondary box, 437 for example "<extra>{fullData.name}</extra>". To hide the 438 secondary box completely, use an empty tag `<extra></extra>`. 439 440 The 'hovertemplate' property is a string and must be specified as: 441 - A string 442 - A number that will be converted to a string 443 - A tuple, list, or one-dimensional numpy array of the above 444 445 Returns 446 ------- 447 str|numpy.ndarray 448 """ 449 return self["hovertemplate"] 450 451 @hovertemplate.setter 452 def hovertemplate(self, val): 453 self["hovertemplate"] = val 454 455 # hovertemplatesrc 456 # ---------------- 457 @property 458 def hovertemplatesrc(self): 459 """ 460 Sets the source reference on Chart Studio Cloud for 461 hovertemplate . 462 463 The 'hovertemplatesrc' property must be specified as a string or 464 as a plotly.grid_objs.Column object 465 466 Returns 467 ------- 468 str 469 """ 470 return self["hovertemplatesrc"] 471 472 @hovertemplatesrc.setter 473 def hovertemplatesrc(self, val): 474 self["hovertemplatesrc"] = val 475 476 # hovertext 477 # --------- 478 @property 479 def hovertext(self): 480 """ 481 Sets hover text elements associated with each (x,y) pair. If a 482 single string, the same string appears over all the data 483 points. If an array of string, the items are mapped in order to 484 the this trace's (x,y) coordinates. To be seen, trace 485 `hoverinfo` must contain a "text" flag. 486 487 The 'hovertext' property is a string and must be specified as: 488 - A string 489 - A number that will be converted to a string 490 - A tuple, list, or one-dimensional numpy array of the above 491 492 Returns 493 ------- 494 str|numpy.ndarray 495 """ 496 return self["hovertext"] 497 498 @hovertext.setter 499 def hovertext(self, val): 500 self["hovertext"] = val 501 502 # hovertextsrc 503 # ------------ 504 @property 505 def hovertextsrc(self): 506 """ 507 Sets the source reference on Chart Studio Cloud for hovertext 508 . 509 510 The 'hovertextsrc' property must be specified as a string or 511 as a plotly.grid_objs.Column object 512 513 Returns 514 ------- 515 str 516 """ 517 return self["hovertextsrc"] 518 519 @hovertextsrc.setter 520 def hovertextsrc(self, val): 521 self["hovertextsrc"] = val 522 523 # ids 524 # --- 525 @property 526 def ids(self): 527 """ 528 Assigns id labels to each datum. These ids for object constancy 529 of data points during animation. Should be an array of strings, 530 not numbers or any other type. 531 532 The 'ids' property is an array that may be specified as a tuple, 533 list, numpy array, or pandas Series 534 535 Returns 536 ------- 537 numpy.ndarray 538 """ 539 return self["ids"] 540 541 @ids.setter 542 def ids(self, val): 543 self["ids"] = val 544 545 # idssrc 546 # ------ 547 @property 548 def idssrc(self): 549 """ 550 Sets the source reference on Chart Studio Cloud for ids . 551 552 The 'idssrc' property must be specified as a string or 553 as a plotly.grid_objs.Column object 554 555 Returns 556 ------- 557 str 558 """ 559 return self["idssrc"] 560 561 @idssrc.setter 562 def idssrc(self, val): 563 self["idssrc"] = val 564 565 # legendgroup 566 # ----------- 567 @property 568 def legendgroup(self): 569 """ 570 Sets the legend group for this trace. Traces part of the same 571 legend group hide/show at the same time when toggling legend 572 items. 573 574 The 'legendgroup' property is a string and must be specified as: 575 - A string 576 - A number that will be converted to a string 577 578 Returns 579 ------- 580 str 581 """ 582 return self["legendgroup"] 583 584 @legendgroup.setter 585 def legendgroup(self, val): 586 self["legendgroup"] = val 587 588 # line 589 # ---- 590 @property 591 def line(self): 592 """ 593 The 'line' property is an instance of Line 594 that may be specified as: 595 - An instance of :class:`plotly.graph_objs.scatterpolar.Line` 596 - A dict of string/value properties that will be passed 597 to the Line constructor 598 599 Supported dict properties: 600 601 color 602 Sets the line color. 603 dash 604 Sets the dash style of lines. Set to a dash 605 type string ("solid", "dot", "dash", 606 "longdash", "dashdot", or "longdashdot") or a 607 dash length list in px (eg "5px,10px,2px,2px"). 608 shape 609 Determines the line shape. With "spline" the 610 lines are drawn using spline interpolation. The 611 other available values correspond to step-wise 612 line shapes. 613 smoothing 614 Has an effect only if `shape` is set to 615 "spline" Sets the amount of smoothing. 0 616 corresponds to no smoothing (equivalent to a 617 "linear" shape). 618 width 619 Sets the line width (in px). 620 621 Returns 622 ------- 623 plotly.graph_objs.scatterpolar.Line 624 """ 625 return self["line"] 626 627 @line.setter 628 def line(self, val): 629 self["line"] = val 630 631 # marker 632 # ------ 633 @property 634 def marker(self): 635 """ 636 The 'marker' property is an instance of Marker 637 that may be specified as: 638 - An instance of :class:`plotly.graph_objs.scatterpolar.Marker` 639 - A dict of string/value properties that will be passed 640 to the Marker constructor 641 642 Supported dict properties: 643 644 autocolorscale 645 Determines whether the colorscale is a default 646 palette (`autocolorscale: true`) or the palette 647 determined by `marker.colorscale`. Has an 648 effect only if in `marker.color`is set to a 649 numerical array. In case `colorscale` is 650 unspecified or `autocolorscale` is true, the 651 default palette will be chosen according to 652 whether numbers in the `color` array are all 653 positive, all negative or mixed. 654 cauto 655 Determines whether or not the color domain is 656 computed with respect to the input data (here 657 in `marker.color`) or the bounds set in 658 `marker.cmin` and `marker.cmax` Has an effect 659 only if in `marker.color`is set to a numerical 660 array. Defaults to `false` when `marker.cmin` 661 and `marker.cmax` are set by the user. 662 cmax 663 Sets the upper bound of the color domain. Has 664 an effect only if in `marker.color`is set to a 665 numerical array. Value should have the same 666 units as in `marker.color` and if set, 667 `marker.cmin` must be set as well. 668 cmid 669 Sets the mid-point of the color domain by 670 scaling `marker.cmin` and/or `marker.cmax` to 671 be equidistant to this point. Has an effect 672 only if in `marker.color`is set to a numerical 673 array. Value should have the same units as in 674 `marker.color`. Has no effect when 675 `marker.cauto` is `false`. 676 cmin 677 Sets the lower bound of the color domain. Has 678 an effect only if in `marker.color`is set to a 679 numerical array. Value should have the same 680 units as in `marker.color` and if set, 681 `marker.cmax` must be set as well. 682 color 683 Sets themarkercolor. It accepts either a 684 specific color or an array of numbers that are 685 mapped to the colorscale relative to the max 686 and min values of the array or relative to 687 `marker.cmin` and `marker.cmax` if set. 688 coloraxis 689 Sets a reference to a shared color axis. 690 References to these shared color axes are 691 "coloraxis", "coloraxis2", "coloraxis3", etc. 692 Settings for these shared color axes are set in 693 the layout, under `layout.coloraxis`, 694 `layout.coloraxis2`, etc. Note that multiple 695 color scales can be linked to the same color 696 axis. 697 colorbar 698 :class:`plotly.graph_objects.scatterpolar.marke 699 r.ColorBar` instance or dict with compatible 700 properties 701 colorscale 702 Sets the colorscale. Has an effect only if in 703 `marker.color`is set to a numerical array. The 704 colorscale must be an array containing arrays 705 mapping a normalized value to an rgb, rgba, 706 hex, hsl, hsv, or named color string. At 707 minimum, a mapping for the lowest (0) and 708 highest (1) values are required. For example, 709 `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. 710 To control the bounds of the colorscale in 711 color space, use`marker.cmin` and 712 `marker.cmax`. Alternatively, `colorscale` may 713 be a palette name string of the following list: 714 Greys,YlGnBu,Greens,YlOrRd,Bluered,RdBu,Reds,Bl 715 ues,Picnic,Rainbow,Portland,Jet,Hot,Blackbody,E 716 arth,Electric,Viridis,Cividis. 717 colorsrc 718 Sets the source reference on Chart Studio Cloud 719 for color . 720 gradient 721 :class:`plotly.graph_objects.scatterpolar.marke 722 r.Gradient` instance or dict with compatible 723 properties 724 line 725 :class:`plotly.graph_objects.scatterpolar.marke 726 r.Line` instance or dict with compatible 727 properties 728 maxdisplayed 729 Sets a maximum number of points to be drawn on 730 the graph. 0 corresponds to no limit. 731 opacity 732 Sets the marker opacity. 733 opacitysrc 734 Sets the source reference on Chart Studio Cloud 735 for opacity . 736 reversescale 737 Reverses the color mapping if true. Has an 738 effect only if in `marker.color`is set to a 739 numerical array. If true, `marker.cmin` will 740 correspond to the last color in the array and 741 `marker.cmax` will correspond to the first 742 color. 743 showscale 744 Determines whether or not a colorbar is 745 displayed for this trace. Has an effect only if 746 in `marker.color`is set to a numerical array. 747 size 748 Sets the marker size (in px). 749 sizemin 750 Has an effect only if `marker.size` is set to a 751 numerical array. Sets the minimum size (in px) 752 of the rendered marker points. 753 sizemode 754 Has an effect only if `marker.size` is set to a 755 numerical array. Sets the rule for which the 756 data in `size` is converted to pixels. 757 sizeref 758 Has an effect only if `marker.size` is set to a 759 numerical array. Sets the scale factor used to 760 determine the rendered size of marker points. 761 Use with `sizemin` and `sizemode`. 762 sizesrc 763 Sets the source reference on Chart Studio Cloud 764 for size . 765 symbol 766 Sets the marker symbol type. Adding 100 is 767 equivalent to appending "-open" to a symbol 768 name. Adding 200 is equivalent to appending 769 "-dot" to a symbol name. Adding 300 is 770 equivalent to appending "-open-dot" or "dot- 771 open" to a symbol name. 772 symbolsrc 773 Sets the source reference on Chart Studio Cloud 774 for symbol . 775 776 Returns 777 ------- 778 plotly.graph_objs.scatterpolar.Marker 779 """ 780 return self["marker"] 781 782 @marker.setter 783 def marker(self, val): 784 self["marker"] = val 785 786 # meta 787 # ---- 788 @property 789 def meta(self): 790 """ 791 Assigns extra meta information associated with this trace that 792 can be used in various text attributes. Attributes such as 793 trace `name`, graph, axis and colorbar `title.text`, annotation 794 `text` `rangeselector`, `updatemenues` and `sliders` `label` 795 text all support `meta`. To access the trace `meta` values in 796 an attribute in the same trace, simply use `%{meta[i]}` where 797 `i` is the index or key of the `meta` item in question. To 798 access trace `meta` in layout attributes, use 799 `%{data[n[.meta[i]}` where `i` is the index or key of the 800 `meta` and `n` is the trace index. 801 802 The 'meta' property accepts values of any type 803 804 Returns 805 ------- 806 Any|numpy.ndarray 807 """ 808 return self["meta"] 809 810 @meta.setter 811 def meta(self, val): 812 self["meta"] = val 813 814 # metasrc 815 # ------- 816 @property 817 def metasrc(self): 818 """ 819 Sets the source reference on Chart Studio Cloud for meta . 820 821 The 'metasrc' property must be specified as a string or 822 as a plotly.grid_objs.Column object 823 824 Returns 825 ------- 826 str 827 """ 828 return self["metasrc"] 829 830 @metasrc.setter 831 def metasrc(self, val): 832 self["metasrc"] = val 833 834 # mode 835 # ---- 836 @property 837 def mode(self): 838 """ 839 Determines the drawing mode for this scatter trace. If the 840 provided `mode` includes "text" then the `text` elements appear 841 at the coordinates. Otherwise, the `text` elements appear on 842 hover. If there are less than 20 points and the trace is not 843 stacked then the default is "lines+markers". Otherwise, 844 "lines". 845 846 The 'mode' property is a flaglist and may be specified 847 as a string containing: 848 - Any combination of ['lines', 'markers', 'text'] joined with '+' characters 849 (e.g. 'lines+markers') 850 OR exactly one of ['none'] (e.g. 'none') 851 852 Returns 853 ------- 854 Any 855 """ 856 return self["mode"] 857 858 @mode.setter 859 def mode(self, val): 860 self["mode"] = val 861 862 # name 863 # ---- 864 @property 865 def name(self): 866 """ 867 Sets the trace name. The trace name appear as the legend item 868 and on hover. 869 870 The 'name' property is a string and must be specified as: 871 - A string 872 - A number that will be converted to a string 873 874 Returns 875 ------- 876 str 877 """ 878 return self["name"] 879 880 @name.setter 881 def name(self, val): 882 self["name"] = val 883 884 # opacity 885 # ------- 886 @property 887 def opacity(self): 888 """ 889 Sets the opacity of the trace. 890 891 The 'opacity' property is a number and may be specified as: 892 - An int or float in the interval [0, 1] 893 894 Returns 895 ------- 896 int|float 897 """ 898 return self["opacity"] 899 900 @opacity.setter 901 def opacity(self, val): 902 self["opacity"] = val 903 904 # r 905 # - 906 @property 907 def r(self): 908 """ 909 Sets the radial coordinates 910 911 The 'r' property is an array that may be specified as a tuple, 912 list, numpy array, or pandas Series 913 914 Returns 915 ------- 916 numpy.ndarray 917 """ 918 return self["r"] 919 920 @r.setter 921 def r(self, val): 922 self["r"] = val 923 924 # r0 925 # -- 926 @property 927 def r0(self): 928 """ 929 Alternate to `r`. Builds a linear space of r coordinates. Use 930 with `dr` where `r0` is the starting coordinate and `dr` the 931 step. 932 933 The 'r0' property accepts values of any type 934 935 Returns 936 ------- 937 Any 938 """ 939 return self["r0"] 940 941 @r0.setter 942 def r0(self, val): 943 self["r0"] = val 944 945 # rsrc 946 # ---- 947 @property 948 def rsrc(self): 949 """ 950 Sets the source reference on Chart Studio Cloud for r . 951 952 The 'rsrc' property must be specified as a string or 953 as a plotly.grid_objs.Column object 954 955 Returns 956 ------- 957 str 958 """ 959 return self["rsrc"] 960 961 @rsrc.setter 962 def rsrc(self, val): 963 self["rsrc"] = val 964 965 # selected 966 # -------- 967 @property 968 def selected(self): 969 """ 970 The 'selected' property is an instance of Selected 971 that may be specified as: 972 - An instance of :class:`plotly.graph_objs.scatterpolar.Selected` 973 - A dict of string/value properties that will be passed 974 to the Selected constructor 975 976 Supported dict properties: 977 978 marker 979 :class:`plotly.graph_objects.scatterpolar.selec 980 ted.Marker` instance or dict with compatible 981 properties 982 textfont 983 :class:`plotly.graph_objects.scatterpolar.selec 984 ted.Textfont` instance or dict with compatible 985 properties 986 987 Returns 988 ------- 989 plotly.graph_objs.scatterpolar.Selected 990 """ 991 return self["selected"] 992 993 @selected.setter 994 def selected(self, val): 995 self["selected"] = val 996 997 # selectedpoints 998 # -------------- 999 @property 1000 def selectedpoints(self): 1001 """ 1002 Array containing integer indices of selected points. Has an 1003 effect only for traces that support selections. Note that an 1004 empty array means an empty selection where the `unselected` are 1005 turned on for all points, whereas, any other non-array values 1006 means no selection all where the `selected` and `unselected` 1007 styles have no effect. 1008 1009 The 'selectedpoints' property accepts values of any type 1010 1011 Returns 1012 ------- 1013 Any 1014 """ 1015 return self["selectedpoints"] 1016 1017 @selectedpoints.setter 1018 def selectedpoints(self, val): 1019 self["selectedpoints"] = val 1020 1021 # showlegend 1022 # ---------- 1023 @property 1024 def showlegend(self): 1025 """ 1026 Determines whether or not an item corresponding to this trace 1027 is shown in the legend. 1028 1029 The 'showlegend' property must be specified as a bool 1030 (either True, or False) 1031 1032 Returns 1033 ------- 1034 bool 1035 """ 1036 return self["showlegend"] 1037 1038 @showlegend.setter 1039 def showlegend(self, val): 1040 self["showlegend"] = val 1041 1042 # stream 1043 # ------ 1044 @property 1045 def stream(self): 1046 """ 1047 The 'stream' property is an instance of Stream 1048 that may be specified as: 1049 - An instance of :class:`plotly.graph_objs.scatterpolar.Stream` 1050 - A dict of string/value properties that will be passed 1051 to the Stream constructor 1052 1053 Supported dict properties: 1054 1055 maxpoints 1056 Sets the maximum number of points to keep on 1057 the plots from an incoming stream. If 1058 `maxpoints` is set to 50, only the newest 50 1059 points will be displayed on the plot. 1060 token 1061 The stream id number links a data trace on a 1062 plot with a stream. See https://chart- 1063 studio.plotly.com/settings for more details. 1064 1065 Returns 1066 ------- 1067 plotly.graph_objs.scatterpolar.Stream 1068 """ 1069 return self["stream"] 1070 1071 @stream.setter 1072 def stream(self, val): 1073 self["stream"] = val 1074 1075 # subplot 1076 # ------- 1077 @property 1078 def subplot(self): 1079 """ 1080 Sets a reference between this trace's data coordinates and a 1081 polar subplot. If "polar" (the default value), the data refer 1082 to `layout.polar`. If "polar2", the data refer to 1083 `layout.polar2`, and so on. 1084 1085 The 'subplot' property is an identifier of a particular 1086 subplot, of type 'polar', that may be specified as the string 'polar' 1087 optionally followed by an integer >= 1 1088 (e.g. 'polar', 'polar1', 'polar2', 'polar3', etc.) 1089 1090 Returns 1091 ------- 1092 str 1093 """ 1094 return self["subplot"] 1095 1096 @subplot.setter 1097 def subplot(self, val): 1098 self["subplot"] = val 1099 1100 # text 1101 # ---- 1102 @property 1103 def text(self): 1104 """ 1105 Sets text elements associated with each (x,y) pair. If a single 1106 string, the same string appears over all the data points. If an 1107 array of string, the items are mapped in order to the this 1108 trace's (x,y) coordinates. If trace `hoverinfo` contains a 1109 "text" flag and "hovertext" is not set, these elements will be 1110 seen in the hover labels. 1111 1112 The 'text' property is a string and must be specified as: 1113 - A string 1114 - A number that will be converted to a string 1115 - A tuple, list, or one-dimensional numpy array of the above 1116 1117 Returns 1118 ------- 1119 str|numpy.ndarray 1120 """ 1121 return self["text"] 1122 1123 @text.setter 1124 def text(self, val): 1125 self["text"] = val 1126 1127 # textfont 1128 # -------- 1129 @property 1130 def textfont(self): 1131 """ 1132 Sets the text font. 1133 1134 The 'textfont' property is an instance of Textfont 1135 that may be specified as: 1136 - An instance of :class:`plotly.graph_objs.scatterpolar.Textfont` 1137 - A dict of string/value properties that will be passed 1138 to the Textfont constructor 1139 1140 Supported dict properties: 1141 1142 color 1143 1144 colorsrc 1145 Sets the source reference on Chart Studio Cloud 1146 for color . 1147 family 1148 HTML font family - the typeface that will be 1149 applied by the web browser. The web browser 1150 will only be able to apply a font if it is 1151 available on the system which it operates. 1152 Provide multiple font families, separated by 1153 commas, to indicate the preference in which to 1154 apply fonts if they aren't available on the 1155 system. The Chart Studio Cloud (at 1156 https://chart-studio.plotly.com or on-premise) 1157 generates images on a server, where only a 1158 select number of fonts are installed and 1159 supported. These include "Arial", "Balto", 1160 "Courier New", "Droid Sans",, "Droid Serif", 1161 "Droid Sans Mono", "Gravitas One", "Old 1162 Standard TT", "Open Sans", "Overpass", "PT Sans 1163 Narrow", "Raleway", "Times New Roman". 1164 familysrc 1165 Sets the source reference on Chart Studio Cloud 1166 for family . 1167 size 1168 1169 sizesrc 1170 Sets the source reference on Chart Studio Cloud 1171 for size . 1172 1173 Returns 1174 ------- 1175 plotly.graph_objs.scatterpolar.Textfont 1176 """ 1177 return self["textfont"] 1178 1179 @textfont.setter 1180 def textfont(self, val): 1181 self["textfont"] = val 1182 1183 # textposition 1184 # ------------ 1185 @property 1186 def textposition(self): 1187 """ 1188 Sets the positions of the `text` elements with respects to the 1189 (x,y) coordinates. 1190 1191 The 'textposition' property is an enumeration that may be specified as: 1192 - One of the following enumeration values: 1193 ['top left', 'top center', 'top right', 'middle left', 1194 'middle center', 'middle right', 'bottom left', 'bottom 1195 center', 'bottom right'] 1196 - A tuple, list, or one-dimensional numpy array of the above 1197 1198 Returns 1199 ------- 1200 Any|numpy.ndarray 1201 """ 1202 return self["textposition"] 1203 1204 @textposition.setter 1205 def textposition(self, val): 1206 self["textposition"] = val 1207 1208 # textpositionsrc 1209 # --------------- 1210 @property 1211 def textpositionsrc(self): 1212 """ 1213 Sets the source reference on Chart Studio Cloud for 1214 textposition . 1215 1216 The 'textpositionsrc' property must be specified as a string or 1217 as a plotly.grid_objs.Column object 1218 1219 Returns 1220 ------- 1221 str 1222 """ 1223 return self["textpositionsrc"] 1224 1225 @textpositionsrc.setter 1226 def textpositionsrc(self, val): 1227 self["textpositionsrc"] = val 1228 1229 # textsrc 1230 # ------- 1231 @property 1232 def textsrc(self): 1233 """ 1234 Sets the source reference on Chart Studio Cloud for text . 1235 1236 The 'textsrc' property must be specified as a string or 1237 as a plotly.grid_objs.Column object 1238 1239 Returns 1240 ------- 1241 str 1242 """ 1243 return self["textsrc"] 1244 1245 @textsrc.setter 1246 def textsrc(self, val): 1247 self["textsrc"] = val 1248 1249 # texttemplate 1250 # ------------ 1251 @property 1252 def texttemplate(self): 1253 """ 1254 Template string used for rendering the information text that 1255 appear on points. Note that this will override `textinfo`. 1256 Variables are inserted using %{variable}, for example "y: 1257 %{y}". Numbers are formatted using d3-format's syntax 1258 %{variable:d3-format}, for example "Price: %{y:$.2f}". 1259 https://github.com/d3/d3-3.x-api- 1260 reference/blob/master/Formatting.md#d3_format for details on 1261 the formatting syntax. Dates are formatted using d3-time- 1262 format's syntax %{variable|d3-time-format}, for example "Day: 1263 %{2019-01-01|%A}". https://github.com/d3/d3-time- 1264 format#locale_format for details on the date formatting syntax. 1265 Every attributes that can be specified per-point (the ones that 1266 are `arrayOk: true`) are available. variables `r`, `theta` and 1267 `text`. 1268 1269 The 'texttemplate' property is a string and must be specified as: 1270 - A string 1271 - A number that will be converted to a string 1272 - A tuple, list, or one-dimensional numpy array of the above 1273 1274 Returns 1275 ------- 1276 str|numpy.ndarray 1277 """ 1278 return self["texttemplate"] 1279 1280 @texttemplate.setter 1281 def texttemplate(self, val): 1282 self["texttemplate"] = val 1283 1284 # texttemplatesrc 1285 # --------------- 1286 @property 1287 def texttemplatesrc(self): 1288 """ 1289 Sets the source reference on Chart Studio Cloud for 1290 texttemplate . 1291 1292 The 'texttemplatesrc' property must be specified as a string or 1293 as a plotly.grid_objs.Column object 1294 1295 Returns 1296 ------- 1297 str 1298 """ 1299 return self["texttemplatesrc"] 1300 1301 @texttemplatesrc.setter 1302 def texttemplatesrc(self, val): 1303 self["texttemplatesrc"] = val 1304 1305 # theta 1306 # ----- 1307 @property 1308 def theta(self): 1309 """ 1310 Sets the angular coordinates 1311 1312 The 'theta' property is an array that may be specified as a tuple, 1313 list, numpy array, or pandas Series 1314 1315 Returns 1316 ------- 1317 numpy.ndarray 1318 """ 1319 return self["theta"] 1320 1321 @theta.setter 1322 def theta(self, val): 1323 self["theta"] = val 1324 1325 # theta0 1326 # ------ 1327 @property 1328 def theta0(self): 1329 """ 1330 Alternate to `theta`. Builds a linear space of theta 1331 coordinates. Use with `dtheta` where `theta0` is the starting 1332 coordinate and `dtheta` the step. 1333 1334 The 'theta0' property accepts values of any type 1335 1336 Returns 1337 ------- 1338 Any 1339 """ 1340 return self["theta0"] 1341 1342 @theta0.setter 1343 def theta0(self, val): 1344 self["theta0"] = val 1345 1346 # thetasrc 1347 # -------- 1348 @property 1349 def thetasrc(self): 1350 """ 1351 Sets the source reference on Chart Studio Cloud for theta . 1352 1353 The 'thetasrc' property must be specified as a string or 1354 as a plotly.grid_objs.Column object 1355 1356 Returns 1357 ------- 1358 str 1359 """ 1360 return self["thetasrc"] 1361 1362 @thetasrc.setter 1363 def thetasrc(self, val): 1364 self["thetasrc"] = val 1365 1366 # thetaunit 1367 # --------- 1368 @property 1369 def thetaunit(self): 1370 """ 1371 Sets the unit of input "theta" values. Has an effect only when 1372 on "linear" angular axes. 1373 1374 The 'thetaunit' property is an enumeration that may be specified as: 1375 - One of the following enumeration values: 1376 ['radians', 'degrees', 'gradians'] 1377 1378 Returns 1379 ------- 1380 Any 1381 """ 1382 return self["thetaunit"] 1383 1384 @thetaunit.setter 1385 def thetaunit(self, val): 1386 self["thetaunit"] = val 1387 1388 # uid 1389 # --- 1390 @property 1391 def uid(self): 1392 """ 1393 Assign an id to this trace, Use this to provide object 1394 constancy between traces during animations and transitions. 1395 1396 The 'uid' property is a string and must be specified as: 1397 - A string 1398 - A number that will be converted to a string 1399 1400 Returns 1401 ------- 1402 str 1403 """ 1404 return self["uid"] 1405 1406 @uid.setter 1407 def uid(self, val): 1408 self["uid"] = val 1409 1410 # uirevision 1411 # ---------- 1412 @property 1413 def uirevision(self): 1414 """ 1415 Controls persistence of some user-driven changes to the trace: 1416 `constraintrange` in `parcoords` traces, as well as some 1417 `editable: true` modifications such as `name` and 1418 `colorbar.title`. Defaults to `layout.uirevision`. Note that 1419 other user-driven trace attribute changes are controlled by 1420 `layout` attributes: `trace.visible` is controlled by 1421 `layout.legend.uirevision`, `selectedpoints` is controlled by 1422 `layout.selectionrevision`, and `colorbar.(x|y)` (accessible 1423 with `config: {editable: true}`) is controlled by 1424 `layout.editrevision`. Trace changes are tracked by `uid`, 1425 which only falls back on trace index if no `uid` is provided. 1426 So if your app can add/remove traces before the end of the 1427 `data` array, such that the same trace has a different index, 1428 you can still preserve user-driven changes if you give each 1429 trace a `uid` that stays with it as it moves. 1430 1431 The 'uirevision' property accepts values of any type 1432 1433 Returns 1434 ------- 1435 Any 1436 """ 1437 return self["uirevision"] 1438 1439 @uirevision.setter 1440 def uirevision(self, val): 1441 self["uirevision"] = val 1442 1443 # unselected 1444 # ---------- 1445 @property 1446 def unselected(self): 1447 """ 1448 The 'unselected' property is an instance of Unselected 1449 that may be specified as: 1450 - An instance of :class:`plotly.graph_objs.scatterpolar.Unselected` 1451 - A dict of string/value properties that will be passed 1452 to the Unselected constructor 1453 1454 Supported dict properties: 1455 1456 marker 1457 :class:`plotly.graph_objects.scatterpolar.unsel 1458 ected.Marker` instance or dict with compatible 1459 properties 1460 textfont 1461 :class:`plotly.graph_objects.scatterpolar.unsel 1462 ected.Textfont` instance or dict with 1463 compatible properties 1464 1465 Returns 1466 ------- 1467 plotly.graph_objs.scatterpolar.Unselected 1468 """ 1469 return self["unselected"] 1470 1471 @unselected.setter 1472 def unselected(self, val): 1473 self["unselected"] = val 1474 1475 # visible 1476 # ------- 1477 @property 1478 def visible(self): 1479 """ 1480 Determines whether or not this trace is visible. If 1481 "legendonly", the trace is not drawn, but can appear as a 1482 legend item (provided that the legend itself is visible). 1483 1484 The 'visible' property is an enumeration that may be specified as: 1485 - One of the following enumeration values: 1486 [True, False, 'legendonly'] 1487 1488 Returns 1489 ------- 1490 Any 1491 """ 1492 return self["visible"] 1493 1494 @visible.setter 1495 def visible(self, val): 1496 self["visible"] = val 1497 1498 # type 1499 # ---- 1500 @property 1501 def type(self): 1502 return self._props["type"] 1503 1504 # Self properties description 1505 # --------------------------- 1506 @property 1507 def _prop_descriptions(self): 1508 return """\ 1509 cliponaxis 1510 Determines whether or not markers and text nodes are 1511 clipped about the subplot axes. To show markers and 1512 text nodes above axis lines and tick labels, make sure 1513 to set `xaxis.layer` and `yaxis.layer` to *below 1514 traces*. 1515 connectgaps 1516 Determines whether or not gaps (i.e. {nan} or missing 1517 values) in the provided data arrays are connected. 1518 customdata 1519 Assigns extra data each datum. This may be useful when 1520 listening to hover, click and selection events. Note 1521 that, "scatter" traces also appends customdata items in 1522 the markers DOM elements 1523 customdatasrc 1524 Sets the source reference on Chart Studio Cloud for 1525 customdata . 1526 dr 1527 Sets the r coordinate step. 1528 dtheta 1529 Sets the theta coordinate step. By default, the 1530 `dtheta` step equals the subplot's period divided by 1531 the length of the `r` coordinates. 1532 fill 1533 Sets the area to fill with a solid color. Use with 1534 `fillcolor` if not "none". scatterpolar has a subset of 1535 the options available to scatter. "toself" connects the 1536 endpoints of the trace (or each segment of the trace if 1537 it has gaps) into a closed shape. "tonext" fills the 1538 space between two traces if one completely encloses the 1539 other (eg consecutive contour lines), and behaves like 1540 "toself" if there is no trace before it. "tonext" 1541 should not be used if one trace does not enclose the 1542 other. 1543 fillcolor 1544 Sets the fill color. Defaults to a half-transparent 1545 variant of the line color, marker color, or marker line 1546 color, whichever is available. 1547 hoverinfo 1548 Determines which trace information appear on hover. If 1549 `none` or `skip` are set, no information is displayed 1550 upon hovering. But, if `none` is set, click and hover 1551 events are still fired. 1552 hoverinfosrc 1553 Sets the source reference on Chart Studio Cloud for 1554 hoverinfo . 1555 hoverlabel 1556 :class:`plotly.graph_objects.scatterpolar.Hoverlabel` 1557 instance or dict with compatible properties 1558 hoveron 1559 Do the hover effects highlight individual points 1560 (markers or line points) or do they highlight filled 1561 regions? If the fill is "toself" or "tonext" and there 1562 are no markers or text, then the default is "fills", 1563 otherwise it is "points". 1564 hovertemplate 1565 Template string used for rendering the information that 1566 appear on hover box. Note that this will override 1567 `hoverinfo`. Variables are inserted using %{variable}, 1568 for example "y: %{y}". Numbers are formatted using 1569 d3-format's syntax %{variable:d3-format}, for example 1570 "Price: %{y:$.2f}". https://github.com/d3/d3-3.x-api- 1571 reference/blob/master/Formatting.md#d3_format for 1572 details on the formatting syntax. Dates are formatted 1573 using d3-time-format's syntax %{variable|d3-time- 1574 format}, for example "Day: %{2019-01-01|%A}". 1575 https://github.com/d3/d3-time-format#locale_format for 1576 details on the date formatting syntax. The variables 1577 available in `hovertemplate` are the ones emitted as 1578 event data described at this link 1579 https://plotly.com/javascript/plotlyjs-events/#event- 1580 data. Additionally, every attributes that can be 1581 specified per-point (the ones that are `arrayOk: true`) 1582 are available. Anything contained in tag `<extra>` is 1583 displayed in the secondary box, for example 1584 "<extra>{fullData.name}</extra>". To hide the secondary 1585 box completely, use an empty tag `<extra></extra>`. 1586 hovertemplatesrc 1587 Sets the source reference on Chart Studio Cloud for 1588 hovertemplate . 1589 hovertext 1590 Sets hover text elements associated with each (x,y) 1591 pair. If a single string, the same string appears over 1592 all the data points. If an array of string, the items 1593 are mapped in order to the this trace's (x,y) 1594 coordinates. To be seen, trace `hoverinfo` must contain 1595 a "text" flag. 1596 hovertextsrc 1597 Sets the source reference on Chart Studio Cloud for 1598 hovertext . 1599 ids 1600 Assigns id labels to each datum. These ids for object 1601 constancy of data points during animation. Should be an 1602 array of strings, not numbers or any other type. 1603 idssrc 1604 Sets the source reference on Chart Studio Cloud for 1605 ids . 1606 legendgroup 1607 Sets the legend group for this trace. Traces part of 1608 the same legend group hide/show at the same time when 1609 toggling legend items. 1610 line 1611 :class:`plotly.graph_objects.scatterpolar.Line` 1612 instance or dict with compatible properties 1613 marker 1614 :class:`plotly.graph_objects.scatterpolar.Marker` 1615 instance or dict with compatible properties 1616 meta 1617 Assigns extra meta information associated with this 1618 trace that can be used in various text attributes. 1619 Attributes such as trace `name`, graph, axis and 1620 colorbar `title.text`, annotation `text` 1621 `rangeselector`, `updatemenues` and `sliders` `label` 1622 text all support `meta`. To access the trace `meta` 1623 values in an attribute in the same trace, simply use 1624 `%{meta[i]}` where `i` is the index or key of the 1625 `meta` item in question. To access trace `meta` in 1626 layout attributes, use `%{data[n[.meta[i]}` where `i` 1627 is the index or key of the `meta` and `n` is the trace 1628 index. 1629 metasrc 1630 Sets the source reference on Chart Studio Cloud for 1631 meta . 1632 mode 1633 Determines the drawing mode for this scatter trace. If 1634 the provided `mode` includes "text" then the `text` 1635 elements appear at the coordinates. Otherwise, the 1636 `text` elements appear on hover. If there are less than 1637 20 points and the trace is not stacked then the default 1638 is "lines+markers". Otherwise, "lines". 1639 name 1640 Sets the trace name. The trace name appear as the 1641 legend item and on hover. 1642 opacity 1643 Sets the opacity of the trace. 1644 r 1645 Sets the radial coordinates 1646 r0 1647 Alternate to `r`. Builds a linear space of r 1648 coordinates. Use with `dr` where `r0` is the starting 1649 coordinate and `dr` the step. 1650 rsrc 1651 Sets the source reference on Chart Studio Cloud for r 1652 . 1653 selected 1654 :class:`plotly.graph_objects.scatterpolar.Selected` 1655 instance or dict with compatible properties 1656 selectedpoints 1657 Array containing integer indices of selected points. 1658 Has an effect only for traces that support selections. 1659 Note that an empty array means an empty selection where 1660 the `unselected` are turned on for all points, whereas, 1661 any other non-array values means no selection all where 1662 the `selected` and `unselected` styles have no effect. 1663 showlegend 1664 Determines whether or not an item corresponding to this 1665 trace is shown in the legend. 1666 stream 1667 :class:`plotly.graph_objects.scatterpolar.Stream` 1668 instance or dict with compatible properties 1669 subplot 1670 Sets a reference between this trace's data coordinates 1671 and a polar subplot. If "polar" (the default value), 1672 the data refer to `layout.polar`. If "polar2", the data 1673 refer to `layout.polar2`, and so on. 1674 text 1675 Sets text elements associated with each (x,y) pair. If 1676 a single string, the same string appears over all the 1677 data points. If an array of string, the items are 1678 mapped in order to the this trace's (x,y) coordinates. 1679 If trace `hoverinfo` contains a "text" flag and 1680 "hovertext" is not set, these elements will be seen in 1681 the hover labels. 1682 textfont 1683 Sets the text font. 1684 textposition 1685 Sets the positions of the `text` elements with respects 1686 to the (x,y) coordinates. 1687 textpositionsrc 1688 Sets the source reference on Chart Studio Cloud for 1689 textposition . 1690 textsrc 1691 Sets the source reference on Chart Studio Cloud for 1692 text . 1693 texttemplate 1694 Template string used for rendering the information text 1695 that appear on points. Note that this will override 1696 `textinfo`. Variables are inserted using %{variable}, 1697 for example "y: %{y}". Numbers are formatted using 1698 d3-format's syntax %{variable:d3-format}, for example 1699 "Price: %{y:$.2f}". https://github.com/d3/d3-3.x-api- 1700 reference/blob/master/Formatting.md#d3_format for 1701 details on the formatting syntax. Dates are formatted 1702 using d3-time-format's syntax %{variable|d3-time- 1703 format}, for example "Day: %{2019-01-01|%A}". 1704 https://github.com/d3/d3-time-format#locale_format for 1705 details on the date formatting syntax. Every attributes 1706 that can be specified per-point (the ones that are 1707 `arrayOk: true`) are available. variables `r`, `theta` 1708 and `text`. 1709 texttemplatesrc 1710 Sets the source reference on Chart Studio Cloud for 1711 texttemplate . 1712 theta 1713 Sets the angular coordinates 1714 theta0 1715 Alternate to `theta`. Builds a linear space of theta 1716 coordinates. Use with `dtheta` where `theta0` is the 1717 starting coordinate and `dtheta` the step. 1718 thetasrc 1719 Sets the source reference on Chart Studio Cloud for 1720 theta . 1721 thetaunit 1722 Sets the unit of input "theta" values. Has an effect 1723 only when on "linear" angular axes. 1724 uid 1725 Assign an id to this trace, Use this to provide object 1726 constancy between traces during animations and 1727 transitions. 1728 uirevision 1729 Controls persistence of some user-driven changes to the 1730 trace: `constraintrange` in `parcoords` traces, as well 1731 as some `editable: true` modifications such as `name` 1732 and `colorbar.title`. Defaults to `layout.uirevision`. 1733 Note that other user-driven trace attribute changes are 1734 controlled by `layout` attributes: `trace.visible` is 1735 controlled by `layout.legend.uirevision`, 1736 `selectedpoints` is controlled by 1737 `layout.selectionrevision`, and `colorbar.(x|y)` 1738 (accessible with `config: {editable: true}`) is 1739 controlled by `layout.editrevision`. Trace changes are 1740 tracked by `uid`, which only falls back on trace index 1741 if no `uid` is provided. So if your app can add/remove 1742 traces before the end of the `data` array, such that 1743 the same trace has a different index, you can still 1744 preserve user-driven changes if you give each trace a 1745 `uid` that stays with it as it moves. 1746 unselected 1747 :class:`plotly.graph_objects.scatterpolar.Unselected` 1748 instance or dict with compatible properties 1749 visible 1750 Determines whether or not this trace is visible. If 1751 "legendonly", the trace is not drawn, but can appear as 1752 a legend item (provided that the legend itself is 1753 visible). 1754 """ 1755 1756 def __init__( 1757 self, 1758 arg=None, 1759 cliponaxis=None, 1760 connectgaps=None, 1761 customdata=None, 1762 customdatasrc=None, 1763 dr=None, 1764 dtheta=None, 1765 fill=None, 1766 fillcolor=None, 1767 hoverinfo=None, 1768 hoverinfosrc=None, 1769 hoverlabel=None, 1770 hoveron=None, 1771 hovertemplate=None, 1772 hovertemplatesrc=None, 1773 hovertext=None, 1774 hovertextsrc=None, 1775 ids=None, 1776 idssrc=None, 1777 legendgroup=None, 1778 line=None, 1779 marker=None, 1780 meta=None, 1781 metasrc=None, 1782 mode=None, 1783 name=None, 1784 opacity=None, 1785 r=None, 1786 r0=None, 1787 rsrc=None, 1788 selected=None, 1789 selectedpoints=None, 1790 showlegend=None, 1791 stream=None, 1792 subplot=None, 1793 text=None, 1794 textfont=None, 1795 textposition=None, 1796 textpositionsrc=None, 1797 textsrc=None, 1798 texttemplate=None, 1799 texttemplatesrc=None, 1800 theta=None, 1801 theta0=None, 1802 thetasrc=None, 1803 thetaunit=None, 1804 uid=None, 1805 uirevision=None, 1806 unselected=None, 1807 visible=None, 1808 **kwargs 1809 ): 1810 """ 1811 Construct a new Scatterpolar object 1812 1813 The scatterpolar trace type encompasses line charts, scatter 1814 charts, text charts, and bubble charts in polar coordinates. 1815 The data visualized as scatter point or lines is set in `r` 1816 (radial) and `theta` (angular) coordinates Text (appearing 1817 either on the chart or on hover only) is via `text`. Bubble 1818 charts are achieved by setting `marker.size` and/or 1819 `marker.color` to numerical arrays. 1820 1821 Parameters 1822 ---------- 1823 arg 1824 dict of properties compatible with this constructor or 1825 an instance of :class:`plotly.graph_objs.Scatterpolar` 1826 cliponaxis 1827 Determines whether or not markers and text nodes are 1828 clipped about the subplot axes. To show markers and 1829 text nodes above axis lines and tick labels, make sure 1830 to set `xaxis.layer` and `yaxis.layer` to *below 1831 traces*. 1832 connectgaps 1833 Determines whether or not gaps (i.e. {nan} or missing 1834 values) in the provided data arrays are connected. 1835 customdata 1836 Assigns extra data each datum. This may be useful when 1837 listening to hover, click and selection events. Note 1838 that, "scatter" traces also appends customdata items in 1839 the markers DOM elements 1840 customdatasrc 1841 Sets the source reference on Chart Studio Cloud for 1842 customdata . 1843 dr 1844 Sets the r coordinate step. 1845 dtheta 1846 Sets the theta coordinate step. By default, the 1847 `dtheta` step equals the subplot's period divided by 1848 the length of the `r` coordinates. 1849 fill 1850 Sets the area to fill with a solid color. Use with 1851 `fillcolor` if not "none". scatterpolar has a subset of 1852 the options available to scatter. "toself" connects the 1853 endpoints of the trace (or each segment of the trace if 1854 it has gaps) into a closed shape. "tonext" fills the 1855 space between two traces if one completely encloses the 1856 other (eg consecutive contour lines), and behaves like 1857 "toself" if there is no trace before it. "tonext" 1858 should not be used if one trace does not enclose the 1859 other. 1860 fillcolor 1861 Sets the fill color. Defaults to a half-transparent 1862 variant of the line color, marker color, or marker line 1863 color, whichever is available. 1864 hoverinfo 1865 Determines which trace information appear on hover. If 1866 `none` or `skip` are set, no information is displayed 1867 upon hovering. But, if `none` is set, click and hover 1868 events are still fired. 1869 hoverinfosrc 1870 Sets the source reference on Chart Studio Cloud for 1871 hoverinfo . 1872 hoverlabel 1873 :class:`plotly.graph_objects.scatterpolar.Hoverlabel` 1874 instance or dict with compatible properties 1875 hoveron 1876 Do the hover effects highlight individual points 1877 (markers or line points) or do they highlight filled 1878 regions? If the fill is "toself" or "tonext" and there 1879 are no markers or text, then the default is "fills", 1880 otherwise it is "points". 1881 hovertemplate 1882 Template string used for rendering the information that 1883 appear on hover box. Note that this will override 1884 `hoverinfo`. Variables are inserted using %{variable}, 1885 for example "y: %{y}". Numbers are formatted using 1886 d3-format's syntax %{variable:d3-format}, for example 1887 "Price: %{y:$.2f}". https://github.com/d3/d3-3.x-api- 1888 reference/blob/master/Formatting.md#d3_format for 1889 details on the formatting syntax. Dates are formatted 1890 using d3-time-format's syntax %{variable|d3-time- 1891 format}, for example "Day: %{2019-01-01|%A}". 1892 https://github.com/d3/d3-time-format#locale_format for 1893 details on the date formatting syntax. The variables 1894 available in `hovertemplate` are the ones emitted as 1895 event data described at this link 1896 https://plotly.com/javascript/plotlyjs-events/#event- 1897 data. Additionally, every attributes that can be 1898 specified per-point (the ones that are `arrayOk: true`) 1899 are available. Anything contained in tag `<extra>` is 1900 displayed in the secondary box, for example 1901 "<extra>{fullData.name}</extra>". To hide the secondary 1902 box completely, use an empty tag `<extra></extra>`. 1903 hovertemplatesrc 1904 Sets the source reference on Chart Studio Cloud for 1905 hovertemplate . 1906 hovertext 1907 Sets hover text elements associated with each (x,y) 1908 pair. If a single string, the same string appears over 1909 all the data points. If an array of string, the items 1910 are mapped in order to the this trace's (x,y) 1911 coordinates. To be seen, trace `hoverinfo` must contain 1912 a "text" flag. 1913 hovertextsrc 1914 Sets the source reference on Chart Studio Cloud for 1915 hovertext . 1916 ids 1917 Assigns id labels to each datum. These ids for object 1918 constancy of data points during animation. Should be an 1919 array of strings, not numbers or any other type. 1920 idssrc 1921 Sets the source reference on Chart Studio Cloud for 1922 ids . 1923 legendgroup 1924 Sets the legend group for this trace. Traces part of 1925 the same legend group hide/show at the same time when 1926 toggling legend items. 1927 line 1928 :class:`plotly.graph_objects.scatterpolar.Line` 1929 instance or dict with compatible properties 1930 marker 1931 :class:`plotly.graph_objects.scatterpolar.Marker` 1932 instance or dict with compatible properties 1933 meta 1934 Assigns extra meta information associated with this 1935 trace that can be used in various text attributes. 1936 Attributes such as trace `name`, graph, axis and 1937 colorbar `title.text`, annotation `text` 1938 `rangeselector`, `updatemenues` and `sliders` `label` 1939 text all support `meta`. To access the trace `meta` 1940 values in an attribute in the same trace, simply use 1941 `%{meta[i]}` where `i` is the index or key of the 1942 `meta` item in question. To access trace `meta` in 1943 layout attributes, use `%{data[n[.meta[i]}` where `i` 1944 is the index or key of the `meta` and `n` is the trace 1945 index. 1946 metasrc 1947 Sets the source reference on Chart Studio Cloud for 1948 meta . 1949 mode 1950 Determines the drawing mode for this scatter trace. If 1951 the provided `mode` includes "text" then the `text` 1952 elements appear at the coordinates. Otherwise, the 1953 `text` elements appear on hover. If there are less than 1954 20 points and the trace is not stacked then the default 1955 is "lines+markers". Otherwise, "lines". 1956 name 1957 Sets the trace name. The trace name appear as the 1958 legend item and on hover. 1959 opacity 1960 Sets the opacity of the trace. 1961 r 1962 Sets the radial coordinates 1963 r0 1964 Alternate to `r`. Builds a linear space of r 1965 coordinates. Use with `dr` where `r0` is the starting 1966 coordinate and `dr` the step. 1967 rsrc 1968 Sets the source reference on Chart Studio Cloud for r 1969 . 1970 selected 1971 :class:`plotly.graph_objects.scatterpolar.Selected` 1972 instance or dict with compatible properties 1973 selectedpoints 1974 Array containing integer indices of selected points. 1975 Has an effect only for traces that support selections. 1976 Note that an empty array means an empty selection where 1977 the `unselected` are turned on for all points, whereas, 1978 any other non-array values means no selection all where 1979 the `selected` and `unselected` styles have no effect. 1980 showlegend 1981 Determines whether or not an item corresponding to this 1982 trace is shown in the legend. 1983 stream 1984 :class:`plotly.graph_objects.scatterpolar.Stream` 1985 instance or dict with compatible properties 1986 subplot 1987 Sets a reference between this trace's data coordinates 1988 and a polar subplot. If "polar" (the default value), 1989 the data refer to `layout.polar`. If "polar2", the data 1990 refer to `layout.polar2`, and so on. 1991 text 1992 Sets text elements associated with each (x,y) pair. If 1993 a single string, the same string appears over all the 1994 data points. If an array of string, the items are 1995 mapped in order to the this trace's (x,y) coordinates. 1996 If trace `hoverinfo` contains a "text" flag and 1997 "hovertext" is not set, these elements will be seen in 1998 the hover labels. 1999 textfont 2000 Sets the text font. 2001 textposition 2002 Sets the positions of the `text` elements with respects 2003 to the (x,y) coordinates. 2004 textpositionsrc 2005 Sets the source reference on Chart Studio Cloud for 2006 textposition . 2007 textsrc 2008 Sets the source reference on Chart Studio Cloud for 2009 text . 2010 texttemplate 2011 Template string used for rendering the information text 2012 that appear on points. Note that this will override 2013 `textinfo`. Variables are inserted using %{variable}, 2014 for example "y: %{y}". Numbers are formatted using 2015 d3-format's syntax %{variable:d3-format}, for example 2016 "Price: %{y:$.2f}". https://github.com/d3/d3-3.x-api- 2017 reference/blob/master/Formatting.md#d3_format for 2018 details on the formatting syntax. Dates are formatted 2019 using d3-time-format's syntax %{variable|d3-time- 2020 format}, for example "Day: %{2019-01-01|%A}". 2021 https://github.com/d3/d3-time-format#locale_format for 2022 details on the date formatting syntax. Every attributes 2023 that can be specified per-point (the ones that are 2024 `arrayOk: true`) are available. variables `r`, `theta` 2025 and `text`. 2026 texttemplatesrc 2027 Sets the source reference on Chart Studio Cloud for 2028 texttemplate . 2029 theta 2030 Sets the angular coordinates 2031 theta0 2032 Alternate to `theta`. Builds a linear space of theta 2033 coordinates. Use with `dtheta` where `theta0` is the 2034 starting coordinate and `dtheta` the step. 2035 thetasrc 2036 Sets the source reference on Chart Studio Cloud for 2037 theta . 2038 thetaunit 2039 Sets the unit of input "theta" values. Has an effect 2040 only when on "linear" angular axes. 2041 uid 2042 Assign an id to this trace, Use this to provide object 2043 constancy between traces during animations and 2044 transitions. 2045 uirevision 2046 Controls persistence of some user-driven changes to the 2047 trace: `constraintrange` in `parcoords` traces, as well 2048 as some `editable: true` modifications such as `name` 2049 and `colorbar.title`. Defaults to `layout.uirevision`. 2050 Note that other user-driven trace attribute changes are 2051 controlled by `layout` attributes: `trace.visible` is 2052 controlled by `layout.legend.uirevision`, 2053 `selectedpoints` is controlled by 2054 `layout.selectionrevision`, and `colorbar.(x|y)` 2055 (accessible with `config: {editable: true}`) is 2056 controlled by `layout.editrevision`. Trace changes are 2057 tracked by `uid`, which only falls back on trace index 2058 if no `uid` is provided. So if your app can add/remove 2059 traces before the end of the `data` array, such that 2060 the same trace has a different index, you can still 2061 preserve user-driven changes if you give each trace a 2062 `uid` that stays with it as it moves. 2063 unselected 2064 :class:`plotly.graph_objects.scatterpolar.Unselected` 2065 instance or dict with compatible properties 2066 visible 2067 Determines whether or not this trace is visible. If 2068 "legendonly", the trace is not drawn, but can appear as 2069 a legend item (provided that the legend itself is 2070 visible). 2071 2072 Returns 2073 ------- 2074 Scatterpolar 2075 """ 2076 super(Scatterpolar, self).__init__("scatterpolar") 2077 2078 if "_parent" in kwargs: 2079 self._parent = kwargs["_parent"] 2080 return 2081 2082 # Validate arg 2083 # ------------ 2084 if arg is None: 2085 arg = {} 2086 elif isinstance(arg, self.__class__): 2087 arg = arg.to_plotly_json() 2088 elif isinstance(arg, dict): 2089 arg = _copy.copy(arg) 2090 else: 2091 raise ValueError( 2092 """\ 2093The first argument to the plotly.graph_objs.Scatterpolar 2094constructor must be a dict or 2095an instance of :class:`plotly.graph_objs.Scatterpolar`""" 2096 ) 2097 2098 # Handle skip_invalid 2099 # ------------------- 2100 self._skip_invalid = kwargs.pop("skip_invalid", False) 2101 self._validate = kwargs.pop("_validate", True) 2102 2103 # Populate data dict with properties 2104 # ---------------------------------- 2105 _v = arg.pop("cliponaxis", None) 2106 _v = cliponaxis if cliponaxis is not None else _v 2107 if _v is not None: 2108 self["cliponaxis"] = _v 2109 _v = arg.pop("connectgaps", None) 2110 _v = connectgaps if connectgaps is not None else _v 2111 if _v is not None: 2112 self["connectgaps"] = _v 2113 _v = arg.pop("customdata", None) 2114 _v = customdata if customdata is not None else _v 2115 if _v is not None: 2116 self["customdata"] = _v 2117 _v = arg.pop("customdatasrc", None) 2118 _v = customdatasrc if customdatasrc is not None else _v 2119 if _v is not None: 2120 self["customdatasrc"] = _v 2121 _v = arg.pop("dr", None) 2122 _v = dr if dr is not None else _v 2123 if _v is not None: 2124 self["dr"] = _v 2125 _v = arg.pop("dtheta", None) 2126 _v = dtheta if dtheta is not None else _v 2127 if _v is not None: 2128 self["dtheta"] = _v 2129 _v = arg.pop("fill", None) 2130 _v = fill if fill is not None else _v 2131 if _v is not None: 2132 self["fill"] = _v 2133 _v = arg.pop("fillcolor", None) 2134 _v = fillcolor if fillcolor is not None else _v 2135 if _v is not None: 2136 self["fillcolor"] = _v 2137 _v = arg.pop("hoverinfo", None) 2138 _v = hoverinfo if hoverinfo is not None else _v 2139 if _v is not None: 2140 self["hoverinfo"] = _v 2141 _v = arg.pop("hoverinfosrc", None) 2142 _v = hoverinfosrc if hoverinfosrc is not None else _v 2143 if _v is not None: 2144 self["hoverinfosrc"] = _v 2145 _v = arg.pop("hoverlabel", None) 2146 _v = hoverlabel if hoverlabel is not None else _v 2147 if _v is not None: 2148 self["hoverlabel"] = _v 2149 _v = arg.pop("hoveron", None) 2150 _v = hoveron if hoveron is not None else _v 2151 if _v is not None: 2152 self["hoveron"] = _v 2153 _v = arg.pop("hovertemplate", None) 2154 _v = hovertemplate if hovertemplate is not None else _v 2155 if _v is not None: 2156 self["hovertemplate"] = _v 2157 _v = arg.pop("hovertemplatesrc", None) 2158 _v = hovertemplatesrc if hovertemplatesrc is not None else _v 2159 if _v is not None: 2160 self["hovertemplatesrc"] = _v 2161 _v = arg.pop("hovertext", None) 2162 _v = hovertext if hovertext is not None else _v 2163 if _v is not None: 2164 self["hovertext"] = _v 2165 _v = arg.pop("hovertextsrc", None) 2166 _v = hovertextsrc if hovertextsrc is not None else _v 2167 if _v is not None: 2168 self["hovertextsrc"] = _v 2169 _v = arg.pop("ids", None) 2170 _v = ids if ids is not None else _v 2171 if _v is not None: 2172 self["ids"] = _v 2173 _v = arg.pop("idssrc", None) 2174 _v = idssrc if idssrc is not None else _v 2175 if _v is not None: 2176 self["idssrc"] = _v 2177 _v = arg.pop("legendgroup", None) 2178 _v = legendgroup if legendgroup is not None else _v 2179 if _v is not None: 2180 self["legendgroup"] = _v 2181 _v = arg.pop("line", None) 2182 _v = line if line is not None else _v 2183 if _v is not None: 2184 self["line"] = _v 2185 _v = arg.pop("marker", None) 2186 _v = marker if marker is not None else _v 2187 if _v is not None: 2188 self["marker"] = _v 2189 _v = arg.pop("meta", None) 2190 _v = meta if meta is not None else _v 2191 if _v is not None: 2192 self["meta"] = _v 2193 _v = arg.pop("metasrc", None) 2194 _v = metasrc if metasrc is not None else _v 2195 if _v is not None: 2196 self["metasrc"] = _v 2197 _v = arg.pop("mode", None) 2198 _v = mode if mode is not None else _v 2199 if _v is not None: 2200 self["mode"] = _v 2201 _v = arg.pop("name", None) 2202 _v = name if name is not None else _v 2203 if _v is not None: 2204 self["name"] = _v 2205 _v = arg.pop("opacity", None) 2206 _v = opacity if opacity is not None else _v 2207 if _v is not None: 2208 self["opacity"] = _v 2209 _v = arg.pop("r", None) 2210 _v = r if r is not None else _v 2211 if _v is not None: 2212 self["r"] = _v 2213 _v = arg.pop("r0", None) 2214 _v = r0 if r0 is not None else _v 2215 if _v is not None: 2216 self["r0"] = _v 2217 _v = arg.pop("rsrc", None) 2218 _v = rsrc if rsrc is not None else _v 2219 if _v is not None: 2220 self["rsrc"] = _v 2221 _v = arg.pop("selected", None) 2222 _v = selected if selected is not None else _v 2223 if _v is not None: 2224 self["selected"] = _v 2225 _v = arg.pop("selectedpoints", None) 2226 _v = selectedpoints if selectedpoints is not None else _v 2227 if _v is not None: 2228 self["selectedpoints"] = _v 2229 _v = arg.pop("showlegend", None) 2230 _v = showlegend if showlegend is not None else _v 2231 if _v is not None: 2232 self["showlegend"] = _v 2233 _v = arg.pop("stream", None) 2234 _v = stream if stream is not None else _v 2235 if _v is not None: 2236 self["stream"] = _v 2237 _v = arg.pop("subplot", None) 2238 _v = subplot if subplot is not None else _v 2239 if _v is not None: 2240 self["subplot"] = _v 2241 _v = arg.pop("text", None) 2242 _v = text if text is not None else _v 2243 if _v is not None: 2244 self["text"] = _v 2245 _v = arg.pop("textfont", None) 2246 _v = textfont if textfont is not None else _v 2247 if _v is not None: 2248 self["textfont"] = _v 2249 _v = arg.pop("textposition", None) 2250 _v = textposition if textposition is not None else _v 2251 if _v is not None: 2252 self["textposition"] = _v 2253 _v = arg.pop("textpositionsrc", None) 2254 _v = textpositionsrc if textpositionsrc is not None else _v 2255 if _v is not None: 2256 self["textpositionsrc"] = _v 2257 _v = arg.pop("textsrc", None) 2258 _v = textsrc if textsrc is not None else _v 2259 if _v is not None: 2260 self["textsrc"] = _v 2261 _v = arg.pop("texttemplate", None) 2262 _v = texttemplate if texttemplate is not None else _v 2263 if _v is not None: 2264 self["texttemplate"] = _v 2265 _v = arg.pop("texttemplatesrc", None) 2266 _v = texttemplatesrc if texttemplatesrc is not None else _v 2267 if _v is not None: 2268 self["texttemplatesrc"] = _v 2269 _v = arg.pop("theta", None) 2270 _v = theta if theta is not None else _v 2271 if _v is not None: 2272 self["theta"] = _v 2273 _v = arg.pop("theta0", None) 2274 _v = theta0 if theta0 is not None else _v 2275 if _v is not None: 2276 self["theta0"] = _v 2277 _v = arg.pop("thetasrc", None) 2278 _v = thetasrc if thetasrc is not None else _v 2279 if _v is not None: 2280 self["thetasrc"] = _v 2281 _v = arg.pop("thetaunit", None) 2282 _v = thetaunit if thetaunit is not None else _v 2283 if _v is not None: 2284 self["thetaunit"] = _v 2285 _v = arg.pop("uid", None) 2286 _v = uid if uid is not None else _v 2287 if _v is not None: 2288 self["uid"] = _v 2289 _v = arg.pop("uirevision", None) 2290 _v = uirevision if uirevision is not None else _v 2291 if _v is not None: 2292 self["uirevision"] = _v 2293 _v = arg.pop("unselected", None) 2294 _v = unselected if unselected is not None else _v 2295 if _v is not None: 2296 self["unselected"] = _v 2297 _v = arg.pop("visible", None) 2298 _v = visible if visible is not None else _v 2299 if _v is not None: 2300 self["visible"] = _v 2301 2302 # Read-only literals 2303 # ------------------ 2304 2305 self._props["type"] = "scatterpolar" 2306 arg.pop("type", None) 2307 2308 # Process unknown kwargs 2309 # ---------------------- 2310 self._process_kwargs(**dict(arg, **kwargs)) 2311 2312 # Reset skip_invalid 2313 # ------------------ 2314 self._skip_invalid = False 2315