docs: def draw_classes(self, X, y, **kwargs):
          """
          Draw the instances colored by the target y such that each line is a
          single class. This is the "fast" mode of drawing, since the number of
          lines drawn equals the number of classes, rather than the number of
          instances. However, this drawing method sacrifices inter-class density
          of points using the alpha parameter.
  
          Parameters
          ----------
          X : ndarray of shape n x m
              A matrix of n instances with m features
  
          y : ndarray of length n
              An array or series of target or class values
          """
          # Get alpha from param or default
          alpha = self.alpha or 0.5
  
          # Prepare to flatten data within each class:
          #   introduce separation between individual data points using None in
          #   x-values and arbitrary value (one) in y-values
          X_separated = np.hstack([X, np.ones((X.shape[0], 1))])
          increments_separated = self._increments.tolist()
          increments_separated.append(None)
  
          # Get the classes that exist in the dataset, y
          y_values = np.unique(y)
  
          # Plot each class as a single line plot
          for yi in y_values:
              if isinstance(yi, str):
                  label = yi
              else:
                  # TODO: what happens if yi is not in classes?!
                  label = self.classes_[yi]
  
              X_in_class = X_separated[y == yi, :]
              increments_in_class = increments_separated * len(X_in_class)
              if len(X_in_class) > 0:
                  self.ax.plot(
                      increments_in_class, X_in_class.flatten(), linewidth=1,
                      color=self._colors[label], alpha=alpha, **kwargs
                  )
  
          return self.ax