text: from plotly.basedatatypes import BaseTraceType
  import copy
  
  
  class Area(BaseTraceType):
  
      # 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 plot.ly 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
  
      # hoverinfo
      # ---------
      @property
      def hoverinfo(self):
          """
          Determines which trace information appear on hover. If `none`
          or `skip` are set, no information is displayed upon hovering.
          But, if `none` is set, click and hover events are still fired.
      
          The 'hoverinfo' property is a flaglist and may be specified
          as a string containing:
            - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters
              (e.g. 'x+y')
              OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip')
            - A list or array of the above
  
          Returns
          -------
          Any|numpy.ndarray
          """
          return self['hoverinfo']
  
      @hoverinfo.setter
      def hoverinfo(self, val):
          self['hoverinfo'] = val
  
      # hoverinfosrc
      # ------------
      @property
      def hoverinfosrc(self):
          """
          Sets the source reference on plot.ly for  hoverinfo .
      
          The 'hoverinfosrc' property must be specified as a string or
          as a plotly.grid_objs.Column object
  
          Returns
          -------
          str
          """
          return self['hoverinfosrc']
  
      @hoverinfosrc.setter
      def hoverinfosrc(self, val):
          self['hoverinfosrc'] = val
  
      # hoverlabel
      # ----------
      @property
      def hoverlabel(self):
          """
          The 'hoverlabel' property is an instance of Hoverlabel
          that may be specified as:
            - An instance of plotly.graph_objs.area.Hoverlabel
            - A dict of string/value properties that will be passed
              to the Hoverlabel constructor
      
              Supported dict properties:
                  
                  bgcolor
                      Sets the background color of the hover labels
                      for this trace
                  bgcolorsrc
                      Sets the source reference on plot.ly for
                      bgcolor .
                  bordercolor
                      Sets the border color of the hover labels for
                      this trace.
                  bordercolorsrc
                      Sets the source reference on plot.ly for
                      bordercolor .
                  font
                      Sets the font used in hover labels.
                  namelength
                      Sets the length (in number of characters) of
                      the trace name in the hover labels for this
                      trace. -1 shows the whole name regardless of
                      length. 0-3 shows the first 0-3 characters, and
                      an integer >3 will show the whole name if it is
                      less than that many characters, but if it is
                      longer, will truncate to `namelength - 3`
                      characters and add an ellipsis.
                  namelengthsrc
                      Sets the source reference on plot.ly for
                      namelength .
  
          Returns
          -------
          plotly.graph_objs.area.Hoverlabel
          """
          return self['hoverlabel']
  
      @hoverlabel.setter
      def hoverlabel(self, val):
          self['hoverlabel'] = 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 plot.ly 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
  
      # legendgroup
      # -----------
      @property
      def legendgroup(self):
          """
          Sets the legend group for this trace. Traces part of the same
          legend group hide/show at the same time when toggling legend
          items.
      
          The 'legendgroup' property is a string and must be specified as:
            - A string
            - A number that will be converted to a string
  
          Returns
          -------
          str
          """
          return self['legendgroup']
  
      @legendgroup.setter
      def legendgroup(self, val):
          self['legendgroup'] = val
  
      # marker
      # ------
      @property
      def marker(self):
          """
          The 'marker' property is an instance of Marker
          that may be specified as:
            - An instance of plotly.graph_objs.area.Marker
            - A dict of string/value properties that will be passed
              to the Marker constructor
      
              Supported dict properties:
                  
                  color
                      Area traces are deprecated! Please switch to
                      the "barpolar" trace type. Sets themarkercolor.
                      It accepts either a specific color or an array
                      of numbers that are mapped to the colorscale
                      relative to the max and min values of the array
                      or relative to `marker.cmin` and `marker.cmax`
                      if set.
                  colorsrc
                      Sets the source reference on plot.ly for  color
                      .
                  opacity
                      Area traces are deprecated! Please switch to
                      the "barpolar" trace type. Sets the marker
                      opacity.
                  opacitysrc
                      Sets the source reference on plot.ly for
                      opacity .
                  size
                      Area traces are deprecated! Please switch to
                      the "barpolar" trace type. Sets the marker size
                      (in px).
                  sizesrc
                      Sets the source reference on plot.ly for  size
                      .
                  symbol
                      Area traces are deprecated! Please switch to
                      the "barpolar" trace type. Sets the marker
                      symbol type. Adding 100 is equivalent to
                      appending "-open" to a symbol name. Adding 200
                      is equivalent to appending "-dot" to a symbol
                      name. Adding 300 is equivalent to appending
                      "-open-dot" or "dot-open" to a symbol name.
                  symbolsrc
                      Sets the source reference on plot.ly for
                      symbol .
  
          Returns
          -------
          plotly.graph_objs.area.Marker
          """
          return self['marker']
  
      @marker.setter
      def marker(self, val):
          self['marker'] = 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
  
      # r
      # -
      @property
      def r(self):
          """
          Area traces are deprecated! Please switch to the "barpolar"
          trace type. Sets the radial coordinates for legacy polar chart
          only.
      
          The 'r' property is an array that may be specified as a tuple,
          list, numpy array, or pandas Series
  
          Returns
          -------
          numpy.ndarray
          """
          return self['r']
  
      @r.setter
      def r(self, val):
          self['r'] = val
  
      # rsrc
      # ----
      @property
      def rsrc(self):
          """
          Sets the source reference on plot.ly for  r .
      
          The 'rsrc' property must be specified as a string or
          as a plotly.grid_objs.Column object
  
          Returns
          -------
          str
          """
          return self['rsrc']
  
      @rsrc.setter
      def rsrc(self, val):
          self['rsrc'] = val
  
      # selectedpoints
      # --------------
      @property
      def selectedpoints(self):
          """
          Array containing integer indices of selected points. Has an
          effect only for traces that support selections. Note that an
          empty array means an empty selection where the `unselected` are
          turned on for all points, whereas, any other non-array values
          means no selection all where the `selected` and `unselected`
          styles have no effect.
      
          The 'selectedpoints' property accepts values of any type
  
          Returns
          -------
          Any
          """
          return self['selectedpoints']
  
      @selectedpoints.setter
      def selectedpoints(self, val):
          self['selectedpoints'] = val
  
      # showlegend
      # ----------
      @property
      def showlegend(self):
          """
          Determines whether or not an item corresponding to this trace
          is shown in the legend.
      
          The 'showlegend' property must be specified as a bool
          (either True, or False)
  
          Returns
          -------
          bool
          """
          return self['showlegend']
  
      @showlegend.setter
      def showlegend(self, val):
          self['showlegend'] = val
  
      # stream
      # ------
      @property
      def stream(self):
          """
          The 'stream' property is an instance of Stream
          that may be specified as:
            - An instance of plotly.graph_objs.area.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://plot.ly/settings for more details.
  
          Returns
          -------
          plotly.graph_objs.area.Stream
          """
          return self['stream']
  
      @stream.setter
      def stream(self, val):
          self['stream'] = val
  
      # t
      # -
      @property
      def t(self):
          """
          Area traces are deprecated! Please switch to the "barpolar"
          trace type. Sets the angular coordinates for legacy polar chart
          only.
      
          The 't' property is an array that may be specified as a tuple,
          list, numpy array, or pandas Series
  
          Returns
          -------
          numpy.ndarray
          """
          return self['t']
  
      @t.setter
      def t(self, val):
          self['t'] = val
  
      # tsrc
      # ----
      @property
      def tsrc(self):
          """
          Sets the source reference on plot.ly for  t .
      
          The 'tsrc' property must be specified as a string or
          as a plotly.grid_objs.Column object
  
          Returns
          -------
          str
          """
          return self['tsrc']
  
      @tsrc.setter
      def tsrc(self, val):
          self['tsrc'] = val
  
      # uid
      # ---
      @property
      def uid(self):
          """
          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
  
      # 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
  
      # type
      # ----
      @property
      def type(self):
          return self._props['type']
  
      # property parent name
      # --------------------
      @property
      def _parent_path_str(self):
          return ''
  
      # Self properties description
      # ---------------------------
      @property
      def _prop_descriptions(self):
          return """\
          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 plot.ly for  customdata .
          hoverinfo
              Determines which trace information appear on hover. If
              `none` or `skip` are set, no information is displayed
              upon hovering. But, if `none` is set, click and hover
              events are still fired.
          hoverinfosrc
              Sets the source reference on plot.ly for  hoverinfo .
          hoverlabel
              plotly.graph_objs.area.Hoverlabel instance or dict with
              compatible properties
          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 plot.ly for  ids .
          legendgroup
              Sets the legend group for this trace. Traces part of
              the same legend group hide/show at the same time when
              toggling legend items.
          marker
              plotly.graph_objs.area.Marker instance or dict with
              compatible properties
          name
              Sets the trace name. The trace name appear as the
              legend item and on hover.
          opacity
              Sets the opacity of the trace.
          r
              Area traces are deprecated! Please switch to the
              "barpolar" trace type. Sets the radial coordinates for
              legacy polar chart only.
          rsrc
              Sets the source reference on plot.ly for  r .
          selectedpoints
              Array containing integer indices of selected points.
              Has an effect only for traces that support selections.
              Note that an empty array means an empty selection where
              the `unselected` are turned on for all points, whereas,
              any other non-array values means no selection all where
              the `selected` and `unselected` styles have no effect.
          showlegend
              Determines whether or not an item corresponding to this
              trace is shown in the legend.
          stream
              plotly.graph_objs.area.Stream instance or dict with
              compatible properties
          t
              Area traces are deprecated! Please switch to the
              "barpolar" trace type. Sets the angular coordinates for
              legacy polar chart only.
          tsrc
              Sets the source reference on plot.ly for  t .
          uid
  
          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).
          """
  
      def __init__(
          self,
          arg=None,
          customdata=None,
          customdatasrc=None,
          hoverinfo=None,
          hoverinfosrc=None,
          hoverlabel=None,
          ids=None,
          idssrc=None,
          legendgroup=None,
          marker=None,
          name=None,
          opacity=None,
          r=None,
          rsrc=None,
          selectedpoints=None,
          showlegend=None,
          stream=None,
          t=None,
          tsrc=None,
          uid=None,
          visible=None,
          **kwargs
      ):
          """
          Construct a new Area object
          
          Parameters
          ----------
          arg
              dict of properties compatible with this constructor or
              an instance of plotly.graph_objs.Area
          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 plot.ly for  customdata .
          hoverinfo
              Determines which trace information appear on hover. If
              `none` or `skip` are set, no information is displayed
              upon hovering. But, if `none` is set, click and hover
              events are still fired.
          hoverinfosrc
              Sets the source reference on plot.ly for  hoverinfo .
          hoverlabel
              plotly.graph_objs.area.Hoverlabel instance or dict with
              compatible properties
          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 plot.ly for  ids .
          legendgroup
              Sets the legend group for this trace. Traces part of
              the same legend group hide/show at the same time when
              toggling legend items.
          marker
              plotly.graph_objs.area.Marker instance or dict with
              compatible properties
          name
              Sets the trace name. The trace name appear as the
              legend item and on hover.
          opacity
              Sets the opacity of the trace.
          r
              Area traces are deprecated! Please switch to the
              "barpolar" trace type. Sets the radial coordinates for
              legacy polar chart only.
          rsrc
              Sets the source reference on plot.ly for  r .
          selectedpoints
              Array containing integer indices of selected points.
              Has an effect only for traces that support selections.
              Note that an empty array means an empty selection where
              the `unselected` are turned on for all points, whereas,
              any other non-array values means no selection all where
              the `selected` and `unselected` styles have no effect.
          showlegend
              Determines whether or not an item corresponding to this
              trace is shown in the legend.
          stream
              plotly.graph_objs.area.Stream instance or dict with
              compatible properties
          t
              Area traces are deprecated! Please switch to the
              "barpolar" trace type. Sets the angular coordinates for
              legacy polar chart only.
          tsrc
              Sets the source reference on plot.ly for  t .
          uid
  
          visible
              Determines whether or not this trace is visible. If
              "legendonly", the trace is not drawn, but can appear as
              a legend item (provided that the legend itself is
              visible).
  
          Returns
          -------
          Area
          """
          super(Area, self).__init__('area')
  
          # 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.Area 
  constructor must be a dict or 
  an instance of plotly.graph_objs.Area"""
              )
  
          # Handle skip_invalid
          # -------------------
          self._skip_invalid = kwargs.pop('skip_invalid', False)
  
          # Import validators
          # -----------------
          from plotly.validators import (area as v_area)
  
          # Initialize validators
          # ---------------------
          self._validators['customdata'] = v_area.CustomdataValidator()
          self._validators['customdatasrc'] = v_area.CustomdatasrcValidator()
          self._validators['hoverinfo'] = v_area.HoverinfoValidator()
          self._validators['hoverinfosrc'] = v_area.HoverinfosrcValidator()
          self._validators['hoverlabel'] = v_area.HoverlabelValidator()
          self._validators['ids'] = v_area.IdsValidator()
          self._validators['idssrc'] = v_area.IdssrcValidator()
          self._validators['legendgroup'] = v_area.LegendgroupValidator()
          self._validators['marker'] = v_area.MarkerValidator()
          self._validators['name'] = v_area.NameValidator()
          self._validators['opacity'] = v_area.OpacityValidator()
          self._validators['r'] = v_area.RValidator()
          self._validators['rsrc'] = v_area.RsrcValidator()
          self._validators['selectedpoints'] = v_area.SelectedpointsValidator()
          self._validators['showlegend'] = v_area.ShowlegendValidator()
          self._validators['stream'] = v_area.StreamValidator()
          self._validators['t'] = v_area.TValidator()
          self._validators['tsrc'] = v_area.TsrcValidator()
          self._validators['uid'] = v_area.UidValidator()
          self._validators['visible'] = v_area.VisibleValidator()
  
          # Populate data dict with properties
          # ----------------------------------
          _v = arg.pop('customdata', None)
          self['customdata'] = customdata if customdata is not None else _v
          _v = arg.pop('customdatasrc', None)
          self['customdatasrc'
              ] = customdatasrc if customdatasrc is not None else _v
          _v = arg.pop('hoverinfo', None)
          self['hoverinfo'] = hoverinfo if hoverinfo is not None else _v
          _v = arg.pop('hoverinfosrc', None)
          self['hoverinfosrc'] = hoverinfosrc if hoverinfosrc is not None else _v
          _v = arg.pop('hoverlabel', None)
          self['hoverlabel'] = hoverlabel if hoverlabel is not None else _v
          _v = arg.pop('ids', None)
          self['ids'] = ids if ids is not None else _v
          _v = arg.pop('idssrc', None)
          self['idssrc'] = idssrc if idssrc is not None else _v
          _v = arg.pop('legendgroup', None)
          self['legendgroup'] = legendgroup if legendgroup is not None else _v
          _v = arg.pop('marker', None)
          self['marker'] = marker if marker is not None else _v
          _v = arg.pop('name', None)
          self['name'] = name if name is not None else _v
          _v = arg.pop('opacity', None)
          self['opacity'] = opacity if opacity is not None else _v
          _v = arg.pop('r', None)
          self['r'] = r if r is not None else _v
          _v = arg.pop('rsrc', None)
          self['rsrc'] = rsrc if rsrc is not None else _v
          _v = arg.pop('selectedpoints', None)
          self['selectedpoints'
              ] = selectedpoints if selectedpoints is not None else _v
          _v = arg.pop('showlegend', None)
          self['showlegend'] = showlegend if showlegend is not None else _v
          _v = arg.pop('stream', None)
          self['stream'] = stream if stream is not None else _v
          _v = arg.pop('t', None)
          self['t'] = t if t is not None else _v
          _v = arg.pop('tsrc', None)
          self['tsrc'] = tsrc if tsrc is not None else _v
          _v = arg.pop('uid', None)
          self['uid'] = uid if uid is not None else _v
          _v = arg.pop('visible', None)
          self['visible'] = visible if visible is not None else _v
  
          # Read-only literals
          # ------------------
          from _plotly_utils.basevalidators import LiteralValidator
          self._props['type'] = 'area'
          self._validators['type'] = LiteralValidator(
              plotly_name='type', parent_name='area', val='area'
          )
          arg.pop('type', None)
  
          # Process unknown kwargs
          # ----------------------
          self._process_kwargs(**dict(arg, **kwargs))
  
          # Reset skip_invalid
          # ------------------
          self._skip_invalid = False
  