matplotlib
diff --git a/‎lib/matplotlib/axes/_axes.py
Lines changed: 8 additions & 263 deletions b/‎lib/matplotlib/axes/_axes.py
Lines changed: 8 additions & 263 deletions
@@ -596,283 +596,28 @@ def axhline(self, y=0, xmin=0, xmax=1, **kwargs):
         return _lines.axhline(self, y=0, xmin=0, xmax=1, **kwargs)
     axhline.__doc__ = _lines.axhline.__doc__
 
-    @docstring.dedent_interpd
     def axvline(self, x=0, ymin=0, ymax=1, **kwargs):
-        """
-        Add a vertical line across the axes.
-
-        Parameters
-        ----------
-        x : scalar, optional, default: 0
-            y position in data coordinates of the vertical line.
-
-        ymin : scalar, optional, default: 0
-            Should be between 0 and 1, 0 being the far left of the plot, 1 the
-            far right of the plot.
-
-        ymax : scalar, optional, default: 1
-            Should be between 0 and 1, 0 being the far left of the plot, 1 the
-            far right of the plot.
-
-        Returns
-        -------
-        `~matplotlib.lines.Line2D`
-
-
-        Examples
-        ---------
-        * draw a thick red vline at *x* = 0 that spans the yrange::
-
-            >>> axvline(linewidth=4, color='r')
-
-        * draw a default vline at *x* = 1 that spans the yrange::
+        return _lines.axvline(self, x=0, ymin=0, ymax=1, **kwargs)
+    axvline.__doc__ = _lines.axvline.__doc__
 
-            >>> axvline(x=1)
-
-        * draw a default vline at *x* = .5 that spans the the middle half of
-          the yrange::
-
-            >>> axvline(x=.5, ymin=0.25, ymax=0.75)
-
-        Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,
-        with the exception of 'transform':
-
-        %(Line2D)s
-
-        See also
-        --------
-
-        `axhspan` for example plot and source code
-        """
-
-        if "transform" in kwargs:
-            raise ValueError(
-                "'transform' is not allowed as a kwarg;"
-                + "axvline generates its own transform.")
-        xmin, xmax = self.get_xbound()
-
-        # We need to strip away the units for comparison with
-        # non-unitized bounds
-        self._process_unit_info(xdata=x, kwargs=kwargs)
-        xx = self.convert_xunits(x)
-        scalex = (xx < xmin) or (xx > xmax)
-
-        trans = mtransforms.blended_transform_factory(
-            self.transData, self.transAxes)
-        l = mlines.Line2D([x, x], [ymin, ymax], transform=trans, **kwargs)
-        self.add_line(l)
-        self.autoscale_view(scalex=scalex, scaley=False)
-        return l
-
-    @docstring.dedent_interpd
     def axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs):
-        """
-        Add a horizontal span (rectangle) across the axis.
-
-        Call signature::
-
-          axhspan(ymin, ymax, xmin=0, xmax=1, **kwargs)
-
-        *y* coords are in data units and *x* coords are in axes (relative
-        0-1) units.
-
-        Draw a horizontal span (rectangle) from *ymin* to *ymax*.
-        With the default values of *xmin* = 0 and *xmax* = 1, this
-        always spans the xrange, regardless of the xlim settings, even
-        if you change them, e.g., with the :meth:`set_xlim` command.
-        That is, the horizontal extent is in axes coords: 0=left,
-        0.5=middle, 1.0=right but the *y* location is in data
-        coordinates.
-
-        Return value is a :class:`matplotlib.patches.Polygon`
-        instance.
-
-       Examples:
-
-        * draw a gray rectangle from *y* = 0.25-0.75 that spans the
-          horizontal extent of the axes::
-
-            >>> axhspan(0.25, 0.75, facecolor='0.5', alpha=0.5)
-
-        Valid kwargs are :class:`~matplotlib.patches.Polygon` properties:
-
-        %(Polygon)s
-
-        **Example:**
-
-        .. plot:: mpl_examples/pylab_examples/axhspan_demo.py
-
-        """
-        trans = mtransforms.blended_transform_factory(
-            self.transAxes, self.transData)
-
-        # process the unit information
-        self._process_unit_info([xmin, xmax], [ymin, ymax], kwargs=kwargs)
-
-        # first we need to strip away the units
-        xmin, xmax = self.convert_xunits([xmin, xmax])
-        ymin, ymax = self.convert_yunits([ymin, ymax])
-
-        verts = (xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)
-        p = mpatches.Polygon(verts, **kwargs)
-        p.set_transform(trans)
-        self.add_patch(p)
-        self.autoscale_view(scalex=False)
-        return p
+        return _lines.axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs)
+    axhspan.__doc__ = _lines.axhspan.__doc__
 
-    @docstring.dedent_interpd
     def axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs):
