text: from plotly.basedatatypes import BaseTraceHierarchyType as _BaseTraceHierarchyType
  import copy as _copy
  
  
  class Font(_BaseTraceHierarchyType):
  
      # class properties
      # --------------------
      _parent_path_str = "bar.marker.colorbar.title"
      _path_str = "bar.marker.colorbar.title.font"
      _valid_props = {"color", "family", "size"}
  
      # 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
  
      # 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 this color bar's title font. Note that the title's font
          used to be set by the now deprecated `titlefont` attribute.
  
          Parameters
          ----------
          arg
              dict of properties compatible with this constructor or
              an instance of :class:`plotly.graph_objs.bar.marker.col
              orbar.title.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")
  
          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.bar.marker.colorbar.title.Font 
  constructor must be a dict or 
  an instance of :class:`plotly.graph_objs.bar.marker.colorbar.title.Font`"""
              )
  
          # 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("color", None)
          _v = color if color is not None else _v
          if _v is not None:
              self["color"] = _v
          _v = arg.pop("family", None)
          _v = family if family is not None else _v
          if _v is not None:
              self["family"] = _v
          _v = arg.pop("size", None)
          _v = size if size is not None else _v
          if _v is not None:
              self["size"] = _v
  
          # Process unknown kwargs
          # ----------------------
          self._process_kwargs(**dict(arg, **kwargs))
  
          # Reset skip_invalid
          # ------------------
          self._skip_invalid = False
  