Replace code-block with ipython

Code within code-blocks is displayed as is, not allowing linenumbers
to be properly set. The change to ipython directives with :verbatim:
generates correct linenumbers whilst not executing the code.

Signed-off-by: Fabian Haase <haase.fabian@gmail.com>

Author: FHaase

doc/source/10min.rst

@@ -84,7 +84,6 @@ will be completed:
    :verbatim:
 
    In [0]: df2.<TAB>
-   Out[0]:
    df2.A                  df2.bool
    df2.abs                df2.boxplot
    df2.add                df2.C

doc/source/basics.rst

@@ -118,7 +118,8 @@ These are both enabled to be used by default, you can control this by setting th
 
 .. versionadded:: 0.20.0
 
-.. code-block:: python
+.. ipython:: python
+   :verbatim:
 
    pd.set_option('compute.use_bottleneck', False)
    pd.set_option('compute.use_numexpr', False)
@@ -389,12 +390,15 @@ objects of the same length:
 Trying to compare ``Index`` or ``Series`` objects of different lengths will
 raise a ValueError:
 
-.. code-block:: ipython
+.. ipython:: ipython
+    :verbatim:
 
     In [55]: pd.Series(['foo', 'bar', 'baz']) == pd.Series(['foo', 'bar'])
+    ---------------------------------------------------------------------------
     ValueError: Series lengths must match to compare
 
     In [56]: pd.Series(['foo', 'bar', 'baz']) == pd.Series(['foo'])
+    ---------------------------------------------------------------------------
     ValueError: Series lengths must match to compare
 
 Note that this is different from the NumPy behavior where a comparison can

doc/source/gotchas.rst

@@ -312,7 +312,7 @@ Occasionally you may have to deal with data that were created on a machine with
 a different byte order than the one on which you are running Python. A common 
 symptom of this issue is an error like:
 
-.. code-block:: py3tb
+.. code-block:: pytb
 
     Traceback
         ...

doc/source/groupby.rst

@@ -79,14 +79,15 @@ pandas objects can be split on any of their axes. The abstract definition of
 grouping is to provide a mapping of labels to group names. To create a GroupBy
 object (more on what the GroupBy object is later), you may do the following:
 
-.. code-block:: python
+.. ipython:: python
    :flake8-group: None
    :flake8-add-ignore: F821
+   :verbatim:
 
    # default is axis=0
-   >>> grouped = obj.groupby(key)
-   >>> grouped = obj.groupby(key, axis=1)
-   >>> grouped = obj.groupby([key1, key2])
+   grouped = obj.groupby(key)
+   grouped = obj.groupby(key, axis=1)
+   grouped = obj.groupby([key1, key2])
 
 The mapping can be specified many different ways:
 
@@ -141,16 +142,15 @@ but the specified columns
 These will split the DataFrame on its index (rows). We could also split by the
 columns:
 
-.. ipython::
+.. ipython:: python
 
-    In [4]: def get_letter_type(letter):
-       ...:     if letter.lower() in 'aeiou':
-       ...:         return 'vowel'
-       ...:     else:
-       ...:         return 'consonant'
-       ...:
+    def get_letter_type(letter):
+        if letter.lower() in 'aeiou':
+            return 'vowel'
+        else:
+            return 'consonant'
 
-    In [5]: grouped = df.groupby(get_letter_type, axis=1)
+    grouped = df.groupby(get_letter_type, axis=1)
 
 pandas :class:`~pandas.Index` objects support duplicate values. If a
 non-unique index is used as the group key in a groupby operation, all values
@@ -251,11 +251,11 @@ the length of the ``groups`` dict, so it is largely just a convenience:
    gb = df.groupby('gender')
 
 
-.. ipython::
+.. ipython:: ipython
    :flake8-group: None
    :flake8-set-ignore: E999, E225
+   :verbatim:
 
-   @verbatim
    In [1]: gb.<TAB>
    gb.agg        gb.boxplot    gb.cummin     gb.describe   gb.filter     gb.get_group  gb.height     gb.last       gb.median     gb.ngroups    gb.plot       gb.rank       gb.std        gb.transform
    gb.aggregate  gb.count      gb.cumprod    gb.dtype      gb.first      gb.groups     gb.hist       gb.max        gb.min        gb.nth        gb.prod       gb.resample   gb.sum        gb.var
@@ -409,23 +409,21 @@ Iterating through groups
 With the GroupBy object in hand, iterating through the grouped data is very
 natural and functions similarly to :py:func:`itertools.groupby`:
 
