code: def symbol_layer(
      locations,
      hover_text="",
      fill_color=None,
      fill_opacity=1.0,
      stroke_color=None,
      stroke_opacity=1.0,
      scale=3,
      info_box_content=None,
      display_info_box=None,
  ):
      """
      Symbol layer
  
      Add this layer to a :class:`gmaps.Figure` instance to draw
      symbols on the map. A symbol will be drawn on the map for
      each point in the ``locations`` argument.
  
      :Examples:
  
      >>> fig = gmaps.figure()
      >>> locations = [
              (-34.0, -59.166672),
              (-32.23333, -64.433327),
              (40.166672, 44.133331),
              (51.216671, 5.0833302),
              (51.333328, 4.25)
          ]
      >>> symbols = gmaps.symbol_layer(
              locations, fill_color='red', stroke_color='red')
      >>> fig.add_layer(symbols)
  
      You can set a list of information boxes, which will be displayed when the
      user clicks on a marker.
  
      >>> list_of_infoboxes = [
              'Simple string info box',
              '<a href='http://example.com'>HTML content</a>'
          ]
      >>> symbol_layer = gmaps.symbol_layer(
                  locations, info_box_content=list_of_infoboxes)
  
      You can also set text that appears when someone's mouse hovers
      over a point:
  
      >>> names = ['Atucha', 'Embalse', 'Armenia', 'BR', 'Doel']
      >>> symbol_layer = gmaps.symbol_layer(locations, hover_text=names)
  
      Apart from ``locations``, which must be an iterable of
      (latitude, longitude) pairs, the arguments can be given as
      either a list of the same length as ``locations``, or a
      single value. If given as a single value, this value will
      be broadcast to every marker. Thus, these two calls are equivalent:
  
      >>> symbol_layer = gmaps.symbol_layer(
              locations, fill_color=['red']*len(locations))
      >>> symbol_layer = gmaps.symbol_layer(
              locations, fill_color='red')
  
      The former is useful for passing different colours to
      different symbols.
  
      >>> colors = ['red', 'green', 'blue', 'black', 'white']
      >>> symbol_layer = gmaps.symbol_layer(
              locations, fill_color=colors, stro
  
      To change the number of symbols after the layer has been
      constructed, mutate the ``markers`` attribute. You will need to
      pass a list of :class:`gmaps.Symbol` instances explicitly.
  
      >>> symbol_layer.markers = [
              gmaps.Symbol(location=(1.0, 2.0)),
              gmaps.Symbol(location=(3.0, 4.0))
          ]
  
      To change the style of symbols on an existing layer, mutate the
      symbol directly.
  
      >>> symbol_layer.markers[0].scale = 5
  
      :param locations:
          List of (latitude, longitude) pairs
          denoting a single point. Latitudes are expressed as
          a float between -90 (corresponding to 90 degrees south)
          and +90 (corresponding to 90 degrees north). Longitudes
          are expressed as a float between -180 (corresponding to 180
          degrees west) and +180 (corresponding to 180 degrees east).
      :type locations: list of tuples
  
      :param hover_text:
          Text to be displayed when a user's mouse is hovering over
          a marker. This can be either a single string, in which case
          it will be applied to every marker, or a list of strings,
          in which case it must be of the same length as `locations`.
          If this is set to an empty string, nothing will appear when
          the user's mouse hovers over a symbol.
      :type hover_text: string or list of strings, optional
  
      :param fill_color:
          The fill color of the symbol. This can be specified as a
          single color, in which case the same color will apply to every symbol,
          or as a list of colors, in which case it must be the
          same length as ``locations``.
          Colors can be specified as a simple string, e.g. 'blue',
          as an RGB tuple, e.g. (100, 0, 0), or as an RGBA tuple, e.g.
          (100, 0, 0, 0.5).
      :type fill_color: single color or list of colors, optional
  
      :param fill_opacity:
          The opacity of the fill color. The opacity should be a float
          between 0.0 (transparent) and 1.0 (opaque), or a list of floats.
          1.0 by default.
      :type fill_opacity: float or list of floats, optional
  
      :param stroke_color:
          The stroke color of the symbol. This can be specified as a
          single color, in which case the same color will apply to every symbol,
          or as a list of colors, in which case it must be the
          same length as ``locations``.
          Colors can be specified as a simple string, e.g. 'blue',
          as an RGB tuple, e.g. (100, 0, 0), or as an RGBA tuple, e.g.
          (100, 0, 0, 0.5).
      :type stroke_color: single color or list of colors, optional
  
      :param stroke_opacity:
          The opacity of the stroke color. The opacity should be a float
          between 0.0 (transparent) and 1.0 (opaque), or a list of floats.
          1.0 by default.
      :type stroke_opacity: float or list of floats, optional
  
      :param scale:
          How large the marker is. This can either be a single integer,
          in which case the same scale will be applied to every marker,
          or it must be an iterable of the same length as ``locations``.
          The scale must be greater than 1. This defaults to 3.
      :type scale: integer or list of integers, optional
  
      :param info_box_content:
          Content to be displayed when user clicks on a marker. This should
          either be a single string, in which case the same content will apply to
          every marker, or a list of strings of the same length of the
          `locations` list.
      :type info_box_content: string or list of strings, optional
  
      :param display_info_box:
          Whether to display an info box when the user clicks on a symbol.
          This should either be a single boolean value, in which case it
          will be applied to every symbol, or a list of boolean values of the
          same length as the `locations` list.
          The default value is True for any symbols for which `info_box_content`
          is set, and False otherwise.
      :type display_info_box: boolean or list of booleans, optional
  
      :returns:
          A :class:`gmaps.Markers` instance.
      """
      options = _symbol_layer_options(
          locations,
          hover_text,
          fill_color,
          fill_opacity,
          stroke_color,
          stroke_opacity,
          scale,
          info_box_content,
          display_info_box,
      )
      symbols = [Symbol(**option) for option in options]
      return Markers(markers=symbols)
  
imports: import ipywidgets
  from traitlets import Unicode, Int, List, observe, HasTraits, Bool
  import gmaps.geotraitlets
  import gmaps.bounds
  from .maps import DEFAULT_CENTER, GMapsWidgetMixin
  from .locations import locations_to_list
  from .options import merge_option_dicts, is_atomic, is_color_atomic
  from ._docutils import doc_subst
label_desc: Use image node_id 5 for calling a global function with example usage: symbol_layer(locations, hover_text, fill_color, fill_opacity, stroke_color, stroke_opacity, scale, info_box_content, display_info_box) and returns: Markers