class_docstr: A series of possibly disconnected, possibly closed, line and curve
  segments.
  
  The underlying storage is made up of two parallel numpy arrays:
  
  - *vertices*: an (N, 2) float array of vertices
  - *codes*: an N-length `numpy.uint8` array of path codes, or None
  
  These two arrays always have the same length in the first
  dimension.  For example, to represent a cubic curve, you must
  provide three vertices and three `CURVE4` codes.
  
  The code types are:
  
  - `STOP`   :  1 vertex (ignored)
      A marker for the end of the entire path (currently not required and
      ignored)
  
  - `MOVETO` :  1 vertex
      Pick up the pen and move to the given vertex.
  
  - `LINETO` :  1 vertex
      Draw a line from the current position to the given vertex.
  
  - `CURVE3` :  1 control point, 1 endpoint
      Draw a quadratic Bézier curve from the current position, with the given
      control point, to the given end point.
  
  - `CURVE4` :  2 control points, 1 endpoint
      Draw a cubic Bézier curve from the current position, with the given
      control points, to the given end point.
  
  - `CLOSEPOLY` : 1 vertex (ignored)
      Draw a line segment to the start point of the current polyline.
  
  If *codes* is None, it is interpreted as a `MOVETO` followed by a series
  of `LINETO`.
  
  Users of Path objects should not access the vertices and codes arrays
  directly.  Instead, they should use `iter_segments` or `cleaned` to get the
  vertex/code pairs.  This helps, in particular, to consistently handle the
  case of *codes* being None.
  
  Some behavior of Path objects can be controlled by rcParams. See the
  rcParams whose keys start with 'path.'.
  
  .. note::
  
      The vertices and codes arrays should be treated as
      immutable -- there are a number of optimizations and assumptions
      made up front in the constructor that will not change when the
      data changes.
docstr: Make a compound `Path` object to draw a number of polygons with equal
  numbers of sides.
  
  .. plot:: gallery/misc/histogram_path.py
  
  Parameters
  ----------
  XY : (numpolys, numsides, 2) array
docstr_tok: ["Make","a","compound","`","Path","`","object","to","draw","a","number","of","polygons","with","equal","numbers","of","sides",".","..","plot",":",":","gallery\/misc\/histogram_path.py","Parameters","--","--","--","--","--","XY",":","(","numpolys",",","numsides",",","2",")","array"]
code: def make_compound_path_from_polys(cls, XY):
      """
      Make a compound `Path` object to draw a number of polygons with equal
      numbers of sides.
  
      .. plot:: gallery/misc/histogram_path.py
  
      Parameters
      ----------
      XY : (numpolys, numsides, 2) array
      """
      # for each poly: 1 for the MOVETO, (numsides-1) for the LINETO, 1 for
      # the CLOSEPOLY; the vert for the closepoly is ignored but we still
      # need it to keep the codes aligned with the vertices
      numpolys, numsides, two = XY.shape
      if two != 2:
          raise ValueError("The third dimension of 'XY' must be 2")
      stride = numsides + 1
      nverts = numpolys * stride
      verts = np.zeros((nverts, 2))
      codes = np.full(nverts, cls.LINETO, dtype=cls.code_type)
      codes[0::stride] = cls.MOVETO
      codes[numsides::stride] = cls.CLOSEPOLY
      for i in range(numsides):
          verts[i::stride] = XY[:, i]
      return cls(verts, codes)
  
imports: import copy
  from functools import lru_cache
  from weakref import WeakValueDictionary
  import numpy
  import matplotlib
  from .None import _api, _path
  from .cbook import _to_unmasked_float_array, simple_linear_interpolation
  from .bezier import BezierSegment
label_desc: Use image node_id 16 for calling the Path obj's underlying member method code with example usage: obj.make_compound_path_from_polys(cls, XY) and returns: cls