-.. ipython::
+.. ipython:: python
 
-   In [4]: grouped = df.groupby('A')
+   grouped = df.groupby('A')
 
-   In [5]: for name, group in grouped:
-      ...:     print(name)
-      ...:     print(group)
-      ...:
+   for name, group in grouped:
+       print(name)
+       print(group)
 
 In the case of grouping by multiple keys, the group name will be a tuple:
 
-.. ipython::
+.. ipython:: python
 
-   In [5]: for name, group in df.groupby(['A', 'B']):
-      ...:     print(name)
-      ...:     print(group)
-      ...:
+   for name, group in df.groupby(['A', 'B']):
+       print(name)
+       print(group)
 
 See :ref:`timeseries.iterating-label`.
 
@@ -924,16 +922,15 @@ for both ``aggregate`` and ``transform`` in many standard use cases. However,
 
 The dimension of the returned result can also change:
 
-.. ipython::
+.. ipython:: python
 
-    In [8]: grouped = df.groupby('A')['C']
+    grouped = df.groupby('A')['C']
 
-    In [10]: def f(group):
-       ....:     return pd.DataFrame({'original': group,
-       ....:                          'demeaned': group - group.mean()})
-       ....:
+    def f(group):
+        return pd.DataFrame({'original': group,
+                             'demeaned': group - group.mean()})
 
-    In [11]: grouped.apply(f)
+    grouped.apply(f)
 
 ``apply`` on a Series can operate on a returned value from the applied function,
 that is itself a series, and possibly upcast the result to a DataFrame:
@@ -1316,9 +1313,10 @@ Now, to find prices per store/product, we can simply do:
 Piping can also be expressive when you want to deliver a grouped object to some
 arbitrary function, for example:
 
-.. code-block:: python
+.. ipython:: python
    :flake8-group: None
    :flake8-add-ignore: F821
+   :verbatim:
 
    df.groupby(['Store', 'Product']).pipe(report_func)
 

doc/source/reshaping.rst

@@ -20,22 +20,21 @@ Reshaping by pivoting DataFrame objects
 
 .. image:: _static/reshaping_pivot.png
 
-.. ipython::
+.. ipython:: python
    :suppress:
 
-   In [1]: import pandas.util.testing as tm
-      ...: tm.N = 3
+   import pandas.util.testing as tm
+   tm.N = 3
 
-   In [2]: def unpivot(frame):
-      ...:         N, K = frame.shape
-      ...:         data = {'value': frame.values.ravel('F'),
-      ...:                 'variable': np.asarray(frame.columns).repeat(N),
-      ...:                 'date': np.tile(np.asarray(frame.index), K)}
-      ...:         columns = ['date', 'variable', 'value']
-      ...:         return pd.DataFrame(data, columns=columns)
-      ...:
+   def unpivot(frame):
+           N, K = frame.shape
+           data = {'value': frame.values.ravel('F'),
+                   'variable': np.asarray(frame.columns).repeat(N),
+                   'date': np.tile(np.asarray(frame.index), K)}
+           columns = ['date', 'variable', 'value']
+           return pd.DataFrame(data, columns=columns)
 
-   In [3]: df = unpivot(tm.makeTimeDataFrame())
+   df = unpivot(tm.makeTimeDataFrame())
 
 Data is often stored in so-called "stacked" or "record" format:
 
@@ -705,7 +704,8 @@ handling of NaN:
    because of an ordering bug. See also
    `here <https://github.com/numpy/numpy/issues/641>`__.
 
-.. code-block:: ipython
+.. ipython:: ipython
+    :verbatim:
 
     In [2]: pd.factorize(x, sort=True)
     Out[2]:

doc/source/sparse.rst

@@ -157,9 +157,11 @@ You can change the dtype using ``.astype()``, the result is also sparse. Note th
 
 It raises if any value cannot be coerced to specified dtype.
 
-.. code-block:: ipython
+.. ipython:: ipython
+   :verbatim:
 
    In [1]: ss = pd.Series([1, np.nan, np.nan]).to_sparse()
+   Out[1]:
    0    1.0
    1    NaN
    2    NaN
@@ -169,6 +171,7 @@ It raises if any value cannot be coerced to specified dtype.
    Block lengths: array([1], dtype=int32)
 
    In [2]: ss.astype(np.int64)
+   ----------------------------------------------------------------------------
    ValueError: unable to coerce current fill_value nan to int64 dtype
 
 .. _sparse.calculation:

doc/source/text.rst

@@ -201,7 +201,8 @@ regular expression object will raise a ``ValueError``.
     :verbatim:
 
     In [1]: s3.str.replace(regex_pat, 'XX-XX ', flags=re.IGNORECASE)
-    Out[1]: ValueError: case and flags cannot be set when pat is a compiled regex
+    ---------------------------------------------------------------------------
+    ValueError: case and flags cannot be set when pat is a compiled regex
 
 .. _text.concatenate:
 
@@ -442,9 +443,11 @@ returns a ``DataFrame`` if ``expand=True``.
 
 It raises ``ValueError`` if ``expand=False``.
 
-.. code-block:: python
+.. ipython:: ipython
+    :varbatim:
 
-    >>> s.index.str.extract("(?P<letter>[a-zA-Z])([0-9]+)", expand=False)
+    In [1]: s.index.str.extract("(?P<letter>[a-zA-Z])([0-9]+)", expand=False)
+    ---------------------------------------------------------------------------
     ValueError: only one regex group is supported with Index
 
 The table below summarizes the behavior of ``extract(expand=False)``

doc/source/timeseries.rst

@@ -291,9 +291,11 @@ Invalid Data
 
 The default behavior, ``errors='raise'``, is to raise when unparseable:
 
-.. code-block:: ipython
+.. ipython:: ipython
+    :verbatim:
 
     In [2]: pd.to_datetime(['2009/07/31', 'asd'], errors='raise')
+    ---------------------------------------------------------------------------
     ValueError: Unknown string format
 
 Pass ``errors='ignore'`` to return the original input when unparseable:
@@ -1853,9 +1855,11 @@ If ``Period`` freq is daily or higher (``D``, ``H``, ``T``, ``S``, ``L``, ``U``,
    p + datetime.timedelta(minutes=120)
    p + np.timedelta64(7200, 's')
 
-.. code-block:: ipython
+.. ipython:: ipython
+   :verbatim:
 
    In [1]: p + pd.offsets.Minute(5)
+   ----------------------------------------------------------------------------
    Traceback
       ...
    ValueError: Input has different freq from Period(freq=H)
@@ -1867,9 +1871,11 @@ If ``Period`` has other frequencies, only the same ``offsets`` can be added. Oth
    p = pd.Period('2014-07', freq='M')
    p + pd.offsets.MonthEnd(3)
 
-.. code-block:: ipython
+.. ipython:: ipython
+   :verbatim:
 
    In [1]: p + pd.offsets.MonthBegin(3)
+   ----------------------------------------------------------------------------
    Traceback
       ...
    ValueError: Input has different freq from Period(freq=M)
@@ -2333,9 +2339,11 @@ contains ambiguous times and the bottom will infer the right offset.
 
 This will fail as there are ambiguous times
 
-.. code-block:: ipython
+.. ipython:: ipython
+   :verbatim:
 
    In [2]: rng_hourly.tz_localize('US/Eastern')
+   ----------------------------------------------------------------------------
    AmbiguousTimeError: Cannot infer dst time from Timestamp('2011-11-06 01:00:00'), try using the 'ambiguous' argument
 
 Infer the ambiguous times
@@ -2388,9 +2396,11 @@ can be controlled by the ``nonexistent`` argument. The following options are ava
 
 Localization of nonexistent times will raise an error by default.
 
-.. code-block:: ipython
+.. ipython:: ipython
+   :verbatim:
 
    In [2]: dti.tz_localize('Europe/Warsaw')
+   ----------------------------------------------------------------------------
    NonExistentTimeError: 2015-03-29 02:30:00
 
 Transform nonexistent times to ``NaT`` or the closest real time forward in time.

doc/source/visualization.rst

@@ -123,15 +123,14 @@ For example, a bar plot can be created the following way:
 
 You can also create these other plots using the methods ``DataFrame.plot.<kind>`` instead of providing the ``kind`` keyword argument. This makes it easier to discover plot methods and the specific arguments they use:
 
-.. ipython::
+.. ipython:: ipython
     :flake8-group: None
     :flake8-add-ignore: E999, E225, F821,  # E999 breaks linting for complete block
     :verbatim:
 
     In [0]: df = pd.DataFrame()
 
     In [1]: df.plot.<TAB>
-    Out[1]:
     df.plot.area     df.plot.barh     df.plot.density  df.plot.hist     df.plot.line     df.plot.scatter
     df.plot.bar      df.plot.box      df.plot.hexbin   df.plot.kde      df.plot.pie