-        """
-        Add a vertical span (rectangle) across the axes.
-
-        Call signature::
-
-          axvspan(xmin, xmax, ymin=0, ymax=1, **kwargs)
-
-        *x* coords are in data units and *y* coords are in axes (relative
-        0-1) units.
-
-        Draw a vertical span (rectangle) from *xmin* to *xmax*.  With
-        the default values of *ymin* = 0 and *ymax* = 1, this always
-        spans the yrange, regardless of the ylim settings, even if you
-        change them, e.g., with the :meth:`set_ylim` command.  That is,
-        the vertical extent is in axes coords: 0=bottom, 0.5=middle,
-        1.0=top but the *y* location is in data coordinates.
-
-        Return value is the :class:`matplotlib.patches.Polygon`
-        instance.
-
-        Examples:
-
-        * draw a vertical green translucent rectangle from x=1.25 to 1.55 that
-          spans the yrange of the axes::
-
-            >>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5)
-
-        Valid kwargs are :class:`~matplotlib.patches.Polygon`
-        properties:
-
-        %(Polygon)s
-
-        .. seealso::
-
-            :meth:`axhspan`
-                for example plot and source code
-        """
-        trans = mtransforms.blended_transform_factory(
-            self.transData, self.transAxes)
-
-        # process the unit information
-        self._process_unit_info([xmin, xmax], [ymin, ymax], kwargs=kwargs)
+        return _lines.axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs)
+    axvspan.__doc__ = _lines.axvspan.__doc__
 
-        # first we need to strip away the units
-        xmin, xmax = self.convert_xunits([xmin, xmax])
-        ymin, ymax = self.convert_yunits([ymin, ymax])
-
-        verts = [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)]
-        p = mpatches.Polygon(verts, **kwargs)
-        p.set_transform(trans)
-        self.add_patch(p)
-        self.autoscale_view(scaley=False)
-        return p
-
-    @docstring.dedent
     def hlines(self, y, xmin, xmax, colors='k', linestyles='solid',
                label='', **kwargs):
         return _lines.hlines(self, y, xmin, xmax, colors='k',
                              linestyles='solid', label='', **kwargs)
     hlines.__doc__ = _lines.hlines.__doc__
 
-    @docstring.dedent_interpd
     def vlines(self, x, ymin, ymax, colors='k', linestyles='solid',
                label='', **kwargs):
-        """
-        Plot vertical lines.
-
-        Plot vertical lines at each `x` from `ymin` to `ymax`.
-
-        Parameters
-        ----------
-        x : scalar or 1D array_like
-            x-indexes where to plot the lines.
-
-        xmin, xmax : scalar or 1D array_like
-            Respective beginning and end of each line. If scalars are
-            provided, all lines will have same length.
-
-        colors : array_like of colors, optional, default: 'k'
-
-        linestyles : ['solid' | 'dashed' | 'dashdot' | 'dotted'], optional
-
-        label : string, optional, default: ''
-
-        Returns
-        -------
-        lines : `~matplotlib.collections.LineCollection`
-
-        Other parameters
-        ----------------
-        kwargs : `~matplotlib.collections.LineCollection` properties.
-
-        See also
-        --------
-        hlines : horizontal lines
-
-        Examples
-        ---------
-        .. plot:: mpl_examples/pylab_examples/vline_hline_demo.py
-
-        """
-
-        self._process_unit_info(xdata=x, ydata=[ymin, ymax], kwargs=kwargs)
-
-        # We do the conversion first since not all unitized data is uniform
-        x = self.convert_xunits(x)
-        ymin = self.convert_yunits(ymin)
-        ymax = self.convert_yunits(ymax)
-
-        if not iterable(x):
-            x = [x]
-        if not iterable(ymin):
-            ymin = [ymin]
-        if not iterable(ymax):
-            ymax = [ymax]
-
-        x = np.asarray(x)
-        ymin = np.asarray(ymin)
-        ymax = np.asarray(ymax)
-        if len(ymin) == 1:
-            ymin = np.resize(ymin, x.shape)
-        if len(ymax) == 1:
-            ymax = np.resize(ymax, x.shape)
-
-        if len(ymin) != len(x):
-            raise ValueError('ymin and x are unequal sized sequences')
-        if len(ymax) != len(x):
-            raise ValueError('ymax and x are unequal sized sequences')
-
-        Y = np.array([ymin, ymax]).T
-
-        verts = [((thisx, thisymin), (thisx, thisymax))
-                 for thisx, (thisymin, thisymax) in zip(x, Y)]
-        #print 'creating line collection'
-        coll = mcoll.LineCollection(verts, colors=colors,
-                                    linestyles=linestyles, label=label)
-        self.add_collection(coll)
-        coll.update(kwargs)
-
-        if len(x) > 0:
-            minx = min(x)
-            maxx = max(x)
-
-            miny = min(min(ymin), min(ymax))
-            maxy = max(max(ymin), max(ymax))
-
-            corners = (minx, miny), (maxx, maxy)
-            self.update_datalim(corners)
-            self.autoscale_view()
-
-        return coll
+        return _lines.vlines.__doc__
+    vlines.__doc__ = _lines.vlines.__doc__
 
     @docstring.dedent_interpd
     def eventplot(self, positions, orientation='horizontal', lineoffsets=1,