def METHOD_NAME(*args, **kwargs):
    # for import performance reasons we don't import it globally
    import matplotlib.artist as artist
    import matplotlib.transforms as transforms
    import matplotlib.patches as patches
    from matplotlib.path import Path
    class DispersionEllipse(patches.Patch):
        """
        This ellipse has it's center in user coordinates, and the width and height in device coordinates
        such that is is not deformed
        """
        def __str__(self):
            return "DispersionEllipse(%s,%s;%sx%s)" % (self.center[0], self.center[1],
                                                       self.width, self.height)
        # @docstring.dedent_interpd
        def __init__(self, xy, width, height, scale=1.0, angle=0.0, **kwargs):
            """
            *xy*
              center of ellipse
            *width*
              total length (diameter) of horizontal axis
            *height*
              total length (diameter) of vertical axis
            *angle*
              rotation in degrees (anti-clockwise)
            Valid kwargs are:
            %(Patch)s
            """
            patches.Patch.__init__(self, **kwargs)
            self.center = xy
            self.width, self.height = width, height
            self.scale = scale
            self.angle = angle
            self._path = Path.unit_circle()
            # Note: This cannot be calculated until this is added to an Axes
            self._patch_transform = transforms.IdentityTransform()
        def _recompute_transform(self):
            """NOTE: This cannot be called until after this has been added
                     to an Axes, otherwise unit conversion will fail. This
                     maxes it very important to call the accessor method and
                     not directly access the transformation member variable.
            """
            center = (self.convert_xunits(self.center[0]),
                      self.convert_yunits(self.center[1]))
            width = self.width  # self.convert_xunits(self.width)
            height = self.height  # self.convert_yunits(self.height)
            trans = artist.Artist.get_transform(self)
            self._patch_transform = transforms.Affine2D() \
                .scale(width * 0.5 * self.scale, height * 0.5 * self.scale) \
                .rotate_deg(self.angle) \
                .translate(*trans.transform(center))
        def get_path(self):
            """
            Return the vertices of the rectangle
            """
            return self._path
        def get_transform(self):
            """
            Return the :class:`~matplotlib.transforms.Transform` applied
            to the :class:`Patch`.
            """
            return self.get_patch_transform()
        def get_patch_transform(self):
            self._recompute_transform()
            return self._patch_transform
        def contains(self, ev):
            if ev.x is None or ev.y is None:
                return False, {}
            x, y = self.get_transform().inverted().transform_point((ev.x, ev.y))
            return (x * x + y * y) <= 1.0, {}
    return DispersionEllipse(*args, **kwargs)