docs: def radar_factory(num_vars, frame='circle'):
      """Create a radar chart with `num_vars` axes.
  
      This function creates a RadarAxes projection and registers it.
  
      Parameters
      ----------
      num_vars : int
          Number of variables for radar chart.
      frame : {'circle' | 'polygon'}
          Shape of frame surrounding axes.
  
      """
      # calculate evenly-spaced axis angles
      theta = np.linspace(0, 2*np.pi, num_vars, endpoint=False)
      # rotate theta such that the first axis is at the top
      theta += np.pi/2
  
      def draw_poly_patch(self):
          verts = unit_poly_verts(theta)
          return plt.Polygon(verts, closed=True, edgecolor='k')
  
      def draw_circle_patch(self):
          # unit circle centered on (0.5, 0.5)
          return plt.Circle((0.5, 0.5), 0.5)
  
      patch_dict = {'polygon': draw_poly_patch, 'circle': draw_circle_patch}
      if frame not in patch_dict:
          raise ValueError('unknown value for `frame`: %s' % frame)
  
      class RadarAxes(PolarAxes):
  
          name = 'radar'
          # use 1 line segment to connect specified points
          RESOLUTION = 1
          # define draw_frame method
          draw_patch = patch_dict[frame]
  
          def fill(self, *args, **kwargs):
              """Override fill so that line is closed by default"""
              closed = kwargs.pop('closed', True)
              return super(RadarAxes, self).fill(closed=closed, *args, **kwargs)
  
          def plot(self, *args, **kwargs):
              """Override plot so that line is closed by default"""
              lines = super(RadarAxes, self).plot(*args, **kwargs)
              for line in lines:
                  self._close_line(line)
  
          def _close_line(self, line):
              x, y = line.get_data()
              # FIXME: markers at x[0], y[0] get doubled-up
              if x[0] != x[-1]:
                  x = np.concatenate((x, [x[0]]))
                  y = np.concatenate((y, [y[0]]))
                  line.set_data(x, y)
  
          def set_varlabels(self, labels):
              self.set_thetagrids(np.degrees(theta), labels)
  
          def _gen_axes_patch(self):
              return self.draw_patch()
  
          def _gen_axes_spines(self):
              if frame == 'circle':
                  return PolarAxes._gen_axes_spines(self)
              # The following is a hack to get the spines (i.e. the axes frame)
              # to draw correctly for a polygon frame.
  
              # spine_type must be 'left', 'right', 'top', 'bottom', or `circle`.
              spine_type = 'circle'
              verts = unit_poly_verts(theta)
              # close off polygon by repeating first vertex
              verts.append(verts[0])
              path = Path(verts)
  
              spine = Spine(self, spine_type, path)
              spine.set_transform(self.transAxes)
              return {'polar': spine}
  
      register_projection(RadarAxes)
      return theta