text: from plotly.basedatatypes import BaseLayoutHierarchyType as _BaseLayoutHierarchyType
  import copy as _copy
  
  
  class Pad(_BaseLayoutHierarchyType):
  
      # b
      # -
      @property
      def b(self):
          """
          The amount of padding (in px) along the bottom of the
          component.
      
          The 'b' property is a number and may be specified as:
            - An int or float
  
          Returns
          -------
          int|float
          """
          return self["b"]
  
      @b.setter
      def b(self, val):
          self["b"] = val
  
      # l
      # -
      @property
      def l(self):
          """
          The amount of padding (in px) on the left side of the
          component.
      
          The 'l' property is a number and may be specified as:
            - An int or float
  
          Returns
          -------
          int|float
          """
          return self["l"]
  
      @l.setter
      def l(self, val):
          self["l"] = val
  
      # r
      # -
      @property
      def r(self):
          """
          The amount of padding (in px) on the right side of the
          component.
      
          The 'r' property is a number and may be specified as:
            - An int or float
  
          Returns
          -------
          int|float
          """
          return self["r"]
  
      @r.setter
      def r(self, val):
          self["r"] = val
  
      # t
      # -
      @property
      def t(self):
          """
          The amount of padding (in px) along the top of the component.
      
          The 't' property is a number and may be specified as:
            - An int or float
  
          Returns
          -------
          int|float
          """
          return self["t"]
  
      @t.setter
      def t(self, val):
          self["t"] = val
  
      # property parent name
      # --------------------
      @property
      def _parent_path_str(self):
          return "layout.updatemenu"
  
      # Self properties description
      # ---------------------------
      @property
      def _prop_descriptions(self):
          return """\
          b
              The amount of padding (in px) along the bottom of the
              component.
          l
              The amount of padding (in px) on the left side of the
              component.
          r
              The amount of padding (in px) on the right side of the
              component.
          t
              The amount of padding (in px) along the top of the
              component.
          """
  
      def __init__(self, arg=None, b=None, l=None, r=None, t=None, **kwargs):
          """
          Construct a new Pad object
          
          Sets the padding around the buttons or dropdown menu.
  
          Parameters
          ----------
          arg
              dict of properties compatible with this constructor or
              an instance of
              :class:`plotly.graph_objs.layout.updatemenu.Pad`
          b
              The amount of padding (in px) along the bottom of the
              component.
          l
              The amount of padding (in px) on the left side of the
              component.
          r
              The amount of padding (in px) on the right side of the
              component.
          t
              The amount of padding (in px) along the top of the
              component.
  
          Returns
          -------
          Pad
          """
          super(Pad, self).__init__("pad")
  
          # 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.layout.updatemenu.Pad 
  constructor must be a dict or 
  an instance of :class:`plotly.graph_objs.layout.updatemenu.Pad`"""
              )
  
          # Handle skip_invalid
          # -------------------
          self._skip_invalid = kwargs.pop("skip_invalid", False)
  
          # Import validators
          # -----------------
          from plotly.validators.layout.updatemenu import pad as v_pad
  
          # Initialize validators
          # ---------------------
          self._validators["b"] = v_pad.BValidator()
          self._validators["l"] = v_pad.LValidator()
          self._validators["r"] = v_pad.RValidator()
          self._validators["t"] = v_pad.TValidator()
  
          # Populate data dict with properties
          # ----------------------------------
          _v = arg.pop("b", None)
          self["b"] = b if b is not None else _v
          _v = arg.pop("l", None)
          self["l"] = l if l is not None else _v
          _v = arg.pop("r", None)
          self["r"] = r if r is not None else _v
          _v = arg.pop("t", None)
          self["t"] = t if t is not None else _v
  
          # Process unknown kwargs
          # ----------------------
          self._process_kwargs(**dict(arg, **kwargs))
  
          # Reset skip_invalid
          # ------------------
          self._skip_invalid = False
  
  
  from plotly.basedatatypes import BaseLayoutHierarchyType as _BaseLayoutHierarchyType
  import copy as _copy
  
  
  class Font(_BaseLayoutHierarchyType):
  
      # color
      # -----
      @property
      def color(self):
          """
          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
  
      # family
      # ------
      @property
      def family(self):
          """
          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".
      
          The 'family' property is a string and must be specified as:
            - A non-empty string
  
          Returns
          -------
          str
          """
          return self["family"]
  
      @family.setter
      def family(self, val):
          self["family"] = val
  
      # size
      # ----
      @property
      def size(self):
          """
          The 'size' property is a number and may be specified as:
            - An int or float in the interval [1, inf]
  
          Returns
          -------
          int|float
          """
          return self["size"]
  
      @size.setter
      def size(self, val):
          self["size"] = val
  
      # property parent name
      # --------------------
      @property
      def _parent_path_str(self):
          return "layout.updatemenu"
  
      # Self properties description
      # ---------------------------
      @property
      def _prop_descriptions(self):
          return """\
          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
  
          """
  
      def __init__(self, arg=None, color=None, family=None, size=None, **kwargs):
          """
          Construct a new Font object
          
          Sets the font of the update menu button text.
  
          Parameters
          ----------
          arg
              dict of properties compatible with this constructor or
              an instance of
              :class:`plotly.graph_objs.layout.updatemenu.Font`
          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
          -------
          Font
          """
          super(Font, self).__init__("font")
  
          # 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.layout.updatemenu.Font 
  constructor must be a dict or 
  an instance of :class:`plotly.graph_objs.layout.updatemenu.Font`"""
              )
  
          # Handle skip_invalid
          # -------------------
          self._skip_invalid = kwargs.pop("skip_invalid", False)
  
          # Import validators
          # -----------------
          from plotly.validators.layout.updatemenu import font as v_font
  
          # Initialize validators
          # ---------------------
          self._validators["color"] = v_font.ColorValidator()
          self._validators["family"] = v_font.FamilyValidator()
          self._validators["size"] = v_font.SizeValidator()
  
          # Populate data dict with properties
          # ----------------------------------
          _v = arg.pop("color", None)
          self["color"] = color if color is not None else _v
          _v = arg.pop("family", None)
          self["family"] = family if family is not None else _v
          _v = arg.pop("size", None)
          self["size"] = size if size is not None else _v
  
          # Process unknown kwargs
          # ----------------------
          self._process_kwargs(**dict(arg, **kwargs))
  
          # Reset skip_invalid
          # ------------------
          self._skip_invalid = False
  
  
  from plotly.basedatatypes import BaseLayoutHierarchyType as _BaseLayoutHierarchyType
  import copy as _copy
  
  
  class Button(_BaseLayoutHierarchyType):
  
      # args
      # ----
      @property
      def args(self):
          """
          Sets the arguments values to be passed to the Plotly method set
          in `method` on click.
      
          The 'args' property is an info array that may be specified as:
      
          * a list or tuple of up to 3 elements where:
      (0) The 'args[0]' property accepts values of any type
      (1) The 'args[1]' property accepts values of any type
      (2) The 'args[2]' property accepts values of any type
  
          Returns
          -------
          list
          """
          return self["args"]
  
      @args.setter
      def args(self, val):
          self["args"] = val
  
      # args2
      # -----
      @property
      def args2(self):
          """
          Sets a 2nd set of `args`, these arguments values are passed to
          the Plotly method set in `method` when clicking this button
          while in the active state. Use this to create toggle buttons.
      
          The 'args2' property is an info array that may be specified as:
      
          * a list or tuple of up to 3 elements where:
      (0) The 'args2[0]' property accepts values of any type
      (1) The 'args2[1]' property accepts values of any type
      (2) The 'args2[2]' property accepts values of any type
  
          Returns
          -------
          list
          """
          return self["args2"]
  
      @args2.setter
      def args2(self, val):
          self["args2"] = val
  
      # execute
      # -------
      @property
      def execute(self):
          """
          When true, the API method is executed. When false, all other
          behaviors are the same and command execution is skipped. This
          may be useful when hooking into, for example, the
          `plotly_buttonclicked` method and executing the API command
          manually without losing the benefit of the updatemenu
          automatically binding to the state of the plot through the
          specification of `method` and `args`.
      
          The 'execute' property must be specified as a bool
          (either True, or False)
  
          Returns
          -------
          bool
          """
          return self["execute"]
  
      @execute.setter
      def execute(self, val):
          self["execute"] = val
  
      # label
      # -----
      @property
      def label(self):
          """
          Sets the text label to appear on the button.
      
          The 'label' property is a string and must be specified as:
            - A string
            - A number that will be converted to a string
  
          Returns
          -------
          str
          """
          return self["label"]
  
      @label.setter
      def label(self, val):
          self["label"] = val
  
      # method
      # ------
      @property
      def method(self):
          """
          Sets the Plotly method to be called on click. If the `skip`
          method is used, the API updatemenu will function as normal but
          will perform no API calls and will not bind automatically to
          state updates. This may be used to create a component interface
          and attach to updatemenu events manually via JavaScript.
      
          The 'method' property is an enumeration that may be specified as:
            - One of the following enumeration values:
                  ['restyle', 'relayout', 'animate', 'update', 'skip']
  
          Returns
          -------
          Any
          """
          return self["method"]
  
      @method.setter
      def method(self, val):
          self["method"] = val
  
      # name
      # ----
      @property
      def name(self):
          """
          When used in a template, named items are created in the output
          figure in addition to any items the figure already has in this
          array. You can modify these items in the output figure by
          making your own item with `templateitemname` matching this
          `name` alongside your modifications (including `visible: false`
          or `enabled: false` to hide it). Has no effect outside of a
          template.
      
          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
  
      # templateitemname
      # ----------------
      @property
      def templateitemname(self):
          """
          Used to refer to a named item in this array in the template.
          Named items from the template will be created even without a
          matching item in the input figure, but you can modify one by
          making an item with `templateitemname` matching its `name`,
          alongside your modifications (including `visible: false` or
          `enabled: false` to hide it). If there is no template or no
          matching item, this item will be hidden unless you explicitly
          show it with `visible: true`.
      
          The 'templateitemname' property is a string and must be specified as:
            - A string
            - A number that will be converted to a string
  
          Returns
          -------
          str
          """
          return self["templateitemname"]
  
      @templateitemname.setter
      def templateitemname(self, val):
          self["templateitemname"] = val
  
      # visible
      # -------
      @property
      def visible(self):
          """
          Determines whether or not this button is visible.
      
          The 'visible' property must be specified as a bool
          (either True, or False)
  
          Returns
          -------
          bool
          """
          return self["visible"]
  
      @visible.setter
      def visible(self, val):
          self["visible"] = val
  
      # property parent name
      # --------------------
      @property
      def _parent_path_str(self):
          return "layout.updatemenu"
  
      # Self properties description
      # ---------------------------
      @property
      def _prop_descriptions(self):
          return """\
          args
              Sets the arguments values to be passed to the Plotly
              method set in `method` on click.
          args2
              Sets a 2nd set of `args`, these arguments values are
              passed to the Plotly method set in `method` when
              clicking this button while in the active state. Use
              this to create toggle buttons.
          execute
              When true, the API method is executed. When false, all
              other behaviors are the same and command execution is
              skipped. This may be useful when hooking into, for
              example, the `plotly_buttonclicked` method and
              executing the API command manually without losing the
              benefit of the updatemenu automatically binding to the
              state of the plot through the specification of `method`
              and `args`.
          label
              Sets the text label to appear on the button.
          method
              Sets the Plotly method to be called on click. If the
              `skip` method is used, the API updatemenu will function
              as normal but will perform no API calls and will not
              bind automatically to state updates. This may be used
              to create a component interface and attach to
              updatemenu events manually via JavaScript.
          name
              When used in a template, named items are created in the
              output figure in addition to any items the figure
              already has in this array. You can modify these items
              in the output figure by making your own item with
              `templateitemname` matching this `name` alongside your
              modifications (including `visible: false` or `enabled:
              false` to hide it). Has no effect outside of a
              template.
          templateitemname
              Used to refer to a named item in this array in the
              template. Named items from the template will be created
              even without a matching item in the input figure, but
              you can modify one by making an item with
              `templateitemname` matching its `name`, alongside your
              modifications (including `visible: false` or `enabled:
              false` to hide it). If there is no template or no
              matching item, this item will be hidden unless you
              explicitly show it with `visible: true`.
          visible
              Determines whether or not this button is visible.
          """
  
      def __init__(
          self,
          arg=None,
          args=None,
          args2=None,
          execute=None,
          label=None,
          method=None,
          name=None,
          templateitemname=None,
          visible=None,
          **kwargs
      ):
          """
          Construct a new Button object
          
          Parameters
          ----------
          arg
              dict of properties compatible with this constructor or
              an instance of
              :class:`plotly.graph_objs.layout.updatemenu.Button`
          args
              Sets the arguments values to be passed to the Plotly
              method set in `method` on click.
          args2
              Sets a 2nd set of `args`, these arguments values are
              passed to the Plotly method set in `method` when
              clicking this button while in the active state. Use
              this to create toggle buttons.
          execute
              When true, the API method is executed. When false, all
              other behaviors are the same and command execution is
              skipped. This may be useful when hooking into, for
              example, the `plotly_buttonclicked` method and
              executing the API command manually without losing the
              benefit of the updatemenu automatically binding to the
              state of the plot through the specification of `method`
              and `args`.
          label
              Sets the text label to appear on the button.
          method
              Sets the Plotly method to be called on click. If the
              `skip` method is used, the API updatemenu will function
              as normal but will perform no API calls and will not
              bind automatically to state updates. This may be used
              to create a component interface and attach to
              updatemenu events manually via JavaScript.
          name
              When used in a template, named items are created in the
              output figure in addition to any items the figure
              already has in this array. You can modify these items
              in the output figure by making your own item with
              `templateitemname` matching this `name` alongside your
              modifications (including `visible: false` or `enabled:
              false` to hide it). Has no effect outside of a
              template.
          templateitemname
              Used to refer to a named item in this array in the
              template. Named items from the template will be created
              even without a matching item in the input figure, but
              you can modify one by making an item with
              `templateitemname` matching its `name`, alongside your
              modifications (including `visible: false` or `enabled:
              false` to hide it). If there is no template or no
              matching item, this item will be hidden unless you
              explicitly show it with `visible: true`.
          visible
              Determines whether or not this button is visible.
  
          Returns
          -------
          Button
          """
          super(Button, self).__init__("buttons")
  
          # 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.layout.updatemenu.Button 
  constructor must be a dict or 
  an instance of :class:`plotly.graph_objs.layout.updatemenu.Button`"""
              )
  
          # Handle skip_invalid
          # -------------------
          self._skip_invalid = kwargs.pop("skip_invalid", False)
  
          # Import validators
          # -----------------
          from plotly.validators.layout.updatemenu import button as v_button
  
          # Initialize validators
          # ---------------------
          self._validators["args"] = v_button.ArgsValidator()
          self._validators["args2"] = v_button.Args2Validator()
          self._validators["execute"] = v_button.ExecuteValidator()
          self._validators["label"] = v_button.LabelValidator()
          self._validators["method"] = v_button.MethodValidator()
          self._validators["name"] = v_button.NameValidator()
          self._validators["templateitemname"] = v_button.TemplateitemnameValidator()
          self._validators["visible"] = v_button.VisibleValidator()
  
          # Populate data dict with properties
          # ----------------------------------
          _v = arg.pop("args", None)
          self["args"] = args if args is not None else _v
          _v = arg.pop("args2", None)
          self["args2"] = args2 if args2 is not None else _v
          _v = arg.pop("execute", None)
          self["execute"] = execute if execute is not None else _v
          _v = arg.pop("label", None)
          self["label"] = label if label is not None else _v
          _v = arg.pop("method", None)
          self["method"] = method if method is not None else _v
          _v = arg.pop("name", None)
          self["name"] = name if name is not None else _v
          _v = arg.pop("templateitemname", None)
          self["templateitemname"] = (
              templateitemname if templateitemname is not None else _v
          )
          _v = arg.pop("visible", None)
          self["visible"] = visible if visible is not None else _v
  
          # Process unknown kwargs
          # ----------------------
          self._process_kwargs(**dict(arg, **kwargs))
  
          # Reset skip_invalid
          # ------------------
          self._skip_invalid = False
  
  
  __all__ = ["Button", "Button", "Font", "Pad"]
  