1from plotly.basedatatypes import BaseLayoutHierarchyType as _BaseLayoutHierarchyType 2import copy as _copy 3 4 5class Slider(_BaseLayoutHierarchyType): 6 7 # class properties 8 # -------------------- 9 _parent_path_str = "layout" 10 _path_str = "layout.slider" 11 _valid_props = { 12 "active", 13 "activebgcolor", 14 "bgcolor", 15 "bordercolor", 16 "borderwidth", 17 "currentvalue", 18 "font", 19 "len", 20 "lenmode", 21 "minorticklen", 22 "name", 23 "pad", 24 "stepdefaults", 25 "steps", 26 "templateitemname", 27 "tickcolor", 28 "ticklen", 29 "tickwidth", 30 "transition", 31 "visible", 32 "x", 33 "xanchor", 34 "y", 35 "yanchor", 36 } 37 38 # active 39 # ------ 40 @property 41 def active(self): 42 """ 43 Determines which button (by index starting from 0) is 44 considered active. 45 46 The 'active' property is a number and may be specified as: 47 - An int or float in the interval [0, inf] 48 49 Returns 50 ------- 51 int|float 52 """ 53 return self["active"] 54 55 @active.setter 56 def active(self, val): 57 self["active"] = val 58 59 # activebgcolor 60 # ------------- 61 @property 62 def activebgcolor(self): 63 """ 64 Sets the background color of the slider grip while dragging. 65 66 The 'activebgcolor' property is a color and may be specified as: 67 - A hex string (e.g. '#ff0000') 68 - An rgb/rgba string (e.g. 'rgb(255,0,0)') 69 - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') 70 - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') 71 - A named CSS color: 72 aliceblue, antiquewhite, aqua, aquamarine, azure, 73 beige, bisque, black, blanchedalmond, blue, 74 blueviolet, brown, burlywood, cadetblue, 75 chartreuse, chocolate, coral, cornflowerblue, 76 cornsilk, crimson, cyan, darkblue, darkcyan, 77 darkgoldenrod, darkgray, darkgrey, darkgreen, 78 darkkhaki, darkmagenta, darkolivegreen, darkorange, 79 darkorchid, darkred, darksalmon, darkseagreen, 80 darkslateblue, darkslategray, darkslategrey, 81 darkturquoise, darkviolet, deeppink, deepskyblue, 82 dimgray, dimgrey, dodgerblue, firebrick, 83 floralwhite, forestgreen, fuchsia, gainsboro, 84 ghostwhite, gold, goldenrod, gray, grey, green, 85 greenyellow, honeydew, hotpink, indianred, indigo, 86 ivory, khaki, lavender, lavenderblush, lawngreen, 87 lemonchiffon, lightblue, lightcoral, lightcyan, 88 lightgoldenrodyellow, lightgray, lightgrey, 89 lightgreen, lightpink, lightsalmon, lightseagreen, 90 lightskyblue, lightslategray, lightslategrey, 91 lightsteelblue, lightyellow, lime, limegreen, 92 linen, magenta, maroon, mediumaquamarine, 93 mediumblue, mediumorchid, mediumpurple, 94 mediumseagreen, mediumslateblue, mediumspringgreen, 95 mediumturquoise, mediumvioletred, midnightblue, 96 mintcream, mistyrose, moccasin, navajowhite, navy, 97 oldlace, olive, olivedrab, orange, orangered, 98 orchid, palegoldenrod, palegreen, paleturquoise, 99 palevioletred, papayawhip, peachpuff, peru, pink, 100 plum, powderblue, purple, red, rosybrown, 101 royalblue, rebeccapurple, saddlebrown, salmon, 102 sandybrown, seagreen, seashell, sienna, silver, 103 skyblue, slateblue, slategray, slategrey, snow, 104 springgreen, steelblue, tan, teal, thistle, tomato, 105 turquoise, violet, wheat, white, whitesmoke, 106 yellow, yellowgreen 107 108 Returns 109 ------- 110 str 111 """ 112 return self["activebgcolor"] 113 114 @activebgcolor.setter 115 def activebgcolor(self, val): 116 self["activebgcolor"] = val 117 118 # bgcolor 119 # ------- 120 @property 121 def bgcolor(self): 122 """ 123 Sets the background color of the slider. 124 125 The 'bgcolor' property is a color and may be specified as: 126 - A hex string (e.g. '#ff0000') 127 - An rgb/rgba string (e.g. 'rgb(255,0,0)') 128 - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') 129 - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') 130 - A named CSS color: 131 aliceblue, antiquewhite, aqua, aquamarine, azure, 132 beige, bisque, black, blanchedalmond, blue, 133 blueviolet, brown, burlywood, cadetblue, 134 chartreuse, chocolate, coral, cornflowerblue, 135 cornsilk, crimson, cyan, darkblue, darkcyan, 136 darkgoldenrod, darkgray, darkgrey, darkgreen, 137 darkkhaki, darkmagenta, darkolivegreen, darkorange, 138 darkorchid, darkred, darksalmon, darkseagreen, 139 darkslateblue, darkslategray, darkslategrey, 140 darkturquoise, darkviolet, deeppink, deepskyblue, 141 dimgray, dimgrey, dodgerblue, firebrick, 142 floralwhite, forestgreen, fuchsia, gainsboro, 143 ghostwhite, gold, goldenrod, gray, grey, green, 144 greenyellow, honeydew, hotpink, indianred, indigo, 145 ivory, khaki, lavender, lavenderblush, lawngreen, 146 lemonchiffon, lightblue, lightcoral, lightcyan, 147 lightgoldenrodyellow, lightgray, lightgrey, 148 lightgreen, lightpink, lightsalmon, lightseagreen, 149 lightskyblue, lightslategray, lightslategrey, 150 lightsteelblue, lightyellow, lime, limegreen, 151 linen, magenta, maroon, mediumaquamarine, 152 mediumblue, mediumorchid, mediumpurple, 153 mediumseagreen, mediumslateblue, mediumspringgreen, 154 mediumturquoise, mediumvioletred, midnightblue, 155 mintcream, mistyrose, moccasin, navajowhite, navy, 156 oldlace, olive, olivedrab, orange, orangered, 157 orchid, palegoldenrod, palegreen, paleturquoise, 158 palevioletred, papayawhip, peachpuff, peru, pink, 159 plum, powderblue, purple, red, rosybrown, 160 royalblue, rebeccapurple, saddlebrown, salmon, 161 sandybrown, seagreen, seashell, sienna, silver, 162 skyblue, slateblue, slategray, slategrey, snow, 163 springgreen, steelblue, tan, teal, thistle, tomato, 164 turquoise, violet, wheat, white, whitesmoke, 165 yellow, yellowgreen 166 167 Returns 168 ------- 169 str 170 """ 171 return self["bgcolor"] 172 173 @bgcolor.setter 174 def bgcolor(self, val): 175 self["bgcolor"] = val 176 177 # bordercolor 178 # ----------- 179 @property 180 def bordercolor(self): 181 """ 182 Sets the color of the border enclosing the slider. 183 184 The 'bordercolor' property is a color and may be specified as: 185 - A hex string (e.g. '#ff0000') 186 - An rgb/rgba string (e.g. 'rgb(255,0,0)') 187 - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') 188 - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') 189 - A named CSS color: 190 aliceblue, antiquewhite, aqua, aquamarine, azure, 191 beige, bisque, black, blanchedalmond, blue, 192 blueviolet, brown, burlywood, cadetblue, 193 chartreuse, chocolate, coral, cornflowerblue, 194 cornsilk, crimson, cyan, darkblue, darkcyan, 195 darkgoldenrod, darkgray, darkgrey, darkgreen, 196 darkkhaki, darkmagenta, darkolivegreen, darkorange, 197 darkorchid, darkred, darksalmon, darkseagreen, 198 darkslateblue, darkslategray, darkslategrey, 199 darkturquoise, darkviolet, deeppink, deepskyblue, 200 dimgray, dimgrey, dodgerblue, firebrick, 201 floralwhite, forestgreen, fuchsia, gainsboro, 202 ghostwhite, gold, goldenrod, gray, grey, green, 203 greenyellow, honeydew, hotpink, indianred, indigo, 204 ivory, khaki, lavender, lavenderblush, lawngreen, 205 lemonchiffon, lightblue, lightcoral, lightcyan, 206 lightgoldenrodyellow, lightgray, lightgrey, 207 lightgreen, lightpink, lightsalmon, lightseagreen, 208 lightskyblue, lightslategray, lightslategrey, 209 lightsteelblue, lightyellow, lime, limegreen, 210 linen, magenta, maroon, mediumaquamarine, 211 mediumblue, mediumorchid, mediumpurple, 212 mediumseagreen, mediumslateblue, mediumspringgreen, 213 mediumturquoise, mediumvioletred, midnightblue, 214 mintcream, mistyrose, moccasin, navajowhite, navy, 215 oldlace, olive, olivedrab, orange, orangered, 216 orchid, palegoldenrod, palegreen, paleturquoise, 217 palevioletred, papayawhip, peachpuff, peru, pink, 218 plum, powderblue, purple, red, rosybrown, 219 royalblue, rebeccapurple, saddlebrown, salmon, 220 sandybrown, seagreen, seashell, sienna, silver, 221 skyblue, slateblue, slategray, slategrey, snow, 222 springgreen, steelblue, tan, teal, thistle, tomato, 223 turquoise, violet, wheat, white, whitesmoke, 224 yellow, yellowgreen 225 226 Returns 227 ------- 228 str 229 """ 230 return self["bordercolor"] 231 232 @bordercolor.setter 233 def bordercolor(self, val): 234 self["bordercolor"] = val 235 236 # borderwidth 237 # ----------- 238 @property 239 def borderwidth(self): 240 """ 241 Sets the width (in px) of the border enclosing the slider. 242 243 The 'borderwidth' property is a number and may be specified as: 244 - An int or float in the interval [0, inf] 245 246 Returns 247 ------- 248 int|float 249 """ 250 return self["borderwidth"] 251 252 @borderwidth.setter 253 def borderwidth(self, val): 254 self["borderwidth"] = val 255 256 # currentvalue 257 # ------------ 258 @property 259 def currentvalue(self): 260 """ 261 The 'currentvalue' property is an instance of Currentvalue 262 that may be specified as: 263 - An instance of :class:`plotly.graph_objs.layout.slider.Currentvalue` 264 - A dict of string/value properties that will be passed 265 to the Currentvalue constructor 266 267 Supported dict properties: 268 269 font 270 Sets the font of the current value label text. 271 offset 272 The amount of space, in pixels, between the 273 current value label and the slider. 274 prefix 275 When currentvalue.visible is true, this sets 276 the prefix of the label. 277 suffix 278 When currentvalue.visible is true, this sets 279 the suffix of the label. 280 visible 281 Shows the currently-selected value above the 282 slider. 283 xanchor 284 The alignment of the value readout relative to 285 the length of the slider. 286 287 Returns 288 ------- 289 plotly.graph_objs.layout.slider.Currentvalue 290 """ 291 return self["currentvalue"] 292 293 @currentvalue.setter 294 def currentvalue(self, val): 295 self["currentvalue"] = val 296 297 # font 298 # ---- 299 @property 300 def font(self): 301 """ 302 Sets the font of the slider step labels. 303 304 The 'font' property is an instance of Font 305 that may be specified as: 306 - An instance of :class:`plotly.graph_objs.layout.slider.Font` 307 - A dict of string/value properties that will be passed 308 to the Font constructor 309 310 Supported dict properties: 311 312 color 313 314 family 315 HTML font family - the typeface that will be 316 applied by the web browser. The web browser 317 will only be able to apply a font if it is 318 available on the system which it operates. 319 Provide multiple font families, separated by 320 commas, to indicate the preference in which to 321 apply fonts if they aren't available on the 322 system. The Chart Studio Cloud (at 323 https://chart-studio.plotly.com or on-premise) 324 generates images on a server, where only a 325 select number of fonts are installed and 326 supported. These include "Arial", "Balto", 327 "Courier New", "Droid Sans",, "Droid Serif", 328 "Droid Sans Mono", "Gravitas One", "Old 329 Standard TT", "Open Sans", "Overpass", "PT Sans 330 Narrow", "Raleway", "Times New Roman". 331 size 332 333 Returns 334 ------- 335 plotly.graph_objs.layout.slider.Font 336 """ 337 return self["font"] 338 339 @font.setter 340 def font(self, val): 341 self["font"] = val 342 343 # len 344 # --- 345 @property 346 def len(self): 347 """ 348 Sets the length of the slider This measure excludes the padding 349 of both ends. That is, the slider's length is this length minus 350 the padding on both ends. 351 352 The 'len' property is a number and may be specified as: 353 - An int or float in the interval [0, inf] 354 355 Returns 356 ------- 357 int|float 358 """ 359 return self["len"] 360 361 @len.setter 362 def len(self, val): 363 self["len"] = val 364 365 # lenmode 366 # ------- 367 @property 368 def lenmode(self): 369 """ 370 Determines whether this slider length is set in units of plot 371 "fraction" or in *pixels. Use `len` to set the value. 372 373 The 'lenmode' property is an enumeration that may be specified as: 374 - One of the following enumeration values: 375 ['fraction', 'pixels'] 376 377 Returns 378 ------- 379 Any 380 """ 381 return self["lenmode"] 382 383 @lenmode.setter 384 def lenmode(self, val): 385 self["lenmode"] = val 386 387 # minorticklen 388 # ------------ 389 @property 390 def minorticklen(self): 391 """ 392 Sets the length in pixels of minor step tick marks 393 394 The 'minorticklen' property is a number and may be specified as: 395 - An int or float in the interval [0, inf] 396 397 Returns 398 ------- 399 int|float 400 """ 401 return self["minorticklen"] 402 403 @minorticklen.setter 404 def minorticklen(self, val): 405 self["minorticklen"] = val 406 407 # name 408 # ---- 409 @property 410 def name(self): 411 """ 412 When used in a template, named items are created in the output 413 figure in addition to any items the figure already has in this 414 array. You can modify these items in the output figure by 415 making your own item with `templateitemname` matching this 416 `name` alongside your modifications (including `visible: false` 417 or `enabled: false` to hide it). Has no effect outside of a 418 template. 419 420 The 'name' property is a string and must be specified as: 421 - A string 422 - A number that will be converted to a string 423 424 Returns 425 ------- 426 str 427 """ 428 return self["name"] 429 430 @name.setter 431 def name(self, val): 432 self["name"] = val 433 434 # pad 435 # --- 436 @property 437 def pad(self): 438 """ 439 Set the padding of the slider component along each side. 440 441 The 'pad' property is an instance of Pad 442 that may be specified as: 443 - An instance of :class:`plotly.graph_objs.layout.slider.Pad` 444 - A dict of string/value properties that will be passed 445 to the Pad constructor 446 447 Supported dict properties: 448 449 b 450 The amount of padding (in px) along the bottom 451 of the component. 452 l 453 The amount of padding (in px) on the left side 454 of the component. 455 r 456 The amount of padding (in px) on the right side 457 of the component. 458 t 459 The amount of padding (in px) along the top of 460 the component. 461 462 Returns 463 ------- 464 plotly.graph_objs.layout.slider.Pad 465 """ 466 return self["pad"] 467 468 @pad.setter 469 def pad(self, val): 470 self["pad"] = val 471 472 # steps 473 # ----- 474 @property 475 def steps(self): 476 """ 477 The 'steps' property is a tuple of instances of 478 Step that may be specified as: 479 - A list or tuple of instances of plotly.graph_objs.layout.slider.Step 480 - A list or tuple of dicts of string/value properties that 481 will be passed to the Step constructor 482 483 Supported dict properties: 484 485 args 486 Sets the arguments values to be passed to the 487 Plotly method set in `method` on slide. 488 execute 489 When true, the API method is executed. When 490 false, all other behaviors are the same and 491 command execution is skipped. This may be 492 useful when hooking into, for example, the 493 `plotly_sliderchange` method and executing the 494 API command manually without losing the benefit 495 of the slider automatically binding to the 496 state of the plot through the specification of 497 `method` and `args`. 498 label 499 Sets the text label to appear on the slider 500 method 501 Sets the Plotly method to be called when the 502 slider value is changed. If the `skip` method 503 is used, the API slider will function as normal 504 but will perform no API calls and will not bind 505 automatically to state updates. This may be 506 used to create a component interface and attach 507 to slider events manually via JavaScript. 508 name 509 When used in a template, named items are 510 created in the output figure in addition to any 511 items the figure already has in this array. You 512 can modify these items in the output figure by 513 making your own item with `templateitemname` 514 matching this `name` alongside your 515 modifications (including `visible: false` or 516 `enabled: false` to hide it). Has no effect 517 outside of a template. 518 templateitemname 519 Used to refer to a named item in this array in 520 the template. Named items from the template 521 will be created even without a matching item in 522 the input figure, but you can modify one by 523 making an item with `templateitemname` matching 524 its `name`, alongside your modifications 525 (including `visible: false` or `enabled: false` 526 to hide it). If there is no template or no 527 matching item, this item will be hidden unless 528 you explicitly show it with `visible: true`. 529 value 530 Sets the value of the slider step, used to 531 refer to the step programatically. Defaults to 532 the slider label if not provided. 533 visible 534 Determines whether or not this step is included 535 in the slider. 536 537 Returns 538 ------- 539 tuple[plotly.graph_objs.layout.slider.Step] 540 """ 541 return self["steps"] 542 543 @steps.setter 544 def steps(self, val): 545 self["steps"] = val 546 547 # stepdefaults 548 # ------------ 549 @property 550 def stepdefaults(self): 551 """ 552 When used in a template (as 553 layout.template.layout.slider.stepdefaults), sets the default 554 property values to use for elements of layout.slider.steps 555 556 The 'stepdefaults' property is an instance of Step 557 that may be specified as: 558 - An instance of :class:`plotly.graph_objs.layout.slider.Step` 559 - A dict of string/value properties that will be passed 560 to the Step constructor 561 562 Supported dict properties: 563 564 Returns 565 ------- 566 plotly.graph_objs.layout.slider.Step 567 """ 568 return self["stepdefaults"] 569 570 @stepdefaults.setter 571 def stepdefaults(self, val): 572 self["stepdefaults"] = val 573 574 # templateitemname 575 # ---------------- 576 @property 577 def templateitemname(self): 578 """ 579 Used to refer to a named item in this array in the template. 580 Named items from the template will be created even without a 581 matching item in the input figure, but you can modify one by 582 making an item with `templateitemname` matching its `name`, 583 alongside your modifications (including `visible: false` or 584 `enabled: false` to hide it). If there is no template or no 585 matching item, this item will be hidden unless you explicitly 586 show it with `visible: true`. 587 588 The 'templateitemname' property is a string and must be specified as: 589 - A string 590 - A number that will be converted to a string 591 592 Returns 593 ------- 594 str 595 """ 596 return self["templateitemname"] 597 598 @templateitemname.setter 599 def templateitemname(self, val): 600 self["templateitemname"] = val 601 602 # tickcolor 603 # --------- 604 @property 605 def tickcolor(self): 606 """ 607 Sets the color of the border enclosing the slider. 608 609 The 'tickcolor' property is a color and may be specified as: 610 - A hex string (e.g. '#ff0000') 611 - An rgb/rgba string (e.g. 'rgb(255,0,0)') 612 - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') 613 - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') 614 - A named CSS color: 615 aliceblue, antiquewhite, aqua, aquamarine, azure, 616 beige, bisque, black, blanchedalmond, blue, 617 blueviolet, brown, burlywood, cadetblue, 618 chartreuse, chocolate, coral, cornflowerblue, 619 cornsilk, crimson, cyan, darkblue, darkcyan, 620 darkgoldenrod, darkgray, darkgrey, darkgreen, 621 darkkhaki, darkmagenta, darkolivegreen, darkorange, 622 darkorchid, darkred, darksalmon, darkseagreen, 623 darkslateblue, darkslategray, darkslategrey, 624 darkturquoise, darkviolet, deeppink, deepskyblue, 625 dimgray, dimgrey, dodgerblue, firebrick, 626 floralwhite, forestgreen, fuchsia, gainsboro, 627 ghostwhite, gold, goldenrod, gray, grey, green, 628 greenyellow, honeydew, hotpink, indianred, indigo, 629 ivory, khaki, lavender, lavenderblush, lawngreen, 630 lemonchiffon, lightblue, lightcoral, lightcyan, 631 lightgoldenrodyellow, lightgray, lightgrey, 632 lightgreen, lightpink, lightsalmon, lightseagreen, 633 lightskyblue, lightslategray, lightslategrey, 634 lightsteelblue, lightyellow, lime, limegreen, 635 linen, magenta, maroon, mediumaquamarine, 636 mediumblue, mediumorchid, mediumpurple, 637 mediumseagreen, mediumslateblue, mediumspringgreen, 638 mediumturquoise, mediumvioletred, midnightblue, 639 mintcream, mistyrose, moccasin, navajowhite, navy, 640 oldlace, olive, olivedrab, orange, orangered, 641 orchid, palegoldenrod, palegreen, paleturquoise, 642 palevioletred, papayawhip, peachpuff, peru, pink, 643 plum, powderblue, purple, red, rosybrown, 644 royalblue, rebeccapurple, saddlebrown, salmon, 645 sandybrown, seagreen, seashell, sienna, silver, 646 skyblue, slateblue, slategray, slategrey, snow, 647 springgreen, steelblue, tan, teal, thistle, tomato, 648 turquoise, violet, wheat, white, whitesmoke, 649 yellow, yellowgreen 650 651 Returns 652 ------- 653 str 654 """ 655 return self["tickcolor"] 656 657 @tickcolor.setter 658 def tickcolor(self, val): 659 self["tickcolor"] = val 660 661 # ticklen 662 # ------- 663 @property 664 def ticklen(self): 665 """ 666 Sets the length in pixels of step tick marks 667 668 The 'ticklen' property is a number and may be specified as: 669 - An int or float in the interval [0, inf] 670 671 Returns 672 ------- 673 int|float 674 """ 675 return self["ticklen"] 676 677 @ticklen.setter 678 def ticklen(self, val): 679 self["ticklen"] = val 680 681 # tickwidth 682 # --------- 683 @property 684 def tickwidth(self): 685 """ 686 Sets the tick width (in px). 687 688 The 'tickwidth' property is a number and may be specified as: 689 - An int or float in the interval [0, inf] 690 691 Returns 692 ------- 693 int|float 694 """ 695 return self["tickwidth"] 696 697 @tickwidth.setter 698 def tickwidth(self, val): 699 self["tickwidth"] = val 700 701 # transition 702 # ---------- 703 @property 704 def transition(self): 705 """ 706 The 'transition' property is an instance of Transition 707 that may be specified as: 708 - An instance of :class:`plotly.graph_objs.layout.slider.Transition` 709 - A dict of string/value properties that will be passed 710 to the Transition constructor 711 712 Supported dict properties: 713 714 duration 715 Sets the duration of the slider transition 716 easing 717 Sets the easing function of the slider 718 transition 719 720 Returns 721 ------- 722 plotly.graph_objs.layout.slider.Transition 723 """ 724 return self["transition"] 725 726 @transition.setter 727 def transition(self, val): 728 self["transition"] = val 729 730 # visible 731 # ------- 732 @property 733 def visible(self): 734 """ 735 Determines whether or not the slider is visible. 736 737 The 'visible' property must be specified as a bool 738 (either True, or False) 739 740 Returns 741 ------- 742 bool 743 """ 744 return self["visible"] 745 746 @visible.setter 747 def visible(self, val): 748 self["visible"] = val 749 750 # x 751 # - 752 @property 753 def x(self): 754 """ 755 Sets the x position (in normalized coordinates) of the slider. 756 757 The 'x' property is a number and may be specified as: 758 - An int or float in the interval [-2, 3] 759 760 Returns 761 ------- 762 int|float 763 """ 764 return self["x"] 765 766 @x.setter 767 def x(self, val): 768 self["x"] = val 769 770 # xanchor 771 # ------- 772 @property 773 def xanchor(self): 774 """ 775 Sets the slider's horizontal position anchor. This anchor binds 776 the `x` position to the "left", "center" or "right" of the 777 range selector. 778 779 The 'xanchor' property is an enumeration that may be specified as: 780 - One of the following enumeration values: 781 ['auto', 'left', 'center', 'right'] 782 783 Returns 784 ------- 785 Any 786 """ 787 return self["xanchor"] 788 789 @xanchor.setter 790 def xanchor(self, val): 791 self["xanchor"] = val 792 793 # y 794 # - 795 @property 796 def y(self): 797 """ 798 Sets the y position (in normalized coordinates) of the slider. 799 800 The 'y' property is a number and may be specified as: 801 - An int or float in the interval [-2, 3] 802 803 Returns 804 ------- 805 int|float 806 """ 807 return self["y"] 808 809 @y.setter 810 def y(self, val): 811 self["y"] = val 812 813 # yanchor 814 # ------- 815 @property 816 def yanchor(self): 817 """ 818 Sets the slider's vertical position anchor This anchor binds 819 the `y` position to the "top", "middle" or "bottom" of the 820 range selector. 821 822 The 'yanchor' property is an enumeration that may be specified as: 823 - One of the following enumeration values: 824 ['auto', 'top', 'middle', 'bottom'] 825 826 Returns 827 ------- 828 Any 829 """ 830 return self["yanchor"] 831 832 @yanchor.setter 833 def yanchor(self, val): 834 self["yanchor"] = val 835 836 # Self properties description 837 # --------------------------- 838 @property 839 def _prop_descriptions(self): 840 return """\ 841 active 842 Determines which button (by index starting from 0) is 843 considered active. 844 activebgcolor 845 Sets the background color of the slider grip while 846 dragging. 847 bgcolor 848 Sets the background color of the slider. 849 bordercolor 850 Sets the color of the border enclosing the slider. 851 borderwidth 852 Sets the width (in px) of the border enclosing the 853 slider. 854 currentvalue 855 :class:`plotly.graph_objects.layout.slider.Currentvalue 856 ` instance or dict with compatible properties 857 font 858 Sets the font of the slider step labels. 859 len 860 Sets the length of the slider This measure excludes the 861 padding of both ends. That is, the slider's length is 862 this length minus the padding on both ends. 863 lenmode 864 Determines whether this slider length is set in units 865 of plot "fraction" or in *pixels. Use `len` to set the 866 value. 867 minorticklen 868 Sets the length in pixels of minor step tick marks 869 name 870 When used in a template, named items are created in the 871 output figure in addition to any items the figure 872 already has in this array. You can modify these items 873 in the output figure by making your own item with 874 `templateitemname` matching this `name` alongside your 875 modifications (including `visible: false` or `enabled: 876 false` to hide it). Has no effect outside of a 877 template. 878 pad 879 Set the padding of the slider component along each 880 side. 881 steps 882 A tuple of 883 :class:`plotly.graph_objects.layout.slider.Step` 884 instances or dicts with compatible properties 885 stepdefaults 886 When used in a template (as 887 layout.template.layout.slider.stepdefaults), sets the 888 default property values to use for elements of 889 layout.slider.steps 890 templateitemname 891 Used to refer to a named item in this array in the 892 template. Named items from the template will be created 893 even without a matching item in the input figure, but 894 you can modify one by making an item with 895 `templateitemname` matching its `name`, alongside your 896 modifications (including `visible: false` or `enabled: 897 false` to hide it). If there is no template or no 898 matching item, this item will be hidden unless you 899 explicitly show it with `visible: true`. 900 tickcolor 901 Sets the color of the border enclosing the slider. 902 ticklen 903 Sets the length in pixels of step tick marks 904 tickwidth 905 Sets the tick width (in px). 906 transition 907 :class:`plotly.graph_objects.layout.slider.Transition` 908 instance or dict with compatible properties 909 visible 910 Determines whether or not the slider is visible. 911 x 912 Sets the x position (in normalized coordinates) of the 913 slider. 914 xanchor 915 Sets the slider's horizontal position anchor. This 916 anchor binds the `x` position to the "left", "center" 917 or "right" of the range selector. 918 y 919 Sets the y position (in normalized coordinates) of the 920 slider. 921 yanchor 922 Sets the slider's vertical position anchor This anchor 923 binds the `y` position to the "top", "middle" or 924 "bottom" of the range selector. 925 """ 926 927 def __init__( 928 self, 929 arg=None, 930 active=None, 931 activebgcolor=None, 932 bgcolor=None, 933 bordercolor=None, 934 borderwidth=None, 935 currentvalue=None, 936 font=None, 937 len=None, 938 lenmode=None, 939 minorticklen=None, 940 name=None, 941 pad=None, 942 steps=None, 943 stepdefaults=None, 944 templateitemname=None, 945 tickcolor=None, 946 ticklen=None, 947 tickwidth=None, 948 transition=None, 949 visible=None, 950 x=None, 951 xanchor=None, 952 y=None, 953 yanchor=None, 954 **kwargs 955 ): 956 """ 957 Construct a new Slider object 958 959 Parameters 960 ---------- 961 arg 962 dict of properties compatible with this constructor or 963 an instance of :class:`plotly.graph_objs.layout.Slider` 964 active 965 Determines which button (by index starting from 0) is 966 considered active. 967 activebgcolor 968 Sets the background color of the slider grip while 969 dragging. 970 bgcolor 971 Sets the background color of the slider. 972 bordercolor 973 Sets the color of the border enclosing the slider. 974 borderwidth 975 Sets the width (in px) of the border enclosing the 976 slider. 977 currentvalue 978 :class:`plotly.graph_objects.layout.slider.Currentvalue 979 ` instance or dict with compatible properties 980 font 981 Sets the font of the slider step labels. 982 len 983 Sets the length of the slider This measure excludes the 984 padding of both ends. That is, the slider's length is 985 this length minus the padding on both ends. 986 lenmode 987 Determines whether this slider length is set in units 988 of plot "fraction" or in *pixels. Use `len` to set the 989 value. 990 minorticklen 991 Sets the length in pixels of minor step tick marks 992 name 993 When used in a template, named items are created in the 994 output figure in addition to any items the figure 995 already has in this array. You can modify these items 996 in the output figure by making your own item with 997 `templateitemname` matching this `name` alongside your 998 modifications (including `visible: false` or `enabled: 999 false` to hide it). Has no effect outside of a 1000 template. 1001 pad 1002 Set the padding of the slider component along each 1003 side. 1004 steps 1005 A tuple of 1006 :class:`plotly.graph_objects.layout.slider.Step` 1007 instances or dicts with compatible properties 1008 stepdefaults 1009 When used in a template (as 1010 layout.template.layout.slider.stepdefaults), sets the 1011 default property values to use for elements of 1012 layout.slider.steps 1013 templateitemname 1014 Used to refer to a named item in this array in the 1015 template. Named items from the template will be created 1016 even without a matching item in the input figure, but 1017 you can modify one by making an item with 1018 `templateitemname` matching its `name`, alongside your 1019 modifications (including `visible: false` or `enabled: 1020 false` to hide it). If there is no template or no 1021 matching item, this item will be hidden unless you 1022 explicitly show it with `visible: true`. 1023 tickcolor 1024 Sets the color of the border enclosing the slider. 1025 ticklen 1026 Sets the length in pixels of step tick marks 1027 tickwidth 1028 Sets the tick width (in px). 1029 transition 1030 :class:`plotly.graph_objects.layout.slider.Transition` 1031 instance or dict with compatible properties 1032 visible 1033 Determines whether or not the slider is visible. 1034 x 1035 Sets the x position (in normalized coordinates) of the 1036 slider. 1037 xanchor 1038 Sets the slider's horizontal position anchor. This 1039 anchor binds the `x` position to the "left", "center" 1040 or "right" of the range selector. 1041 y 1042 Sets the y position (in normalized coordinates) of the 1043 slider. 1044 yanchor 1045 Sets the slider's vertical position anchor This anchor 1046 binds the `y` position to the "top", "middle" or 1047 "bottom" of the range selector. 1048 1049 Returns 1050 ------- 1051 Slider 1052 """ 1053 super(Slider, self).__init__("sliders") 1054 1055 if "_parent" in kwargs: 1056 self._parent = kwargs["_parent"] 1057 return 1058 1059 # Validate arg 1060 # ------------ 1061 if arg is None: 1062 arg = {} 1063 elif isinstance(arg, self.__class__): 1064 arg = arg.to_plotly_json() 1065 elif isinstance(arg, dict): 1066 arg = _copy.copy(arg) 1067 else: 1068 raise ValueError( 1069 """\ 1070The first argument to the plotly.graph_objs.layout.Slider 1071constructor must be a dict or 1072an instance of :class:`plotly.graph_objs.layout.Slider`""" 1073 ) 1074 1075 # Handle skip_invalid 1076 # ------------------- 1077 self._skip_invalid = kwargs.pop("skip_invalid", False) 1078 self._validate = kwargs.pop("_validate", True) 1079 1080 # Populate data dict with properties 1081 # ---------------------------------- 1082 _v = arg.pop("active", None) 1083 _v = active if active is not None else _v 1084 if _v is not None: 1085 self["active"] = _v 1086 _v = arg.pop("activebgcolor", None) 1087 _v = activebgcolor if activebgcolor is not None else _v 1088 if _v is not None: 1089 self["activebgcolor"] = _v 1090 _v = arg.pop("bgcolor", None) 1091 _v = bgcolor if bgcolor is not None else _v 1092 if _v is not None: 1093 self["bgcolor"] = _v 1094 _v = arg.pop("bordercolor", None) 1095 _v = bordercolor if bordercolor is not None else _v 1096 if _v is not None: 1097 self["bordercolor"] = _v 1098 _v = arg.pop("borderwidth", None) 1099 _v = borderwidth if borderwidth is not None else _v 1100 if _v is not None: 1101 self["borderwidth"] = _v 1102 _v = arg.pop("currentvalue", None) 1103 _v = currentvalue if currentvalue is not None else _v 1104 if _v is not None: 1105 self["currentvalue"] = _v 1106 _v = arg.pop("font", None) 1107 _v = font if font is not None else _v 1108 if _v is not None: 1109 self["font"] = _v 1110 _v = arg.pop("len", None) 1111 _v = len if len is not None else _v 1112 if _v is not None: 1113 self["len"] = _v 1114 _v = arg.pop("lenmode", None) 1115 _v = lenmode if lenmode is not None else _v 1116 if _v is not None: 1117 self["lenmode"] = _v 1118 _v = arg.pop("minorticklen", None) 1119 _v = minorticklen if minorticklen is not None else _v 1120 if _v is not None: 1121 self["minorticklen"] = _v 1122 _v = arg.pop("name", None) 1123 _v = name if name is not None else _v 1124 if _v is not None: 1125 self["name"] = _v 1126 _v = arg.pop("pad", None) 1127 _v = pad if pad is not None else _v 1128 if _v is not None: 1129 self["pad"] = _v 1130 _v = arg.pop("steps", None) 1131 _v = steps if steps is not None else _v 1132 if _v is not None: 1133 self["steps"] = _v 1134 _v = arg.pop("stepdefaults", None) 1135 _v = stepdefaults if stepdefaults is not None else _v 1136 if _v is not None: 1137 self["stepdefaults"] = _v 1138 _v = arg.pop("templateitemname", None) 1139 _v = templateitemname if templateitemname is not None else _v 1140 if _v is not None: 1141 self["templateitemname"] = _v 1142 _v = arg.pop("tickcolor", None) 1143 _v = tickcolor if tickcolor is not None else _v 1144 if _v is not None: 1145 self["tickcolor"] = _v 1146 _v = arg.pop("ticklen", None) 1147 _v = ticklen if ticklen is not None else _v 1148 if _v is not None: 1149 self["ticklen"] = _v 1150 _v = arg.pop("tickwidth", None) 1151 _v = tickwidth if tickwidth is not None else _v 1152 if _v is not None: 1153 self["tickwidth"] = _v 1154 _v = arg.pop("transition", None) 1155 _v = transition if transition is not None else _v 1156 if _v is not None: 1157 self["transition"] = _v 1158 _v = arg.pop("visible", None) 1159 _v = visible if visible is not None else _v 1160 if _v is not None: 1161 self["visible"] = _v 1162 _v = arg.pop("x", None) 1163 _v = x if x is not None else _v 1164 if _v is not None: 1165 self["x"] = _v 1166 _v = arg.pop("xanchor", None) 1167 _v = xanchor if xanchor is not None else _v 1168 if _v is not None: 1169 self["xanchor"] = _v 1170 _v = arg.pop("y", None) 1171 _v = y if y is not None else _v 1172 if _v is not None: 1173 self["y"] = _v 1174 _v = arg.pop("yanchor", None) 1175 _v = yanchor if yanchor is not None else _v 1176 if _v is not None: 1177 self["yanchor"] = _v 1178 1179 # Process unknown kwargs 1180 # ---------------------- 1181 self._process_kwargs(**dict(arg, **kwargs)) 1182 1183 # Reset skip_invalid 1184 # ------------------ 1185 self._skip_invalid = False 1186