text: from plotly.basedatatypes import BaseTraceType as _BaseTraceType
  import copy as _copy
  
  
  class Carpet(_BaseTraceType):
  
      # class properties
      # --------------------
      _parent_path_str = ""
      _path_str = "carpet"
      _valid_props = {
          "a",
          "a0",
          "aaxis",
          "asrc",
          "b",
          "b0",
          "baxis",
          "bsrc",
          "carpet",
          "cheaterslope",
          "color",
          "customdata",
          "customdatasrc",
          "da",
          "db",
          "font",
          "ids",
          "idssrc",
          "meta",
          "metasrc",
          "name",
          "opacity",
          "stream",
          "type",
          "uid",
          "uirevision",
          "visible",
          "x",
          "xaxis",
          "xsrc",
          "y",
          "yaxis",
          "ysrc",
      }
  
      # a
      # -
      @property
      def a(self):
          """
          An array containing values of the first parameter value
      
          The 'a' property is an array that may be specified as a tuple,
          list, numpy array, or pandas Series
  
          Returns
          -------
          numpy.ndarray
          """
          return self["a"]
  
      @a.setter
      def a(self, val):
          self["a"] = val
  
      # a0
      # --
      @property
      def a0(self):
          """
          Alternate to `a`. Builds a linear space of a coordinates. Use
          with `da` where `a0` is the starting coordinate and `da` the
          step.
      
          The 'a0' property is a number and may be specified as:
            - An int or float
  
          Returns
          -------
          int|float
          """
          return self["a0"]
  
      @a0.setter
      def a0(self, val):
          self["a0"] = val
  
      # aaxis
      # -----
      @property
      def aaxis(self):
          """
          The 'aaxis' property is an instance of Aaxis
          that may be specified as:
            - An instance of :class:`plotly.graph_objs.carpet.Aaxis`
            - A dict of string/value properties that will be passed
              to the Aaxis constructor
      
              Supported dict properties:
                  
                  arraydtick
                      The stride between grid lines along the axis
                  arraytick0
                      The starting index of grid lines along the axis
                  autorange
                      Determines whether or not the range of this
                      axis is computed in relation to the input data.
                      See `rangemode` for more info. If `range` is
                      provided, then `autorange` is set to False.
                  autotypenumbers
                      Using "strict" a numeric string in trace data
                      is not converted to a number. Using *convert
                      types* a numeric string in trace data may be
                      treated as a number during automatic axis
                      `type` detection. Defaults to
                      layout.autotypenumbers.
                  categoryarray
                      Sets the order in which categories on this axis
                      appear. Only has an effect if `categoryorder`
                      is set to "array". Used with `categoryorder`.
                  categoryarraysrc
                      Sets the source reference on Chart Studio Cloud
                      for  categoryarray .
                  categoryorder
                      Specifies the ordering logic for the case of
                      categorical variables. By default, plotly uses
                      "trace", which specifies the order that is
                      present in the data supplied. Set
                      `categoryorder` to *category ascending* or
                      *category descending* if order should be
                      determined by the alphanumerical order of the
                      category names. Set `categoryorder` to "array"
                      to derive the ordering from the attribute
                      `categoryarray`. If a category is not found in
                      the `categoryarray` array, the sorting behavior
                      for that attribute will be identical to the
                      "trace" mode. The unspecified categories will
                      follow the categories in `categoryarray`.
                  cheatertype
      
                  color
                      Sets default for all colors associated with
                      this axis all at once: line, font, tick, and
                      grid colors. Grid color is lightened by
                      blending this with the plot background
                      Individual pieces can override this.
                  dtick
                      The stride between grid lines along the axis
                  endline
                      Determines whether or not a line is drawn at
                      along the final value of this axis. If True,
                      the end line is drawn on top of the grid lines.
                  endlinecolor
                      Sets the line color of the end line.
                  endlinewidth
                      Sets the width (in px) of the end line.
                  exponentformat
                      Determines a formatting rule for the tick
                      exponents. For example, consider the number
                      1,000,000,000. If "none", it appears as
                      1,000,000,000. If "e", 1e+9. If "E", 1E+9. If
                      "power", 1x10^9 (with 9 in a super script). If
                      "SI", 1G. If "B", 1B.
                  fixedrange
                      Determines whether or not this axis is zoom-
                      able. If true, then zoom is disabled.
                  gridcolor
                      Sets the axis line color.
                  gridwidth
                      Sets the width (in px) of the axis line.
                  labelpadding
                      Extra padding between label and the axis
                  labelprefix
                      Sets a axis label prefix.
                  labelsuffix
                      Sets a axis label suffix.
                  linecolor
                      Sets the axis line color.
                  linewidth
                      Sets the width (in px) of the axis line.
                  minexponent
                      Hide SI prefix for 10^n if |n| is below this
                      number
                  minorgridcolor
                      Sets the color of the grid lines.
                  minorgridcount
                      Sets the number of minor grid ticks per major
                      grid tick
                  minorgridwidth
                      Sets the width (in px) of the grid lines.
                  nticks
                      Specifies the maximum number of ticks for the
                      particular axis. The actual number of ticks
                      will be chosen automatically to be less than or
                      equal to `nticks`. Has an effect only if
                      `tickmode` is set to "auto".
                  range
                      Sets the range of this axis. If the axis `type`
                      is "log", then you must take the log of your
                      desired range (e.g. to set the range from 1 to
                      100, set the range from 0 to 2). If the axis
                      `type` is "date", it should be date strings,
                      like date data, though Date objects and unix
                      milliseconds will be accepted and converted to
                      strings. If the axis `type` is "category", it
                      should be numbers, using the scale where each
                      category is assigned a serial number from zero
                      in the order it appears.
                  rangemode
                      If "normal", the range is computed in relation
                      to the extrema of the input data. If *tozero*`,
                      the range extends to 0, regardless of the input
                      data If "nonnegative", the range is non-
                      negative, regardless of the input data.
                  separatethousands
                      If "true", even 4-digit integers are separated
                  showexponent
                      If "all", all exponents are shown besides their
                      significands. If "first", only the exponent of
                      the first tick is shown. If "last", only the
                      exponent of the last tick is shown. If "none",
                      no exponents appear.
                  showgrid
                      Determines whether or not grid lines are drawn.
                      If True, the grid lines are drawn at every tick
                      mark.
                  showline
                      Determines whether or not a line bounding this
                      axis is drawn.
                  showticklabels
                      Determines whether axis labels are drawn on the
                      low side, the high side, both, or neither side
                      of the axis.
                  showtickprefix
                      If "all", all tick labels are displayed with a
                      prefix. If "first", only the first tick is
                      displayed with a prefix. If "last", only the
                      last tick is displayed with a suffix. If
                      "none", tick prefixes are hidden.
                  showticksuffix
                      Same as `showtickprefix` but for tick suffixes.
                  smoothing
      
                  startline
                      Determines whether or not a line is drawn at
                      along the starting value of this axis. If True,
                      the start line is drawn on top of the grid
                      lines.
                  startlinecolor
                      Sets the line color of the start line.
                  startlinewidth
                      Sets the width (in px) of the start line.
                  tick0
                      The starting index of grid lines along the axis
                  tickangle
                      Sets the angle of the tick labels with respect
                      to the horizontal. For example, a `tickangle`
                      of -90 draws the tick labels vertically.
                  tickfont
                      Sets the tick font.
                  tickformat
                      Sets the tick label formatting rule using d3
                      formatting mini-languages which are very
                      similar to those in Python. For numbers, see:
                      https://github.com/d3/d3-3.x-api-
                      reference/blob/master/Formatting.md#d3_format
                      And for dates see:
                      https://github.com/d3/d3-time-
                      format#locale_format We add one item to d3's
                      date formatter: "%{n}f" for fractional seconds
                      with n digits. For example, *2016-10-13
                      09:15:23.456* with tickformat "%H~%M~%S.%2f"
                      would display "09~15~23.46"
                  tickformatstops
                      A tuple of :class:`plotly.graph_objects.carpet.
                      aaxis.Tickformatstop` instances or dicts with
                      compatible properties
                  tickformatstopdefaults
                      When used in a template (as layout.template.dat
                      a.carpet.aaxis.tickformatstopdefaults), sets
                      the default property values to use for elements
                      of carpet.aaxis.tickformatstops
                  tickmode
      
                  tickprefix
                      Sets a tick label prefix.
                  ticksuffix
                      Sets a tick label suffix.
                  ticktext
                      Sets the text displayed at the ticks position
                      via `tickvals`. Only has an effect if
                      `tickmode` is set to "array". Used with
                      `tickvals`.
                  ticktextsrc
                      Sets the source reference on Chart Studio Cloud
                      for  ticktext .
                  tickvals
                      Sets the values at which ticks on this axis
                      appear. Only has an effect if `tickmode` is set
                      to "array". Used with `ticktext`.
                  tickvalssrc
                      Sets the source reference on Chart Studio Cloud
                      for  tickvals .
                  title
                      :class:`plotly.graph_objects.carpet.aaxis.Title
                      ` instance or dict with compatible properties
                  titlefont
                      Deprecated: Please use carpet.aaxis.title.font
                      instead. Sets this axis' title font. Note that
                      the title's font used to be set by the now
                      deprecated `titlefont` attribute.
                  titleoffset
                      Deprecated: Please use
                      carpet.aaxis.title.offset instead. An
                      additional amount by which to offset the title
                      from the tick labels, given in pixels. Note
                      that this used to be set by the now deprecated
                      `titleoffset` attribute.
                  type
                      Sets the axis type. By default, plotly attempts
                      to determined the axis type by looking into the
                      data of the traces that referenced the axis in
                      question.
  
          Returns
          -------
          plotly.graph_objs.carpet.Aaxis
          """
          return self["aaxis"]
  
      @aaxis.setter
      def aaxis(self, val):
          self["aaxis"] = val
  
      # asrc
      # ----
      @property
      def asrc(self):
          """
          Sets the source reference on Chart Studio Cloud for  a .
      
          The 'asrc' property must be specified as a string or
          as a plotly.grid_objs.Column object
  
          Returns
          -------
          str
          """
          return self["asrc"]
  
      @asrc.setter
      def asrc(self, val):
          self["asrc"] = val
  
      # b
      # -
      @property
      def b(self):
          """
          A two dimensional array of y coordinates at each carpet point.
      
          The 'b' property is an array that may be specified as a tuple,
          list, numpy array, or pandas Series
  
          Returns
          -------
          numpy.ndarray
          """
          return self["b"]
  
      @b.setter
      def b(self, val):
          self["b"] = val
  
      # b0
      # --
      @property
      def b0(self):
          """
          Alternate to `b`. Builds a linear space of a coordinates. Use
          with `db` where `b0` is the starting coordinate and `db` the
          step.
      
          The 'b0' property is a number and may be specified as:
            - An int or float
  
          Returns
          -------
          int|float
          """
          return self["b0"]
  
      @b0.setter
      def b0(self, val):
          self["b0"] = val
  
      # baxis
      # -----
      @property
      def baxis(self):
          """
          The 'baxis' property is an instance of Baxis
          that may be specified as:
            - An instance of :class:`plotly.graph_objs.carpet.Baxis`
            - A dict of string/value properties that will be passed
              to the Baxis constructor
      
              Supported dict properties:
                  
                  arraydtick
                      The stride between grid lines along the axis
                  arraytick0
                      The starting index of grid lines along the axis
                  autorange
                      Determines whether or not the range of this
                      axis is computed in relation to the input data.
                      See `rangemode` for more info. If `range` is
                      provided, then `autorange` is set to False.
                  autotypenumbers
                      Using "strict" a numeric string in trace data
                      is not converted to a number. Using *convert
                      types* a numeric string in trace data may be
                      treated as a number during automatic axis
                      `type` detection. Defaults to
                      layout.autotypenumbers.
                  categoryarray
                      Sets the order in which categories on this axis
                      appear. Only has an effect if `categoryorder`
                      is set to "array". Used with `categoryorder`.
                  categoryarraysrc
                      Sets the source reference on Chart Studio Cloud
                      for  categoryarray .
                  categoryorder
                      Specifies the ordering logic for the case of
                      categorical variables. By default, plotly uses
                      "trace", which specifies the order that is
                      present in the data supplied. Set
                      `categoryorder` to *category ascending* or
                      *category descending* if order should be
                      determined by the alphanumerical order of the
                      category names. Set `categoryorder` to "array"
                      to derive the ordering from the attribute
                      `categoryarray`. If a category is not found in
                      the `categoryarray` array, the sorting behavior
                      for that attribute will be identical to the
                      "trace" mode. The unspecified categories will
                      follow the categories in `categoryarray`.
                  cheatertype
      
                  color
                      Sets default for all colors associated with
                      this axis all at once: line, font, tick, and
                      grid colors. Grid color is lightened by
                      blending this with the plot background
                      Individual pieces can override this.
                  dtick
                      The stride between grid lines along the axis
                  endline
                      Determines whether or not a line is drawn at
                      along the final value of this axis. If True,
                      the end line is drawn on top of the grid lines.
                  endlinecolor
                      Sets the line color of the end line.
                  endlinewidth
                      Sets the width (in px) of the end line.
                  exponentformat
                      Determines a formatting rule for the tick
                      exponents. For example, consider the number
                      1,000,000,000. If "none", it appears as
                      1,000,000,000. If "e", 1e+9. If "E", 1E+9. If
                      "power", 1x10^9 (with 9 in a super script). If
                      "SI", 1G. If "B", 1B.
                  fixedrange
                      Determines whether or not this axis is zoom-
                      able. If true, then zoom is disabled.
                  gridcolor
                      Sets the axis line color.
                  gridwidth
                      Sets the width (in px) of the axis line.
                  labelpadding
                      Extra padding between label and the axis
                  labelprefix
                      Sets a axis label prefix.
                  labelsuffix
                      Sets a axis label suffix.
                  linecolor
                      Sets the axis line color.
                  linewidth
                      Sets the width (in px) of the axis line.
                  minexponent
                      Hide SI prefix for 10^n if |n| is below this
                      number
                  minorgridcolor
                      Sets the color of the grid lines.
                  minorgridcount
                      Sets the number of minor grid ticks per major
                      grid tick
                  minorgridwidth
                      Sets the width (in px) of the grid lines.
                  nticks
                      Specifies the maximum number of ticks for the
                      particular axis. The actual number of ticks
                      will be chosen automatically to be less than or
                      equal to `nticks`. Has an effect only if
                      `tickmode` is set to "auto".
                  range
                      Sets the range of this axis. If the axis `type`
                      is "log", then you must take the log of your
                      desired range (e.g. to set the range from 1 to
                      100, set the range from 0 to 2). If the axis
                      `type` is "date", it should be date strings,
                      like date data, though Date objects and unix
                      milliseconds will be accepted and converted to
                      strings. If the axis `type` is "category", it
                      should be numbers, using the scale where each
                      category is assigned a serial number from zero
                      in the order it appears.
                  rangemode
                      If "normal", the range is computed in relation
                      to the extrema of the input data. If *tozero*`,
                      the range extends to 0, regardless of the input
                      data If "nonnegative", the range is non-
                      negative, regardless of the input data.
                  separatethousands
                      If "true", even 4-digit integers are separated
                  showexponent
                      If "all", all exponents are shown besides their
                      significands. If "first", only the exponent of
                      the first tick is shown. If "last", only the
                      exponent of the last tick is shown. If "none",
                      no exponents appear.
                  showgrid
                      Determines whether or not grid lines are drawn.
                      If True, the grid lines are drawn at every tick
                      mark.
                  showline
                      Determines whether or not a line bounding this
                      axis is drawn.
                  showticklabels
                      Determines whether axis labels are drawn on the
                      low side, the high side, both, or neither side
                      of the axis.
                  showtickprefix
                      If "all", all tick labels are displayed with a
                      prefix. If "first", only the first tick is
                      displayed with a prefix. If "last", only the
                      last tick is displayed with a suffix. If
                      "none", tick prefixes are hidden.
                  showticksuffix
                      Same as `showtickprefix` but for tick suffixes.
                  smoothing
      
                  startline
                      Determines whether or not a line is drawn at
                      along the starting value of this axis. If True,
                      the start line is drawn on top of the grid
                      lines.
                  startlinecolor
                      Sets the line color of the start line.
                  startlinewidth
                      Sets the width (in px) of the start line.
                  tick0
                      The starting index of grid lines along the axis
                  tickangle
                      Sets the angle of the tick labels with respect
                      to the horizontal. For example, a `tickangle`
                      of -90 draws the tick labels vertically.
                  tickfont
                      Sets the tick font.
                  tickformat
                      Sets the tick label formatting rule using d3
                      formatting mini-languages which are very
                      similar to those in Python. For numbers, see:
                      https://github.com/d3/d3-3.x-api-
                      reference/blob/master/Formatting.md#d3_format
                      And for dates see:
                      https://github.com/d3/d3-time-
                      format#locale_format We add one item to d3's
                      date formatter: "%{n}f" for fractional seconds
                      with n digits. For example, *2016-10-13
                      09:15:23.456* with tickformat "%H~%M~%S.%2f"
                      would display "09~15~23.46"
                  tickformatstops
                      A tuple of :class:`plotly.graph_objects.carpet.
                      baxis.Tickformatstop` instances or dicts with
                      compatible properties
                  tickformatstopdefaults
                      When used in a template (as layout.template.dat
                      a.carpet.baxis.tickformatstopdefaults), sets
                      the default property values to use for elements
                      of carpet.baxis.tickformatstops
                  tickmode
      
                  tickprefix
                      Sets a tick label prefix.
                  ticksuffix
                      Sets a tick label suffix.
                  ticktext
                      Sets the text displayed at the ticks position
                      via `tickvals`. Only has an effect if
                      `tickmode` is set to "array". Used with
                      `tickvals`.
                  ticktextsrc
                      Sets the source reference on Chart Studio Cloud
                      for  ticktext .
                  tickvals
                      Sets the values at which ticks on this axis
                      appear. Only has an effect if `tickmode` is set
                      to "array". Used with `ticktext`.
                  tickvalssrc
                      Sets the source reference on Chart Studio Cloud
                      for  tickvals .
                  title
                      :class:`plotly.graph_objects.carpet.baxis.Title
                      ` instance or dict with compatible properties
                  titlefont
                      Deprecated: Please use carpet.baxis.title.font
                      instead. Sets this axis' title font. Note that
                      the title's font used to be set by the now
                      deprecated `titlefont` attribute.
                  titleoffset
                      Deprecated: Please use
                      carpet.baxis.title.offset instead. An
                      additional amount by which to offset the title
                      from the tick labels, given in pixels. Note
                      that this used to be set by the now deprecated
                      `titleoffset` attribute.
                  type
                      Sets the axis type. By default, plotly attempts
                      to determined the axis type by looking into the
                      data of the traces that referenced the axis in
                      question.
  
          Returns
          -------
          plotly.graph_objs.carpet.Baxis
          """
          return self["baxis"]
  
      @baxis.setter
      def baxis(self, val):
          self["baxis"] = val
  
      # bsrc
      # ----
      @property
      def bsrc(self):
          """
          Sets the source reference on Chart Studio Cloud for  b .
      
          The 'bsrc' property must be specified as a string or
          as a plotly.grid_objs.Column object
  
          Returns
          -------
          str
          """
          return self["bsrc"]
  
      @bsrc.setter
      def bsrc(self, val):
          self["bsrc"] = val
  
      # carpet
      # ------
      @property
      def carpet(self):
          """
          An identifier for this carpet, so that `scattercarpet` and
          `contourcarpet` traces can specify a carpet plot on which they
          lie
      
          The 'carpet' property is a string and must be specified as:
            - A string
            - A number that will be converted to a string
  
          Returns
          -------
          str
          """
          return self["carpet"]
  
      @carpet.setter
      def carpet(self, val):
          self["carpet"] = val
  
      # cheaterslope
      # ------------
      @property
      def cheaterslope(self):
          """
          The shift applied to each successive row of data in creating a
          cheater plot. Only used if `x` is been omitted.
      
          The 'cheaterslope' property is a number and may be specified as:
            - An int or float
  
          Returns
          -------
          int|float
          """
          return self["cheaterslope"]
  
      @cheaterslope.setter
      def cheaterslope(self, val):
          self["cheaterslope"] = val
  
      # color
      # -----
      @property
      def color(self):
          """
          Sets default for all colors associated with this axis all at
          once: line, font, tick, and grid colors. Grid color is
          lightened by blending this with the plot background Individual
          pieces can override this.
      
          The 'color' property is a color and may be specified as:
            - A hex string (e.g. '#ff0000')
            - An rgb/rgba string (e.g. 'rgb(255,0,0)')
            - An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
            - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
            - A named CSS color:
                  aliceblue, antiquewhite, aqua, aquamarine, azure,
                  beige, bisque, black, blanchedalmond, blue,
                  blueviolet, brown, burlywood, cadetblue,
                  chartreuse, chocolate, coral, cornflowerblue,
                  cornsilk, crimson, cyan, darkblue, darkcyan,
                  darkgoldenrod, darkgray, darkgrey, darkgreen,
                  darkkhaki, darkmagenta, darkolivegreen, darkorange,
                  darkorchid, darkred, darksalmon, darkseagreen,
                  darkslateblue, darkslategray, darkslategrey,
                  darkturquoise, darkviolet, deeppink, deepskyblue,
                  dimgray, dimgrey, dodgerblue, firebrick,
                  floralwhite, forestgreen, fuchsia, gainsboro,
                  ghostwhite, gold, goldenrod, gray, grey, green,
                  greenyellow, honeydew, hotpink, indianred, indigo,
                  ivory, khaki, lavender, lavenderblush, lawngreen,
                  lemonchiffon, lightblue, lightcoral, lightcyan,
                  lightgoldenrodyellow, lightgray, lightgrey,
                  lightgreen, lightpink, lightsalmon, lightseagreen,
                  lightskyblue, lightslategray, lightslategrey,
                  lightsteelblue, lightyellow, lime, limegreen,
                  linen, magenta, maroon, mediumaquamarine,
                  mediumblue, mediumorchid, mediumpurple,
                  mediumseagreen, mediumslateblue, mediumspringgreen,
                  mediumturquoise, mediumvioletred, midnightblue,
                  mintcream, mistyrose, moccasin, navajowhite, navy,
                  oldlace, olive, olivedrab, orange, orangered,
                  orchid, palegoldenrod, palegreen, paleturquoise,
                  palevioletred, papayawhip, peachpuff, peru, pink,
                  plum, powderblue, purple, red, rosybrown,
                  royalblue, rebeccapurple, saddlebrown, salmon,
                  sandybrown, seagreen, seashell, sienna, silver,
                  skyblue, slateblue, slategray, slategrey, snow,
                  springgreen, steelblue, tan, teal, thistle, tomato,
                  turquoise, violet, wheat, white, whitesmoke,
                  yellow, yellowgreen
  
          Returns
          -------
          str
          """
          return self["color"]
  
      @color.setter
      def color(self, val):
          self["color"] = val
  
      # customdata
      # ----------
      @property
      def customdata(self):
          """
          Assigns extra data each datum. This may be useful when
          listening to hover, click and selection events. Note that,
          "scatter" traces also appends customdata items in the markers
          DOM elements
      
          The 'customdata' property is an array that may be specified as a tuple,
          list, numpy array, or pandas Series
  
          Returns
          -------
          numpy.ndarray
          """
          return self["customdata"]
  
      @customdata.setter
      def customdata(self, val):
          self["customdata"] = val
  
      # customdatasrc
      # -------------
      @property
      def customdatasrc(self):
          """
          Sets the source reference on Chart Studio Cloud for  customdata
          .
      
          The 'customdatasrc' property must be specified as a string or
          as a plotly.grid_objs.Column object
  
          Returns
          -------
          str
          """
          return self["customdatasrc"]
  
      @customdatasrc.setter
      def customdatasrc(self, val):
          self["customdatasrc"] = val
  
      # da
      # --
      @property
      def da(self):
          """
          Sets the a coordinate step. See `a0` for more info.
      
          The 'da' property is a number and may be specified as:
            - An int or float
  
          Returns
          -------
          int|float
          """
          return self["da"]
  
      @da.setter
      def da(self, val):
          self["da"] = val
  
      # db
      # --
      @property
      def db(self):
          """
          Sets the b coordinate step. See `b0` for more info.
      
          The 'db' property is a number and may be specified as:
            - An int or float
  
          Returns
          -------
          int|float
          """
          return self["db"]
  
      @db.setter
      def db(self, val):
          self["db"] = val
  
      # font
      # ----
      @property
      def font(self):
          """
          The default font used for axis & tick labels on this carpet
      
          The 'font' property is an instance of Font
          that may be specified as:
            - An instance of :class:`plotly.graph_objs.carpet.Font`
            - A dict of string/value properties that will be passed
              to the Font constructor
      
              Supported dict properties:
                  
                  color
      
                  family
                      HTML font family - the typeface that will be
                      applied by the web browser. The web browser
                      will only be able to apply a font if it is
                      available on the system which it operates.
                      Provide multiple font families, separated by
                      commas, to indicate the preference in which to
                      apply fonts if they aren't available on the
                      system. The Chart Studio Cloud (at
                      https://chart-studio.plotly.com or on-premise)
                      generates images on a server, where only a
                      select number of fonts are installed and
                      supported. These include "Arial", "Balto",
                      "Courier New", "Droid Sans",, "Droid Serif",
                      "Droid Sans Mono", "Gravitas One", "Old
                      Standard TT", "Open Sans", "Overpass", "PT Sans
                      Narrow", "Raleway", "Times New Roman".
                  size
  
          Returns
          -------
          plotly.graph_objs.carpet.Font
          """
          return self["font"]
  
      @font.setter
      def font(self, val):
          self["font"] = val
  
      # ids
      # ---
      @property
      def ids(self):
          """
          Assigns id labels to each datum. These ids for object constancy
          of data points during animation. Should be an array of strings,
          not numbers or any other type.
      
          The 'ids' property is an array that may be specified as a tuple,
          list, numpy array, or pandas Series
  
          Returns
          -------
          numpy.ndarray
          """
          return self["ids"]
  
      @ids.setter
      def ids(self, val):
          self["ids"] = val
  
      # idssrc
      # ------
      @property
      def idssrc(self):
          """
          Sets the source reference on Chart Studio Cloud for  ids .
      
          The 'idssrc' property must be specified as a string or
          as a plotly.grid_objs.Column object
  
          Returns
          -------
          str
          """
          return self["idssrc"]
  
      @idssrc.setter
      def idssrc(self, val):
          self["idssrc"] = val
  
      # meta
      # ----
      @property
      def meta(self):
          """
          Assigns extra meta information associated with this trace that
          can be used in various text attributes. Attributes such as
          trace `name`, graph, axis and colorbar `title.text`, annotation
          `text` `rangeselector`, `updatemenues` and `sliders` `label`
          text all support `meta`. To access the trace `meta` values in
          an attribute in the same trace, simply use `%{meta[i]}` where
          `i` is the index or key of the `meta` item in question. To
          access trace `meta` in layout attributes, use
          `%{data[n[.meta[i]}` where `i` is the index or key of the
          `meta` and `n` is the trace index.
      
          The 'meta' property accepts values of any type
  
          Returns
          -------
          Any|numpy.ndarray
          """
          return self["meta"]
  
      @meta.setter
      def meta(self, val):
          self["meta"] = val
  
      # metasrc
      # -------
      @property
      def metasrc(self):
          """
          Sets the source reference on Chart Studio Cloud for  meta .
      
          The 'metasrc' property must be specified as a string or
          as a plotly.grid_objs.Column object
  
          Returns
          -------
          str
          """
          return self["metasrc"]
  
      @metasrc.setter
      def metasrc(self, val):
          self["metasrc"] = val
  
      # name
      # ----
      @property
      def name(self):
          """
          Sets the trace name. The trace name appear as the legend item
          and on hover.
      
          The 'name' property is a string and must be specified as:
            - A string
            - A number that will be converted to a string
  
          Returns
          -------
          str
          """
          return self["name"]
  
      @name.setter
      def name(self, val):
          self["name"] = val
  
      # opacity
      # -------
      @property
      def opacity(self):
          """
          Sets the opacity of the trace.
      
          The 'opacity' property is a number and may be specified as:
            - An int or float in the interval [0, 1]
  
          Returns
          -------
          int|float
          """
          return self["opacity"]
  
      @opacity.setter
      def opacity(self, val):
          self["opacity"] = val
  
      # stream
      # ------
      @property
      def stream(self):
          """
          The 'stream' property is an instance of Stream
          that may be specified as:
            - An instance of :class:`plotly.graph_objs.carpet.Stream`
            - A dict of string/value properties that will be passed
              to the Stream constructor
      
              Supported dict properties:
                  
                  maxpoints
                      Sets the maximum number of points to keep on
                      the plots from an incoming stream. If
                      `maxpoints` is set to 50, only the newest 50
                      points will be displayed on the plot.
                  token
                      The stream id number links a data trace on a
                      plot with a stream. See https://chart-
                      studio.plotly.com/settings for more details.
  
          Returns
          -------
          plotly.graph_objs.carpet.Stream
          """
          return self["stream"]
  
      @stream.setter
      def stream(self, val):
          self["stream"] = val
  
      # uid
      # ---
      @property
      def uid(self):
          """
          Assign an id to this trace, Use this to provide object
          constancy between traces during animations and transitions.
      
          The 'uid' property is a string and must be specified as:
            - A string
            - A number that will be converted to a string
  
          Returns
          -------
          str
          """
          return self["uid"]
  
      @uid.setter
      def uid(self, val):
          self["uid"] = val
  
      # uirevision
      # ----------
      @property
      def uirevision(self):
          """
          Controls persistence of some user-driven changes to the trace:
          `constraintrange` in `parcoords` traces, as well as some
          `editable: true` modifications such as `name` and
          `colorbar.title`. Defaults to `layout.uirevision`. Note that
          other user-driven trace attribute changes are controlled by
          `layout` attributes: `trace.visible` is controlled by
          `layout.legend.uirevision`, `selectedpoints` is controlled by
          `layout.selectionrevision`, and `colorbar.(x|y)` (accessible
          with `config: {editable: true}`) is controlled by
          `layout.editrevision`. Trace changes are tracked by `uid`,
          which only falls back on trace index if no `uid` is provided.
          So if your app can add/remove traces before the end of the
          `data` array, such that the same trace has a different index,
          you can still preserve user-driven changes if you give each
          trace a `uid` that stays with it as it moves.
      
          The 'uirevision' property accepts values of any type
  
          Returns
          -------
          Any
          """
          return self["uirevision"]
  
      @uirevision.setter
      def uirevision(self, val):
          self["uirevision"] = val
  
      # visible
      # -------
      @property
      def visible(self):
          """
          Determines whether or not this trace is visible. If
          "legendonly", the trace is not drawn, but can appear as a
          legend item (provided that the legend itself is visible).
      
          The 'visible' property is an enumeration that may be specified as:
            - One of the following enumeration values:
                  [True, False, 'legendonly']
  
          Returns
          -------
          Any
          """
          return self["visible"]
  
      @visible.setter
      def visible(self, val):
          self["visible"] = val
  
      # x
      # -
      @property
      def x(self):
          """
          A two dimensional array of x coordinates at each carpet point.
          If omitted, the plot is a cheater plot and the xaxis is hidden
          by default.
      
          The 'x' property is an array that may be specified as a tuple,
          list, numpy array, or pandas Series
  
          Returns
          -------
          numpy.ndarray
          """
          return self["x"]
  
      @x.setter
      def x(self, val):
          self["x"] = val
  
      # xaxis
      # -----
      @property
      def xaxis(self):
          """
          Sets a reference between this trace's x coordinates and a 2D
          cartesian x axis. If "x" (the default value), the x coordinates
          refer to `layout.xaxis`. If "x2", the x coordinates refer to
          `layout.xaxis2`, and so on.
      
          The 'xaxis' property is an identifier of a particular
          subplot, of type 'x', that may be specified as the string 'x'
          optionally followed by an integer >= 1
          (e.g. 'x', 'x1', 'x2', 'x3', etc.)
  
          Returns
          -------
          str
          """
          return self["xaxis"]
  
      @xaxis.setter
      def xaxis(self, val):
          self["xaxis"] = val
  
      # xsrc
      # ----
      @property
      def xsrc(self):
          """
          Sets the source reference on Chart Studio Cloud for  x .
      
          The 'xsrc' property must be specified as a string or
          as a plotly.grid_objs.Column object
  
          Returns
          -------
          str
          """
          return self["xsrc"]
  
      @xsrc.setter
      def xsrc(self, val):
          self["xsrc"] = val
  
      # y
      # -
      @property
      def y(self):
          """
          A two dimensional array of y coordinates at each carpet point.
      
          The 'y' property is an array that may be specified as a tuple,
          list, numpy array, or pandas Series
  
          Returns
          -------
          numpy.ndarray
          """
          return self["y"]
  
      @y.setter
      def y(self, val):
          self["y"] = val
  
      # yaxis
      # -----
      @property
      def yaxis(self):
          """
          Sets a reference between this trace's y coordinates and a 2D
          cartesian y axis. If "y" (the default value), the y coordinates
          refer to `layout.yaxis`. If "y2", the y coordinates refer to
          `layout.yaxis2`, and so on.
      
          The 'yaxis' property is an identifier of a particular
          subplot, of type 'y', that may be specified as the string 'y'
          optionally followed by an integer >= 1
          (e.g. 'y', 'y1', 'y2', 'y3', etc.)
  
          Returns
          -------
          str
          """
          return self["yaxis"]
  
      @yaxis.setter
      def yaxis(self, val):
          self["yaxis"] = val
  
      # ysrc
      # ----
      @property
      def ysrc(self):
          """
          Sets the source reference on Chart Studio Cloud for  y .
      
          The 'ysrc' property must be specified as a string or
          as a plotly.grid_objs.Column object
  
          Returns
          -------
          str
          """
          return self["ysrc"]
  
      @ysrc.setter
      def ysrc(self, val):
          self["ysrc"] = val
  
      # type
      # ----
      @property
      def type(self):
          return self._props["type"]
  
      # Self properties description
      # ---------------------------
      @property
      def _prop_descriptions(self):
          return """\
          a
              An array containing values of the first parameter value
          a0
              Alternate to `a`. Builds a linear space of a
              coordinates. Use with `da` where `a0` is the starting
              coordinate and `da` the step.
          aaxis
              :class:`plotly.graph_objects.carpet.Aaxis` instance or
              dict with compatible properties
          asrc
              Sets the source reference on Chart Studio Cloud for  a
              .
          b
              A two dimensional array of y coordinates at each carpet
              point.
          b0
              Alternate to `b`. Builds a linear space of a
              coordinates. Use with `db` where `b0` is the starting
              coordinate and `db` the step.
          baxis
              :class:`plotly.graph_objects.carpet.Baxis` instance or
              dict with compatible properties
          bsrc
              Sets the source reference on Chart Studio Cloud for  b
              .
          carpet
              An identifier for this carpet, so that `scattercarpet`
              and `contourcarpet` traces can specify a carpet plot on
              which they lie
          cheaterslope
              The shift applied to each successive row of data in
              creating a cheater plot. Only used if `x` is been
              omitted.
          color
              Sets default for all colors associated with this axis
              all at once: line, font, tick, and grid colors. Grid
              color is lightened by blending this with the plot
              background Individual pieces can override this.
          customdata
              Assigns extra data each datum. This may be useful when
              listening to hover, click and selection events. Note
              that, "scatter" traces also appends customdata items in
              the markers DOM elements
          customdatasrc
              Sets the source reference on Chart Studio Cloud for
              customdata .
          da
              Sets the a coordinate step. See `a0` for more info.
          db
              Sets the b coordinate step. See `b0` for more info.
          font
              The default font used for axis & tick labels on this
              carpet
          ids
              Assigns id labels to each datum. These ids for object
              constancy of data points during animation. Should be an
              array of strings, not numbers or any other type.
          idssrc
              Sets the source reference on Chart Studio Cloud for
              ids .
          meta
              Assigns extra meta information associated with this
              trace that can be used in various text attributes.
              Attributes such as trace `name`, graph, axis and
              colorbar `title.text`, annotation `text`
              `rangeselector`, `updatemenues` and `sliders` `label`
              text all support `meta`. To access the trace `meta`
              values in an attribute in the same trace, simply use
              `%{meta[i]}` where `i` is the index or key of the
              `meta` item in question. To access trace `meta` in
              layout attributes, use `%{data[n[.meta[i]}` where `i`
              is the index or key of the `meta` and `n` is the trace
              index.
          metasrc
              Sets the source reference on Chart Studio Cloud for
              meta .
          name
              Sets the trace name. The trace name appear as the
              legend item and on hover.
          opacity
              Sets the opacity of the trace.
          stream
              :class:`plotly.graph_objects.carpet.Stream` instance or
              dict with compatible properties
          uid
              Assign an id to this trace, Use this to provide object
              constancy between traces during animations and
              transitions.
          uirevision
              Controls persistence of some user-driven changes to the
              trace: `constraintrange` in `parcoords` traces, as well
              as some `editable: true` modifications such as `name`
              and `colorbar.title`. Defaults to `layout.uirevision`.
              Note that other user-driven trace attribute changes are
              controlled by `layout` attributes: `trace.visible` is
              controlled by `layout.legend.uirevision`,
              `selectedpoints` is controlled by
              `layout.selectionrevision`, and `colorbar.(x|y)`
              (accessible with `config: {editable: true}`) is
              controlled by `layout.editrevision`. Trace changes are
              tracked by `uid`, which only falls back on trace index
              if no `uid` is provided. So if your app can add/remove
              traces before the end of the `data` array, such that
              the same trace has a different index, you can still
              preserve user-driven changes if you give each trace a
              `uid` that stays with it as it moves.
          visible
              Determines whether or not this trace is visible. If
              "legendonly", the trace is not drawn, but can appear as
              a legend item (provided that the legend itself is
              visible).
          x
              A two dimensional array of x coordinates at each carpet
              point. If omitted, the plot is a cheater plot and the
              xaxis is hidden by default.
          xaxis
              Sets a reference between this trace's x coordinates and
              a 2D cartesian x axis. If "x" (the default value), the
              x coordinates refer to `layout.xaxis`. If "x2", the x
              coordinates refer to `layout.xaxis2`, and so on.
          xsrc
              Sets the source reference on Chart Studio Cloud for  x
              .
          y
              A two dimensional array of y coordinates at each carpet
              point.
          yaxis
              Sets a reference between this trace's y coordinates and
              a 2D cartesian y axis. If "y" (the default value), the
              y coordinates refer to `layout.yaxis`. If "y2", the y
              coordinates refer to `layout.yaxis2`, and so on.
          ysrc
              Sets the source reference on Chart Studio Cloud for  y
              .
          """
  
      def __init__(
          self,
          arg=None,
          a=None,
          a0=None,
          aaxis=None,
          asrc=None,
          b=None,
          b0=None,
          baxis=None,
          bsrc=None,
          carpet=None,
          cheaterslope=None,
          color=None,
          customdata=None,
          customdatasrc=None,
          da=None,
          db=None,
          font=None,
          ids=None,
          idssrc=None,
          meta=None,
          metasrc=None,
          name=None,
          opacity=None,
          stream=None,
          uid=None,
          uirevision=None,
          visible=None,
          x=None,
          xaxis=None,
          xsrc=None,
          y=None,
          yaxis=None,
          ysrc=None,
          **kwargs
      ):
          """
          Construct a new Carpet object
          
          The data describing carpet axis layout is set in `y` and
          (optionally) also `x`. If only `y` is present, `x` the plot is
          interpreted as a cheater plot and is filled in using the `y`
          values. `x` and `y` may either be 2D arrays matching with each
          dimension matching that of `a` and `b`, or they may be 1D
          arrays with total length equal to that of `a` and `b`.
  
          Parameters
          ----------
          arg
              dict of properties compatible with this constructor or
              an instance of :class:`plotly.graph_objs.Carpet`
          a
              An array containing values of the first parameter value
          a0
              Alternate to `a`. Builds a linear space of a
              coordinates. Use with `da` where `a0` is the starting
              coordinate and `da` the step.
          aaxis
              :class:`plotly.graph_objects.carpet.Aaxis` instance or
              dict with compatible properties
          asrc
              Sets the source reference on Chart Studio Cloud for  a
              .
          b
              A two dimensional array of y coordinates at each carpet
              point.
          b0
              Alternate to `b`. Builds a linear space of a
              coordinates. Use with `db` where `b0` is the starting
              coordinate and `db` the step.
          baxis
              :class:`plotly.graph_objects.carpet.Baxis` instance or
              dict with compatible properties
          bsrc
              Sets the source reference on Chart Studio Cloud for  b
              .
          carpet
              An identifier for this carpet, so that `scattercarpet`
              and `contourcarpet` traces can specify a carpet plot on
              which they lie
          cheaterslope
              The shift applied to each successive row of data in
              creating a cheater plot. Only used if `x` is been
              omitted.
          color
              Sets default for all colors associated with this axis
              all at once: line, font, tick, and grid colors. Grid
              color is lightened by blending this with the plot
              background Individual pieces can override this.
          customdata
              Assigns extra data each datum. This may be useful when
              listening to hover, click and selection events. Note
              that, "scatter" traces also appends customdata items in
              the markers DOM elements
          customdatasrc
              Sets the source reference on Chart Studio Cloud for
              customdata .
          da
              Sets the a coordinate step. See `a0` for more info.
          db
              Sets the b coordinate step. See `b0` for more info.
          font
              The default font used for axis & tick labels on this
              carpet
          ids
              Assigns id labels to each datum. These ids for object
              constancy of data points during animation. Should be an
              array of strings, not numbers or any other type.
          idssrc
              Sets the source reference on Chart Studio Cloud for
              ids .
          meta
              Assigns extra meta information associated with this
              trace that can be used in various text attributes.
              Attributes such as trace `name`, graph, axis and
              colorbar `title.text`, annotation `text`
              `rangeselector`, `updatemenues` and `sliders` `label`
              text all support `meta`. To access the trace `meta`
              values in an attribute in the same trace, simply use
              `%{meta[i]}` where `i` is the index or key of the
              `meta` item in question. To access trace `meta` in
              layout attributes, use `%{data[n[.meta[i]}` where `i`
              is the index or key of the `meta` and `n` is the trace
              index.
          metasrc
              Sets the source reference on Chart Studio Cloud for
              meta .
          name
              Sets the trace name. The trace name appear as the
              legend item and on hover.
          opacity
              Sets the opacity of the trace.
          stream
              :class:`plotly.graph_objects.carpet.Stream` instance or
              dict with compatible properties
          uid
              Assign an id to this trace, Use this to provide object
              constancy between traces during animations and
              transitions.
          uirevision
              Controls persistence of some user-driven changes to the
              trace: `constraintrange` in `parcoords` traces, as well
              as some `editable: true` modifications such as `name`
              and `colorbar.title`. Defaults to `layout.uirevision`.
              Note that other user-driven trace attribute changes are
              controlled by `layout` attributes: `trace.visible` is
              controlled by `layout.legend.uirevision`,
              `selectedpoints` is controlled by
              `layout.selectionrevision`, and `colorbar.(x|y)`
              (accessible with `config: {editable: true}`) is
              controlled by `layout.editrevision`. Trace changes are
              tracked by `uid`, which only falls back on trace index
              if no `uid` is provided. So if your app can add/remove
              traces before the end of the `data` array, such that
              the same trace has a different index, you can still
              preserve user-driven changes if you give each trace a
              `uid` that stays with it as it moves.
          visible
              Determines whether or not this trace is visible. If
              "legendonly", the trace is not drawn, but can appear as
              a legend item (provided that the legend itself is
              visible).
          x
              A two dimensional array of x coordinates at each carpet
              point. If omitted, the plot is a cheater plot and the
              xaxis is hidden by default.
          xaxis
              Sets a reference between this trace's x coordinates and
              a 2D cartesian x axis. If "x" (the default value), the
              x coordinates refer to `layout.xaxis`. If "x2", the x
              coordinates refer to `layout.xaxis2`, and so on.
          xsrc
              Sets the source reference on Chart Studio Cloud for  x
              .
          y
              A two dimensional array of y coordinates at each carpet
              point.
          yaxis
              Sets a reference between this trace's y coordinates and
              a 2D cartesian y axis. If "y" (the default value), the
              y coordinates refer to `layout.yaxis`. If "y2", the y
              coordinates refer to `layout.yaxis2`, and so on.
          ysrc
              Sets the source reference on Chart Studio Cloud for  y
              .
  
          Returns
          -------
          Carpet
          """
          super(Carpet, self).__init__("carpet")
  
          if "_parent" in kwargs:
              self._parent = kwargs["_parent"]
              return
  
          # Validate arg
          # ------------
          if arg is None:
              arg = {}
          elif isinstance(arg, self.__class__):
              arg = arg.to_plotly_json()
          elif isinstance(arg, dict):
              arg = _copy.copy(arg)
          else:
              raise ValueError(
                  """\
  The first argument to the plotly.graph_objs.Carpet 
  constructor must be a dict or 
  an instance of :class:`plotly.graph_objs.Carpet`"""
              )
  
          # Handle skip_invalid
          # -------------------
          self._skip_invalid = kwargs.pop("skip_invalid", False)
          self._validate = kwargs.pop("_validate", True)
  
          # Populate data dict with properties
          # ----------------------------------
          _v = arg.pop("a", None)
          _v = a if a is not None else _v
          if _v is not None:
              self["a"] = _v
          _v = arg.pop("a0", None)
          _v = a0 if a0 is not None else _v
          if _v is not None:
              self["a0"] = _v
          _v = arg.pop("aaxis", None)
          _v = aaxis if aaxis is not None else _v
          if _v is not None:
              self["aaxis"] = _v
          _v = arg.pop("asrc", None)
          _v = asrc if asrc is not None else _v
          if _v is not None:
              self["asrc"] = _v
          _v = arg.pop("b", None)
          _v = b if b is not None else _v
          if _v is not None:
              self["b"] = _v
          _v = arg.pop("b0", None)
          _v = b0 if b0 is not None else _v
          if _v is not None:
              self["b0"] = _v
          _v = arg.pop("baxis", None)
          _v = baxis if baxis is not None else _v
          if _v is not None:
              self["baxis"] = _v
          _v = arg.pop("bsrc", None)
          _v = bsrc if bsrc is not None else _v
          if _v is not None:
              self["bsrc"] = _v
          _v = arg.pop("carpet", None)
          _v = carpet if carpet is not None else _v
          if _v is not None:
              self["carpet"] = _v
          _v = arg.pop("cheaterslope", None)
          _v = cheaterslope if cheaterslope is not None else _v
          if _v is not None:
              self["cheaterslope"] = _v
          _v = arg.pop("color", None)
          _v = color if color is not None else _v
          if _v is not None:
              self["color"] = _v
          _v = arg.pop("customdata", None)
          _v = customdata if customdata is not None else _v
          if _v is not None:
              self["customdata"] = _v
          _v = arg.pop("customdatasrc", None)
          _v = customdatasrc if customdatasrc is not None else _v
          if _v is not None:
              self["customdatasrc"] = _v
          _v = arg.pop("da", None)
          _v = da if da is not None else _v
          if _v is not None:
              self["da"] = _v
          _v = arg.pop("db", None)
          _v = db if db is not None else _v
          if _v is not None:
              self["db"] = _v
          _v = arg.pop("font", None)
          _v = font if font is not None else _v
          if _v is not None:
              self["font"] = _v
          _v = arg.pop("ids", None)
          _v = ids if ids is not None else _v
          if _v is not None:
              self["ids"] = _v
          _v = arg.pop("idssrc", None)
          _v = idssrc if idssrc is not None else _v
          if _v is not None:
              self["idssrc"] = _v
          _v = arg.pop("meta", None)
          _v = meta if meta is not None else _v
          if _v is not None:
              self["meta"] = _v
          _v = arg.pop("metasrc", None)
          _v = metasrc if metasrc is not None else _v
          if _v is not None:
              self["metasrc"] = _v
          _v = arg.pop("name", None)
          _v = name if name is not None else _v
          if _v is not None:
              self["name"] = _v
          _v = arg.pop("opacity", None)
          _v = opacity if opacity is not None else _v
          if _v is not None:
              self["opacity"] = _v
          _v = arg.pop("stream", None)
          _v = stream if stream is not None else _v
          if _v is not None:
              self["stream"] = _v
          _v = arg.pop("uid", None)
          _v = uid if uid is not None else _v
          if _v is not None:
              self["uid"] = _v
          _v = arg.pop("uirevision", None)
          _v = uirevision if uirevision is not None else _v
          if _v is not None:
              self["uirevision"] = _v
          _v = arg.pop("visible", None)
          _v = visible if visible is not None else _v
          if _v is not None:
              self["visible"] = _v
          _v = arg.pop("x", None)
          _v = x if x is not None else _v
          if _v is not None:
              self["x"] = _v
          _v = arg.pop("xaxis", None)
          _v = xaxis if xaxis is not None else _v
          if _v is not None:
              self["xaxis"] = _v
          _v = arg.pop("xsrc", None)
          _v = xsrc if xsrc is not None else _v
          if _v is not None:
              self["xsrc"] = _v
          _v = arg.pop("y", None)
          _v = y if y is not None else _v
          if _v is not None:
              self["y"] = _v
          _v = arg.pop("yaxis", None)
          _v = yaxis if yaxis is not None else _v
          if _v is not None:
              self["yaxis"] = _v
          _v = arg.pop("ysrc", None)
          _v = ysrc if ysrc is not None else _v
          if _v is not None:
              self["ysrc"] = _v
  
          # Read-only literals
          # ------------------
  
          self._props["type"] = "carpet"
          arg.pop("type", None)
  
          # Process unknown kwargs
          # ----------------------
          self._process_kwargs(**dict(arg, **kwargs))
  
          # Reset skip_invalid
          # ------------------
          self._skip_invalid = False
  