code: def plot(self, ax, kws):
      # --- Determine the visual attributes of the plot
  
      data = self.comp_data.dropna()
      if data.empty:
          return
  
      kws = normalize_kwargs(kws, mpl.collections.PathCollection)
  
      # Define the vectors of x and y positions
      empty = np.full(len(data), np.nan)
      x = data.get("x", empty)
      y = data.get("y", empty)
  
      # Apply inverse scaling to the coordinate variables
      _, inv_x = _get_transform_functions(ax, "x")
      _, inv_y = _get_transform_functions(ax, "y")
      x, y = inv_x(x), inv_y(y)
  
      if "style" in self.variables:
          # Use a representative marker so scatter sets the edgecolor
          # properly for line art markers. We currently enforce either
          # all or none line art so this works.
          example_level = self._style_map.levels[0]
          example_marker = self._style_map(example_level, "marker")
          kws.setdefault("marker", example_marker)
  
      # Conditionally set the marker edgecolor based on whether the marker is "filled"
      # See https://github.com/matplotlib/matplotlib/issues/17849 for context
      m = kws.get("marker", mpl.rcParams.get("marker", "o"))
      if not isinstance(m, mpl.markers.MarkerStyle):
          # TODO in more recent matplotlib (which?) can pass a MarkerStyle here
          m = mpl.markers.MarkerStyle(m)
      if m.is_filled():
          kws.setdefault("edgecolor", "w")
  
      # Draw the scatter plot
      points = ax.scatter(x=x, y=y, **kws)
  
      # Apply the mapping from semantic variables to artist attributes
  
      if "hue" in self.variables:
          points.set_facecolors(self._hue_map(data["hue"]))
  
      if "size" in self.variables:
          points.set_sizes(self._size_map(data["size"]))
  
      if "style" in self.variables:
          p = [self._style_map(val, "path") for val in data["style"]]
          points.set_paths(p)
  
      # Apply dependent default attributes
  
      if "linewidth" not in kws:
          sizes = points.get_sizes()
          linewidth = 0.08 * np.sqrt(np.percentile(sizes, 10))
          points.set_linewidths(linewidth)
          kws["linewidth"] = linewidth
  
      # Finalize the axes details
      self._add_axis_labels(ax)
      if self.legend:
          attrs = {"hue": "color", "size": "s", "style": None}
          self.add_legend_data(ax, _scatter_legend_artist, kws, attrs)
          handles, _ = ax.get_legend_handles_labels()
          if handles:
              legend = ax.legend(title=self.legend_title)
              adjust_legend_subtitles(legend)
  
imports: from functools import partial
  import warnings
  import numpy
  import pandas
  import matplotlib
  import matplotlib.pyplot
  from matplotlib.cbook import normalize_kwargs
  from ._base import VectorPlotter
  from .utils import adjust_legend_subtitles, _default_color, _deprecate_ci, _get_transform_functions, _scatter_legend_artist
  from ._statistics import EstimateAggregator, WeightedAggregator
  from .axisgrid import FacetGrid, _facet_docs
  from ._docstrings import DocstringComponents, _core_docs
label_desc: Use image node_id 2 for calling the _ScatterPlotter obj's underlying member method code with example usage: obj.plot(ax, kws) without return types