1from plotly.basedatatypes import BaseTraceType as _BaseTraceType 2import copy as _copy 3 4 5class Parcats(_BaseTraceType): 6 7 # class properties 8 # -------------------- 9 _parent_path_str = "" 10 _path_str = "parcats" 11 _valid_props = { 12 "arrangement", 13 "bundlecolors", 14 "counts", 15 "countssrc", 16 "dimensiondefaults", 17 "dimensions", 18 "domain", 19 "hoverinfo", 20 "hoveron", 21 "hovertemplate", 22 "labelfont", 23 "line", 24 "meta", 25 "metasrc", 26 "name", 27 "sortpaths", 28 "stream", 29 "tickfont", 30 "type", 31 "uid", 32 "uirevision", 33 "visible", 34 } 35 36 # arrangement 37 # ----------- 38 @property 39 def arrangement(self): 40 """ 41 Sets the drag interaction mode for categories and dimensions. 42 If `perpendicular`, the categories can only move along a line 43 perpendicular to the paths. If `freeform`, the categories can 44 freely move on the plane. If `fixed`, the categories and 45 dimensions are stationary. 46 47 The 'arrangement' property is an enumeration that may be specified as: 48 - One of the following enumeration values: 49 ['perpendicular', 'freeform', 'fixed'] 50 51 Returns 52 ------- 53 Any 54 """ 55 return self["arrangement"] 56 57 @arrangement.setter 58 def arrangement(self, val): 59 self["arrangement"] = val 60 61 # bundlecolors 62 # ------------ 63 @property 64 def bundlecolors(self): 65 """ 66 Sort paths so that like colors are bundled together within each 67 category. 68 69 The 'bundlecolors' property must be specified as a bool 70 (either True, or False) 71 72 Returns 73 ------- 74 bool 75 """ 76 return self["bundlecolors"] 77 78 @bundlecolors.setter 79 def bundlecolors(self, val): 80 self["bundlecolors"] = val 81 82 # counts 83 # ------ 84 @property 85 def counts(self): 86 """ 87 The number of observations represented by each state. Defaults 88 to 1 so that each state represents one observation 89 90 The 'counts' property is a number and may be specified as: 91 - An int or float in the interval [0, inf] 92 - A tuple, list, or one-dimensional numpy array of the above 93 94 Returns 95 ------- 96 int|float|numpy.ndarray 97 """ 98 return self["counts"] 99 100 @counts.setter 101 def counts(self, val): 102 self["counts"] = val 103 104 # countssrc 105 # --------- 106 @property 107 def countssrc(self): 108 """ 109 Sets the source reference on Chart Studio Cloud for counts . 110 111 The 'countssrc' property must be specified as a string or 112 as a plotly.grid_objs.Column object 113 114 Returns 115 ------- 116 str 117 """ 118 return self["countssrc"] 119 120 @countssrc.setter 121 def countssrc(self, val): 122 self["countssrc"] = val 123 124 # dimensions 125 # ---------- 126 @property 127 def dimensions(self): 128 """ 129 The dimensions (variables) of the parallel categories diagram. 130 131 The 'dimensions' property is a tuple of instances of 132 Dimension that may be specified as: 133 - A list or tuple of instances of plotly.graph_objs.parcats.Dimension 134 - A list or tuple of dicts of string/value properties that 135 will be passed to the Dimension constructor 136 137 Supported dict properties: 138 139 categoryarray 140 Sets the order in which categories in this 141 dimension appear. Only has an effect if 142 `categoryorder` is set to "array". Used with 143 `categoryorder`. 144 categoryarraysrc 145 Sets the source reference on Chart Studio Cloud 146 for categoryarray . 147 categoryorder 148 Specifies the ordering logic for the categories 149 in the dimension. By default, plotly uses 150 "trace", which specifies the order that is 151 present in the data supplied. Set 152 `categoryorder` to *category ascending* or 153 *category descending* if order should be 154 determined by the alphanumerical order of the 155 category names. Set `categoryorder` to "array" 156 to derive the ordering from the attribute 157 `categoryarray`. If a category is not found in 158 the `categoryarray` array, the sorting behavior 159 for that attribute will be identical to the 160 "trace" mode. The unspecified categories will 161 follow the categories in `categoryarray`. 162 displayindex 163 The display index of dimension, from left to 164 right, zero indexed, defaults to dimension 165 index. 166 label 167 The shown name of the dimension. 168 ticktext 169 Sets alternative tick labels for the categories 170 in this dimension. Only has an effect if 171 `categoryorder` is set to "array". Should be an 172 array the same length as `categoryarray` Used 173 with `categoryorder`. 174 ticktextsrc 175 Sets the source reference on Chart Studio Cloud 176 for ticktext . 177 values 178 Dimension values. `values[n]` represents the 179 category value of the `n`th point in the 180 dataset, therefore the `values` vector for all 181 dimensions must be the same (longer vectors 182 will be truncated). 183 valuessrc 184 Sets the source reference on Chart Studio Cloud 185 for values . 186 visible 187 Shows the dimension when set to `true` (the 188 default). Hides the dimension for `false`. 189 190 Returns 191 ------- 192 tuple[plotly.graph_objs.parcats.Dimension] 193 """ 194 return self["dimensions"] 195 196 @dimensions.setter 197 def dimensions(self, val): 198 self["dimensions"] = val 199 200 # dimensiondefaults 201 # ----------------- 202 @property 203 def dimensiondefaults(self): 204 """ 205 When used in a template (as 206 layout.template.data.parcats.dimensiondefaults), sets the 207 default property values to use for elements of 208 parcats.dimensions 209 210 The 'dimensiondefaults' property is an instance of Dimension 211 that may be specified as: 212 - An instance of :class:`plotly.graph_objs.parcats.Dimension` 213 - A dict of string/value properties that will be passed 214 to the Dimension constructor 215 216 Supported dict properties: 217 218 Returns 219 ------- 220 plotly.graph_objs.parcats.Dimension 221 """ 222 return self["dimensiondefaults"] 223 224 @dimensiondefaults.setter 225 def dimensiondefaults(self, val): 226 self["dimensiondefaults"] = val 227 228 # domain 229 # ------ 230 @property 231 def domain(self): 232 """ 233 The 'domain' property is an instance of Domain 234 that may be specified as: 235 - An instance of :class:`plotly.graph_objs.parcats.Domain` 236 - A dict of string/value properties that will be passed 237 to the Domain constructor 238 239 Supported dict properties: 240 241 column 242 If there is a layout grid, use the domain for 243 this column in the grid for this parcats trace 244 . 245 row 246 If there is a layout grid, use the domain for 247 this row in the grid for this parcats trace . 248 x 249 Sets the horizontal domain of this parcats 250 trace (in plot fraction). 251 y 252 Sets the vertical domain of this parcats trace 253 (in plot fraction). 254 255 Returns 256 ------- 257 plotly.graph_objs.parcats.Domain 258 """ 259 return self["domain"] 260 261 @domain.setter 262 def domain(self, val): 263 self["domain"] = val 264 265 # hoverinfo 266 # --------- 267 @property 268 def hoverinfo(self): 269 """ 270 Determines which trace information appear on hover. If `none` 271 or `skip` are set, no information is displayed upon hovering. 272 But, if `none` is set, click and hover events are still fired. 273 274 The 'hoverinfo' property is a flaglist and may be specified 275 as a string containing: 276 - Any combination of ['count', 'probability'] joined with '+' characters 277 (e.g. 'count+probability') 278 OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') 279 280 Returns 281 ------- 282 Any 283 """ 284 return self["hoverinfo"] 285 286 @hoverinfo.setter 287 def hoverinfo(self, val): 288 self["hoverinfo"] = val 289 290 # hoveron 291 # ------- 292 @property 293 def hoveron(self): 294 """ 295 Sets the hover interaction mode for the parcats diagram. If 296 `category`, hover interaction take place per category. If 297 `color`, hover interactions take place per color per category. 298 If `dimension`, hover interactions take place across all 299 categories per dimension. 300 301 The 'hoveron' property is an enumeration that may be specified as: 302 - One of the following enumeration values: 303 ['category', 'color', 'dimension'] 304 305 Returns 306 ------- 307 Any 308 """ 309 return self["hoveron"] 310 311 @hoveron.setter 312 def hoveron(self, val): 313 self["hoveron"] = val 314 315 # hovertemplate 316 # ------------- 317 @property 318 def hovertemplate(self): 319 """ 320 Template string used for rendering the information that appear 321 on hover box. Note that this will override `hoverinfo`. 322 Variables are inserted using %{variable}, for example "y: 323 %{y}". Numbers are formatted using d3-format's syntax 324 %{variable:d3-format}, for example "Price: %{y:$.2f}". 325 https://github.com/d3/d3-3.x-api- 326 reference/blob/master/Formatting.md#d3_format for details on 327 the formatting syntax. Dates are formatted using d3-time- 328 format's syntax %{variable|d3-time-format}, for example "Day: 329 %{2019-01-01|%A}". https://github.com/d3/d3-time- 330 format#locale_format for details on the date formatting syntax. 331 The variables available in `hovertemplate` are the ones emitted 332 as event data described at this link 333 https://plotly.com/javascript/plotlyjs-events/#event-data. 334 Additionally, every attributes that can be specified per-point 335 (the ones that are `arrayOk: true`) are available. variables 336 `count`, `probability`, `category`, `categorycount`, 337 `colorcount` and `bandcolorcount`. Anything contained in tag 338 `<extra>` is displayed in the secondary box, for example 339 "<extra>{fullData.name}</extra>". To hide the secondary box 340 completely, use an empty tag `<extra></extra>`. 341 342 The 'hovertemplate' property is a string and must be specified as: 343 - A string 344 - A number that will be converted to a string 345 346 Returns 347 ------- 348 str 349 """ 350 return self["hovertemplate"] 351 352 @hovertemplate.setter 353 def hovertemplate(self, val): 354 self["hovertemplate"] = val 355 356 # labelfont 357 # --------- 358 @property 359 def labelfont(self): 360 """ 361 Sets the font for the `dimension` labels. 362 363 The 'labelfont' property is an instance of Labelfont 364 that may be specified as: 365 - An instance of :class:`plotly.graph_objs.parcats.Labelfont` 366 - A dict of string/value properties that will be passed 367 to the Labelfont constructor 368 369 Supported dict properties: 370 371 color 372 373 family 374 HTML font family - the typeface that will be 375 applied by the web browser. The web browser 376 will only be able to apply a font if it is 377 available on the system which it operates. 378 Provide multiple font families, separated by 379 commas, to indicate the preference in which to 380 apply fonts if they aren't available on the 381 system. The Chart Studio Cloud (at 382 https://chart-studio.plotly.com or on-premise) 383 generates images on a server, where only a 384 select number of fonts are installed and 385 supported. These include "Arial", "Balto", 386 "Courier New", "Droid Sans",, "Droid Serif", 387 "Droid Sans Mono", "Gravitas One", "Old 388 Standard TT", "Open Sans", "Overpass", "PT Sans 389 Narrow", "Raleway", "Times New Roman". 390 size 391 392 Returns 393 ------- 394 plotly.graph_objs.parcats.Labelfont 395 """ 396 return self["labelfont"] 397 398 @labelfont.setter 399 def labelfont(self, val): 400 self["labelfont"] = val 401 402 # line 403 # ---- 404 @property 405 def line(self): 406 """ 407 The 'line' property is an instance of Line 408 that may be specified as: 409 - An instance of :class:`plotly.graph_objs.parcats.Line` 410 - A dict of string/value properties that will be passed 411 to the Line constructor 412 413 Supported dict properties: 414 415 autocolorscale 416 Determines whether the colorscale is a default 417 palette (`autocolorscale: true`) or the palette 418 determined by `line.colorscale`. Has an effect 419 only if in `line.color`is set to a numerical 420 array. In case `colorscale` is unspecified or 421 `autocolorscale` is true, the default palette 422 will be chosen according to whether numbers in 423 the `color` array are all positive, all 424 negative or mixed. 425 cauto 426 Determines whether or not the color domain is 427 computed with respect to the input data (here 428 in `line.color`) or the bounds set in 429 `line.cmin` and `line.cmax` Has an effect only 430 if in `line.color`is set to a numerical array. 431 Defaults to `false` when `line.cmin` and 432 `line.cmax` are set by the user. 433 cmax 434 Sets the upper bound of the color domain. Has 435 an effect only if in `line.color`is set to a 436 numerical array. Value should have the same 437 units as in `line.color` and if set, 438 `line.cmin` must be set as well. 439 cmid 440 Sets the mid-point of the color domain by 441 scaling `line.cmin` and/or `line.cmax` to be 442 equidistant to this point. Has an effect only 443 if in `line.color`is set to a numerical array. 444 Value should have the same units as in 445 `line.color`. Has no effect when `line.cauto` 446 is `false`. 447 cmin 448 Sets the lower bound of the color domain. Has 449 an effect only if in `line.color`is set to a 450 numerical array. Value should have the same 451 units as in `line.color` and if set, 452 `line.cmax` must be set as well. 453 color 454 Sets thelinecolor. It accepts either a specific 455 color or an array of numbers that are mapped to 456 the colorscale relative to the max and min 457 values of the array or relative to `line.cmin` 458 and `line.cmax` if set. 459 coloraxis 460 Sets a reference to a shared color axis. 461 References to these shared color axes are 462 "coloraxis", "coloraxis2", "coloraxis3", etc. 463 Settings for these shared color axes are set in 464 the layout, under `layout.coloraxis`, 465 `layout.coloraxis2`, etc. Note that multiple 466 color scales can be linked to the same color 467 axis. 468 colorbar 469 :class:`plotly.graph_objects.parcats.line.Color 470 Bar` instance or dict with compatible 471 properties 472 colorscale 473 Sets the colorscale. Has an effect only if in 474 `line.color`is set to a numerical array. The 475 colorscale must be an array containing arrays 476 mapping a normalized value to an rgb, rgba, 477 hex, hsl, hsv, or named color string. At 478 minimum, a mapping for the lowest (0) and 479 highest (1) values are required. For example, 480 `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. 481 To control the bounds of the colorscale in 482 color space, use`line.cmin` and `line.cmax`. 483 Alternatively, `colorscale` may be a palette 484 name string of the following list: Greys,YlGnBu 485 ,Greens,YlOrRd,Bluered,RdBu,Reds,Blues,Picnic,R 486 ainbow,Portland,Jet,Hot,Blackbody,Earth,Electri 487 c,Viridis,Cividis. 488 colorsrc 489 Sets the source reference on Chart Studio Cloud 490 for color . 491 hovertemplate 492 Template string used for rendering the 493 information that appear on hover box. Note that 494 this will override `hoverinfo`. Variables are 495 inserted using %{variable}, for example "y: 496 %{y}". Numbers are formatted using d3-format's 497 syntax %{variable:d3-format}, for example 498 "Price: %{y:$.2f}". 499 https://github.com/d3/d3-3.x-api- 500 reference/blob/master/Formatting.md#d3_format 501 for details on the formatting syntax. Dates are 502 formatted using d3-time-format's syntax 503 %{variable|d3-time-format}, for example "Day: 504 %{2019-01-01|%A}". 505 https://github.com/d3/d3-time- 506 format#locale_format for details on the date 507 formatting syntax. The variables available in 508 `hovertemplate` are the ones emitted as event 509 data described at this link 510 https://plotly.com/javascript/plotlyjs- 511 events/#event-data. Additionally, every 512 attributes that can be specified per-point (the 513 ones that are `arrayOk: true`) are available. 514 variables `count` and `probability`. Anything 515 contained in tag `<extra>` is displayed in the 516 secondary box, for example 517 "<extra>{fullData.name}</extra>". To hide the 518 secondary box completely, use an empty tag 519 `<extra></extra>`. 520 reversescale 521 Reverses the color mapping if true. Has an 522 effect only if in `line.color`is set to a 523 numerical array. If true, `line.cmin` will 524 correspond to the last color in the array and 525 `line.cmax` will correspond to the first color. 526 shape 527 Sets the shape of the paths. If `linear`, paths 528 are composed of straight lines. If `hspline`, 529 paths are composed of horizontal curved splines 530 showscale 531 Determines whether or not a colorbar is 532 displayed for this trace. Has an effect only if 533 in `line.color`is set to a numerical array. 534 535 Returns 536 ------- 537 plotly.graph_objs.parcats.Line 538 """ 539 return self["line"] 540 541 @line.setter 542 def line(self, val): 543 self["line"] = val 544 545 # meta 546 # ---- 547 @property 548 def meta(self): 549 """ 550 Assigns extra meta information associated with this trace that 551 can be used in various text attributes. Attributes such as 552 trace `name`, graph, axis and colorbar `title.text`, annotation 553 `text` `rangeselector`, `updatemenues` and `sliders` `label` 554 text all support `meta`. To access the trace `meta` values in 555 an attribute in the same trace, simply use `%{meta[i]}` where 556 `i` is the index or key of the `meta` item in question. To 557 access trace `meta` in layout attributes, use 558 `%{data[n[.meta[i]}` where `i` is the index or key of the 559 `meta` and `n` is the trace index. 560 561 The 'meta' property accepts values of any type 562 563 Returns 564 ------- 565 Any|numpy.ndarray 566 """ 567 return self["meta"] 568 569 @meta.setter 570 def meta(self, val): 571 self["meta"] = val 572 573 # metasrc 574 # ------- 575 @property 576 def metasrc(self): 577 """ 578 Sets the source reference on Chart Studio Cloud for meta . 579 580 The 'metasrc' property must be specified as a string or 581 as a plotly.grid_objs.Column object 582 583 Returns 584 ------- 585 str 586 """ 587 return self["metasrc"] 588 589 @metasrc.setter 590 def metasrc(self, val): 591 self["metasrc"] = val 592 593 # name 594 # ---- 595 @property 596 def name(self): 597 """ 598 Sets the trace name. The trace name appear as the legend item 599 and on hover. 600 601 The 'name' property is a string and must be specified as: 602 - A string 603 - A number that will be converted to a string 604 605 Returns 606 ------- 607 str 608 """ 609 return self["name"] 610 611 @name.setter 612 def name(self, val): 613 self["name"] = val 614 615 # sortpaths 616 # --------- 617 @property 618 def sortpaths(self): 619 """ 620 Sets the path sorting algorithm. If `forward`, sort paths based 621 on dimension categories from left to right. If `backward`, sort 622 paths based on dimensions categories from right to left. 623 624 The 'sortpaths' property is an enumeration that may be specified as: 625 - One of the following enumeration values: 626 ['forward', 'backward'] 627 628 Returns 629 ------- 630 Any 631 """ 632 return self["sortpaths"] 633 634 @sortpaths.setter 635 def sortpaths(self, val): 636 self["sortpaths"] = val 637 638 # stream 639 # ------ 640 @property 641 def stream(self): 642 """ 643 The 'stream' property is an instance of Stream 644 that may be specified as: 645 - An instance of :class:`plotly.graph_objs.parcats.Stream` 646 - A dict of string/value properties that will be passed 647 to the Stream constructor 648 649 Supported dict properties: 650 651 maxpoints 652 Sets the maximum number of points to keep on 653 the plots from an incoming stream. If 654 `maxpoints` is set to 50, only the newest 50 655 points will be displayed on the plot. 656 token 657 The stream id number links a data trace on a 658 plot with a stream. See https://chart- 659 studio.plotly.com/settings for more details. 660 661 Returns 662 ------- 663 plotly.graph_objs.parcats.Stream 664 """ 665 return self["stream"] 666 667 @stream.setter 668 def stream(self, val): 669 self["stream"] = val 670 671 # tickfont 672 # -------- 673 @property 674 def tickfont(self): 675 """ 676 Sets the font for the `category` labels. 677 678 The 'tickfont' property is an instance of Tickfont 679 that may be specified as: 680 - An instance of :class:`plotly.graph_objs.parcats.Tickfont` 681 - A dict of string/value properties that will be passed 682 to the Tickfont constructor 683 684 Supported dict properties: 685 686 color 687 688 family 689 HTML font family - the typeface that will be 690 applied by the web browser. The web browser 691 will only be able to apply a font if it is 692 available on the system which it operates. 693 Provide multiple font families, separated by 694 commas, to indicate the preference in which to 695 apply fonts if they aren't available on the 696 system. The Chart Studio Cloud (at 697 https://chart-studio.plotly.com or on-premise) 698 generates images on a server, where only a 699 select number of fonts are installed and 700 supported. These include "Arial", "Balto", 701 "Courier New", "Droid Sans",, "Droid Serif", 702 "Droid Sans Mono", "Gravitas One", "Old 703 Standard TT", "Open Sans", "Overpass", "PT Sans 704 Narrow", "Raleway", "Times New Roman". 705 size 706 707 Returns 708 ------- 709 plotly.graph_objs.parcats.Tickfont 710 """ 711 return self["tickfont"] 712 713 @tickfont.setter 714 def tickfont(self, val): 715 self["tickfont"] = val 716 717 # uid 718 # --- 719 @property 720 def uid(self): 721 """ 722 Assign an id to this trace, Use this to provide object 723 constancy between traces during animations and transitions. 724 725 The 'uid' property is a string and must be specified as: 726 - A string 727 - A number that will be converted to a string 728 729 Returns 730 ------- 731 str 732 """ 733 return self["uid"] 734 735 @uid.setter 736 def uid(self, val): 737 self["uid"] = val 738 739 # uirevision 740 # ---------- 741 @property 742 def uirevision(self): 743 """ 744 Controls persistence of some user-driven changes to the trace: 745 `constraintrange` in `parcoords` traces, as well as some 746 `editable: true` modifications such as `name` and 747 `colorbar.title`. Defaults to `layout.uirevision`. Note that 748 other user-driven trace attribute changes are controlled by 749 `layout` attributes: `trace.visible` is controlled by 750 `layout.legend.uirevision`, `selectedpoints` is controlled by 751 `layout.selectionrevision`, and `colorbar.(x|y)` (accessible 752 with `config: {editable: true}`) is controlled by 753 `layout.editrevision`. Trace changes are tracked by `uid`, 754 which only falls back on trace index if no `uid` is provided. 755 So if your app can add/remove traces before the end of the 756 `data` array, such that the same trace has a different index, 757 you can still preserve user-driven changes if you give each 758 trace a `uid` that stays with it as it moves. 759 760 The 'uirevision' property accepts values of any type 761 762 Returns 763 ------- 764 Any 765 """ 766 return self["uirevision"] 767 768 @uirevision.setter 769 def uirevision(self, val): 770 self["uirevision"] = val 771 772 # visible 773 # ------- 774 @property 775 def visible(self): 776 """ 777 Determines whether or not this trace is visible. If 778 "legendonly", the trace is not drawn, but can appear as a 779 legend item (provided that the legend itself is visible). 780 781 The 'visible' property is an enumeration that may be specified as: 782 - One of the following enumeration values: 783 [True, False, 'legendonly'] 784 785 Returns 786 ------- 787 Any 788 """ 789 return self["visible"] 790 791 @visible.setter 792 def visible(self, val): 793 self["visible"] = val 794 795 # type 796 # ---- 797 @property 798 def type(self): 799 return self._props["type"] 800 801 # Self properties description 802 # --------------------------- 803 @property 804 def _prop_descriptions(self): 805 return """\ 806 arrangement 807 Sets the drag interaction mode for categories and 808 dimensions. If `perpendicular`, the categories can only 809 move along a line perpendicular to the paths. If 810 `freeform`, the categories can freely move on the 811 plane. If `fixed`, the categories and dimensions are 812 stationary. 813 bundlecolors 814 Sort paths so that like colors are bundled together 815 within each category. 816 counts 817 The number of observations represented by each state. 818 Defaults to 1 so that each state represents one 819 observation 820 countssrc 821 Sets the source reference on Chart Studio Cloud for 822 counts . 823 dimensions 824 The dimensions (variables) of the parallel categories 825 diagram. 826 dimensiondefaults 827 When used in a template (as 828 layout.template.data.parcats.dimensiondefaults), sets 829 the default property values to use for elements of 830 parcats.dimensions 831 domain 832 :class:`plotly.graph_objects.parcats.Domain` instance 833 or dict with compatible properties 834 hoverinfo 835 Determines which trace information appear on hover. If 836 `none` or `skip` are set, no information is displayed 837 upon hovering. But, if `none` is set, click and hover 838 events are still fired. 839 hoveron 840 Sets the hover interaction mode for the parcats 841 diagram. If `category`, hover interaction take place 842 per category. If `color`, hover interactions take place 843 per color per category. If `dimension`, hover 844 interactions take place across all categories per 845 dimension. 846 hovertemplate 847 Template string used for rendering the information that 848 appear on hover box. Note that this will override 849 `hoverinfo`. Variables are inserted using %{variable}, 850 for example "y: %{y}". Numbers are formatted using 851 d3-format's syntax %{variable:d3-format}, for example 852 "Price: %{y:$.2f}". https://github.com/d3/d3-3.x-api- 853 reference/blob/master/Formatting.md#d3_format for 854 details on the formatting syntax. Dates are formatted 855 using d3-time-format's syntax %{variable|d3-time- 856 format}, for example "Day: %{2019-01-01|%A}". 857 https://github.com/d3/d3-time-format#locale_format for 858 details on the date formatting syntax. The variables 859 available in `hovertemplate` are the ones emitted as 860 event data described at this link 861 https://plotly.com/javascript/plotlyjs-events/#event- 862 data. Additionally, every attributes that can be 863 specified per-point (the ones that are `arrayOk: true`) 864 are available. variables `count`, `probability`, 865 `category`, `categorycount`, `colorcount` and 866 `bandcolorcount`. Anything contained in tag `<extra>` 867 is displayed in the secondary box, for example 868 "<extra>{fullData.name}</extra>". To hide the secondary 869 box completely, use an empty tag `<extra></extra>`. 870 labelfont 871 Sets the font for the `dimension` labels. 872 line 873 :class:`plotly.graph_objects.parcats.Line` instance or 874 dict with compatible properties 875 meta 876 Assigns extra meta information associated with this 877 trace that can be used in various text attributes. 878 Attributes such as trace `name`, graph, axis and 879 colorbar `title.text`, annotation `text` 880 `rangeselector`, `updatemenues` and `sliders` `label` 881 text all support `meta`. To access the trace `meta` 882 values in an attribute in the same trace, simply use 883 `%{meta[i]}` where `i` is the index or key of the 884 `meta` item in question. To access trace `meta` in 885 layout attributes, use `%{data[n[.meta[i]}` where `i` 886 is the index or key of the `meta` and `n` is the trace 887 index. 888 metasrc 889 Sets the source reference on Chart Studio Cloud for 890 meta . 891 name 892 Sets the trace name. The trace name appear as the 893 legend item and on hover. 894 sortpaths 895 Sets the path sorting algorithm. If `forward`, sort 896 paths based on dimension categories from left to right. 897 If `backward`, sort paths based on dimensions 898 categories from right to left. 899 stream 900 :class:`plotly.graph_objects.parcats.Stream` instance 901 or dict with compatible properties 902 tickfont 903 Sets the font for the `category` labels. 904 uid 905 Assign an id to this trace, Use this to provide object 906 constancy between traces during animations and 907 transitions. 908 uirevision 909 Controls persistence of some user-driven changes to the 910 trace: `constraintrange` in `parcoords` traces, as well 911 as some `editable: true` modifications such as `name` 912 and `colorbar.title`. Defaults to `layout.uirevision`. 913 Note that other user-driven trace attribute changes are 914 controlled by `layout` attributes: `trace.visible` is 915 controlled by `layout.legend.uirevision`, 916 `selectedpoints` is controlled by 917 `layout.selectionrevision`, and `colorbar.(x|y)` 918 (accessible with `config: {editable: true}`) is 919 controlled by `layout.editrevision`. Trace changes are 920 tracked by `uid`, which only falls back on trace index 921 if no `uid` is provided. So if your app can add/remove 922 traces before the end of the `data` array, such that 923 the same trace has a different index, you can still 924 preserve user-driven changes if you give each trace a 925 `uid` that stays with it as it moves. 926 visible 927 Determines whether or not this trace is visible. If 928 "legendonly", the trace is not drawn, but can appear as 929 a legend item (provided that the legend itself is 930 visible). 931 """ 932 933 def __init__( 934 self, 935 arg=None, 936 arrangement=None, 937 bundlecolors=None, 938 counts=None, 939 countssrc=None, 940 dimensions=None, 941 dimensiondefaults=None, 942 domain=None, 943 hoverinfo=None, 944 hoveron=None, 945 hovertemplate=None, 946 labelfont=None, 947 line=None, 948 meta=None, 949 metasrc=None, 950 name=None, 951 sortpaths=None, 952 stream=None, 953 tickfont=None, 954 uid=None, 955 uirevision=None, 956 visible=None, 957 **kwargs 958 ): 959 """ 960 Construct a new Parcats object 961 962 Parallel categories diagram for multidimensional categorical 963 data. 964 965 Parameters 966 ---------- 967 arg 968 dict of properties compatible with this constructor or 969 an instance of :class:`plotly.graph_objs.Parcats` 970 arrangement 971 Sets the drag interaction mode for categories and 972 dimensions. If `perpendicular`, the categories can only 973 move along a line perpendicular to the paths. If 974 `freeform`, the categories can freely move on the 975 plane. If `fixed`, the categories and dimensions are 976 stationary. 977 bundlecolors 978 Sort paths so that like colors are bundled together 979 within each category. 980 counts 981 The number of observations represented by each state. 982 Defaults to 1 so that each state represents one 983 observation 984 countssrc 985 Sets the source reference on Chart Studio Cloud for 986 counts . 987 dimensions 988 The dimensions (variables) of the parallel categories 989 diagram. 990 dimensiondefaults 991 When used in a template (as 992 layout.template.data.parcats.dimensiondefaults), sets 993 the default property values to use for elements of 994 parcats.dimensions 995 domain 996 :class:`plotly.graph_objects.parcats.Domain` instance 997 or dict with compatible properties 998 hoverinfo 999 Determines which trace information appear on hover. If 1000 `none` or `skip` are set, no information is displayed 1001 upon hovering. But, if `none` is set, click and hover 1002 events are still fired. 1003 hoveron 1004 Sets the hover interaction mode for the parcats 1005 diagram. If `category`, hover interaction take place 1006 per category. If `color`, hover interactions take place 1007 per color per category. If `dimension`, hover 1008 interactions take place across all categories per 1009 dimension. 1010 hovertemplate 1011 Template string used for rendering the information that 1012 appear on hover box. Note that this will override 1013 `hoverinfo`. Variables are inserted using %{variable}, 1014 for example "y: %{y}". Numbers are formatted using 1015 d3-format's syntax %{variable:d3-format}, for example 1016 "Price: %{y:$.2f}". https://github.com/d3/d3-3.x-api- 1017 reference/blob/master/Formatting.md#d3_format for 1018 details on the formatting syntax. Dates are formatted 1019 using d3-time-format's syntax %{variable|d3-time- 1020 format}, for example "Day: %{2019-01-01|%A}". 1021 https://github.com/d3/d3-time-format#locale_format for 1022 details on the date formatting syntax. The variables 1023 available in `hovertemplate` are the ones emitted as 1024 event data described at this link 1025 https://plotly.com/javascript/plotlyjs-events/#event- 1026 data. Additionally, every attributes that can be 1027 specified per-point (the ones that are `arrayOk: true`) 1028 are available. variables `count`, `probability`, 1029 `category`, `categorycount`, `colorcount` and 1030 `bandcolorcount`. Anything contained in tag `<extra>` 1031 is displayed in the secondary box, for example 1032 "<extra>{fullData.name}</extra>". To hide the secondary 1033 box completely, use an empty tag `<extra></extra>`. 1034 labelfont 1035 Sets the font for the `dimension` labels. 1036 line 1037 :class:`plotly.graph_objects.parcats.Line` instance or 1038 dict with compatible properties 1039 meta 1040 Assigns extra meta information associated with this 1041 trace that can be used in various text attributes. 1042 Attributes such as trace `name`, graph, axis and 1043 colorbar `title.text`, annotation `text` 1044 `rangeselector`, `updatemenues` and `sliders` `label` 1045 text all support `meta`. To access the trace `meta` 1046 values in an attribute in the same trace, simply use 1047 `%{meta[i]}` where `i` is the index or key of the 1048 `meta` item in question. To access trace `meta` in 1049 layout attributes, use `%{data[n[.meta[i]}` where `i` 1050 is the index or key of the `meta` and `n` is the trace 1051 index. 1052 metasrc 1053 Sets the source reference on Chart Studio Cloud for 1054 meta . 1055 name 1056 Sets the trace name. The trace name appear as the 1057 legend item and on hover. 1058 sortpaths 1059 Sets the path sorting algorithm. If `forward`, sort 1060 paths based on dimension categories from left to right. 1061 If `backward`, sort paths based on dimensions 1062 categories from right to left. 1063 stream 1064 :class:`plotly.graph_objects.parcats.Stream` instance 1065 or dict with compatible properties 1066 tickfont 1067 Sets the font for the `category` labels. 1068 uid 1069 Assign an id to this trace, Use this to provide object 1070 constancy between traces during animations and 1071 transitions. 1072 uirevision 1073 Controls persistence of some user-driven changes to the 1074 trace: `constraintrange` in `parcoords` traces, as well 1075 as some `editable: true` modifications such as `name` 1076 and `colorbar.title`. Defaults to `layout.uirevision`. 1077 Note that other user-driven trace attribute changes are 1078 controlled by `layout` attributes: `trace.visible` is 1079 controlled by `layout.legend.uirevision`, 1080 `selectedpoints` is controlled by 1081 `layout.selectionrevision`, and `colorbar.(x|y)` 1082 (accessible with `config: {editable: true}`) is 1083 controlled by `layout.editrevision`. Trace changes are 1084 tracked by `uid`, which only falls back on trace index 1085 if no `uid` is provided. So if your app can add/remove 1086 traces before the end of the `data` array, such that 1087 the same trace has a different index, you can still 1088 preserve user-driven changes if you give each trace a 1089 `uid` that stays with it as it moves. 1090 visible 1091 Determines whether or not this trace is visible. If 1092 "legendonly", the trace is not drawn, but can appear as 1093 a legend item (provided that the legend itself is 1094 visible). 1095 1096 Returns 1097 ------- 1098 Parcats 1099 """ 1100 super(Parcats, self).__init__("parcats") 1101 1102 if "_parent" in kwargs: 1103 self._parent = kwargs["_parent"] 1104 return 1105 1106 # Validate arg 1107 # ------------ 1108 if arg is None: 1109 arg = {} 1110 elif isinstance(arg, self.__class__): 1111 arg = arg.to_plotly_json() 1112 elif isinstance(arg, dict): 1113 arg = _copy.copy(arg) 1114 else: 1115 raise ValueError( 1116 """\ 1117The first argument to the plotly.graph_objs.Parcats 1118constructor must be a dict or 1119an instance of :class:`plotly.graph_objs.Parcats`""" 1120 ) 1121 1122 # Handle skip_invalid 1123 # ------------------- 1124 self._skip_invalid = kwargs.pop("skip_invalid", False) 1125 self._validate = kwargs.pop("_validate", True) 1126 1127 # Populate data dict with properties 1128 # ---------------------------------- 1129 _v = arg.pop("arrangement", None) 1130 _v = arrangement if arrangement is not None else _v 1131 if _v is not None: 1132 self["arrangement"] = _v 1133 _v = arg.pop("bundlecolors", None) 1134 _v = bundlecolors if bundlecolors is not None else _v 1135 if _v is not None: 1136 self["bundlecolors"] = _v 1137 _v = arg.pop("counts", None) 1138 _v = counts if counts is not None else _v 1139 if _v is not None: 1140 self["counts"] = _v 1141 _v = arg.pop("countssrc", None) 1142 _v = countssrc if countssrc is not None else _v 1143 if _v is not None: 1144 self["countssrc"] = _v 1145 _v = arg.pop("dimensions", None) 1146 _v = dimensions if dimensions is not None else _v 1147 if _v is not None: 1148 self["dimensions"] = _v 1149 _v = arg.pop("dimensiondefaults", None) 1150 _v = dimensiondefaults if dimensiondefaults is not None else _v 1151 if _v is not None: 1152 self["dimensiondefaults"] = _v 1153 _v = arg.pop("domain", None) 1154 _v = domain if domain is not None else _v 1155 if _v is not None: 1156 self["domain"] = _v 1157 _v = arg.pop("hoverinfo", None) 1158 _v = hoverinfo if hoverinfo is not None else _v 1159 if _v is not None: 1160 self["hoverinfo"] = _v 1161 _v = arg.pop("hoveron", None) 1162 _v = hoveron if hoveron is not None else _v 1163 if _v is not None: 1164 self["hoveron"] = _v 1165 _v = arg.pop("hovertemplate", None) 1166 _v = hovertemplate if hovertemplate is not None else _v 1167 if _v is not None: 1168 self["hovertemplate"] = _v 1169 _v = arg.pop("labelfont", None) 1170 _v = labelfont if labelfont is not None else _v 1171 if _v is not None: 1172 self["labelfont"] = _v 1173 _v = arg.pop("line", None) 1174 _v = line if line is not None else _v 1175 if _v is not None: 1176 self["line"] = _v 1177 _v = arg.pop("meta", None) 1178 _v = meta if meta is not None else _v 1179 if _v is not None: 1180 self["meta"] = _v 1181 _v = arg.pop("metasrc", None) 1182 _v = metasrc if metasrc is not None else _v 1183 if _v is not None: 1184 self["metasrc"] = _v 1185 _v = arg.pop("name", None) 1186 _v = name if name is not None else _v 1187 if _v is not None: 1188 self["name"] = _v 1189 _v = arg.pop("sortpaths", None) 1190 _v = sortpaths if sortpaths is not None else _v 1191 if _v is not None: 1192 self["sortpaths"] = _v 1193 _v = arg.pop("stream", None) 1194 _v = stream if stream is not None else _v 1195 if _v is not None: 1196 self["stream"] = _v 1197 _v = arg.pop("tickfont", None) 1198 _v = tickfont if tickfont is not None else _v 1199 if _v is not None: 1200 self["tickfont"] = _v 1201 _v = arg.pop("uid", None) 1202 _v = uid if uid is not None else _v 1203 if _v is not None: 1204 self["uid"] = _v 1205 _v = arg.pop("uirevision", None) 1206 _v = uirevision if uirevision is not None else _v 1207 if _v is not None: 1208 self["uirevision"] = _v 1209 _v = arg.pop("visible", None) 1210 _v = visible if visible is not None else _v 1211 if _v is not None: 1212 self["visible"] = _v 1213 1214 # Read-only literals 1215 # ------------------ 1216 1217 self._props["type"] = "parcats" 1218 arg.pop("type", None) 1219 1220 # Process unknown kwargs 1221 # ---------------------- 1222 self._process_kwargs(**dict(arg, **kwargs)) 1223 1224 # Reset skip_invalid 1225 # ------------------ 1226 self._skip_invalid = False 1227