Merge branch 'Themanwithoutaplan-openpyxl22'

Author: jreback

ci/requirements-2.6.pip

@@ -1 +1,3 @@
 blosc
+openpyxl
+argparse

ci/requirements-2.6.run

@@ -4,7 +4,6 @@ pytz=2013b
 scipy=0.11.0
 xlwt=0.7.5
 xlrd=0.9.2
-openpyxl=2.0.3
 statsmodels=0.4.3
 html5lib=1.0b2
 beautiful-soup=4.2.0

ci/requirements-3.3.pip

@@ -1 +1,2 @@
 blosc
+openpyxl

ci/requirements-3.3.run

@@ -1,9 +1,9 @@
 python-dateutil
 pytz=2013b
 numpy=1.8.0
-openpyxl=1.6.2
 xlsxwriter=0.4.6
 xlrd=0.9.2
+xlwt
 html5lib=1.0b2
 numexpr
 pytables

doc/source/io.rst

@@ -2230,6 +2230,10 @@ Writing Excel Files to Memory
 Pandas supports writing Excel files to buffer-like objects such as ``StringIO`` or
 ``BytesIO`` using :class:`~pandas.io.excel.ExcelWriter`.
 
+.. versionadded:: 0.17
+
+Added support for Openpyxl >= 2.2
+
 .. code-block:: python
 
    # Safe import for either Python 2.x or 3.x
@@ -2279,14 +2283,15 @@ config options <options>` ``io.excel.xlsx.writer`` and
 files if `Xlsxwriter`_ is not available.
 
 .. _XlsxWriter: http://xlsxwriter.readthedocs.org
-.. _openpyxl: http://packages.python.org/openpyxl/
+.. _openpyxl: http://openpyxl.readthedocs.org/
 .. _xlwt: http://www.python-excel.org
 
 To specify which writer you want to use, you can pass an engine keyword
 argument to ``to_excel`` and to ``ExcelWriter``. The built-in engines are:
 
-- ``openpyxl``: This includes stable support for OpenPyxl 1.6.1 up to but
-  not including 2.0.0, and experimental support for OpenPyxl 2.0.0 and later.
+- ``openpyxl``: This includes stable support for Openpyxl from 1.6.1. However,
+  it is advised to use version 2.2 and higher, especially when working with
+  styles.
 - ``xlsxwriter``
 - ``xlwt``
 

doc/source/release.rst

@@ -64,7 +64,8 @@ Highlights include:
 - Support for reading SAS xport files, see :ref:`here <whatsnew_0170.enhancements.sas_xport>`
 - Documentation comparing SAS to *pandas*, see :ref:`here <compare_with_sas>`
 - Removal of the automatic TimeSeries broadcasting, deprecated since 0.8.0, see :ref:`here <whatsnew_0170.prior_deprecations>`
-- Compatibility with Python 3.5
+- Compatibility with Python 3.5 (:issue:`11097`)
+- Compatibility with matplotlib 1.5.0 (:issue:`11111`)
 
 See the :ref:`v0.17.0 Whatsnew <whatsnew_0170>` overview for an extensive list
 of all enhancements and bugs that have been fixed in 0.17.0.

doc/source/whatsnew/v0.17.0.txt

@@ -278,6 +278,7 @@ engine, they are mapped to NumPy calls.
 
 Changes to Excel with ``MultiIndex``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 In version 0.16.2 a ``DataFrame`` with ``MultiIndex`` columns could not be written to Excel via ``to_excel``.
 That functionality has been added (:issue:`10564`), along with updating  ``read_excel`` so that the data can
 be read back with no loss of information by specifying which columns/rows make up the ``MultiIndex``
@@ -336,6 +337,7 @@ Google BigQuery Enhancements
 Other enhancements
 ^^^^^^^^^^^^^^^^^^
 
+- Support for ``openpyxl`` >= 2.2. The API for style support is now stable (:issue:`10125`)
 - ``merge`` now accepts the argument ``indicator`` which adds a Categorical-type column (by default called ``_merge``) to the output object that takes on the values (:issue:`8790`)
 
   ===================================   ================

pandas/io/excel.py

@@ -57,8 +57,10 @@ def get_writer(engine_name):
             # make sure we make the intelligent choice for the user
             if LooseVersion(openpyxl.__version__) < '2.0.0':
                  return _writers['openpyxl1']
+            elif LooseVersion(openpyxl.__version__) < '2.2.0':
+                 return _writers['openpyxl20']
             else:
-                 return _writers['openpyxl2']
+                 return _writers['openpyxl22']
         except ImportError:
             # fall through to normal exception handling below
             pass
@@ -760,11 +762,11 @@ class _OpenpyxlWriter(_Openpyxl1Writer):
 register_writer(_OpenpyxlWriter)
 
 
-class _Openpyxl2Writer(_Openpyxl1Writer):
+class _Openpyxl20Writer(_Openpyxl1Writer):
     """
     Note: Support for OpenPyxl v2 is currently EXPERIMENTAL (GH7565).
     """
-    engine = 'openpyxl2'
+    engine = 'openpyxl20'
     openpyxl_majorver = 2
 
     def write_cells(self, cells, sheet_name=None, startrow=0, startcol=0):
@@ -1172,8 +1174,76 @@ def _convert_to_protection(cls, protection_dict):
         return Protection(**protection_dict)
 
 
-register_writer(_Openpyxl2Writer)
+register_writer(_Openpyxl20Writer)
 
+class _Openpyxl22Writer(_Openpyxl20Writer):
+    """
+    Note: Support for OpenPyxl v2.2 is currently EXPERIMENTAL (GH7565).
+    """
+    engine = 'openpyxl22'
+    openpyxl_majorver = 2
+
+    def write_cells(self, cells, sheet_name=None, startrow=0, startcol=0):
+        # Write the frame cells using openpyxl.
+        from openpyxl import styles
+
+        sheet_name = self._get_sheet_name(sheet_name)
+
+        _style_cache = {}
+
+        if sheet_name in self.sheets:
+            wks = self.sheets[sheet_name]
+        else:
+            wks = self.book.create_sheet()
+            wks.title = sheet_name
+            self.sheets[sheet_name] = wks
+
+        for cell in cells:
+            xcell = wks.cell(
+                        row=startrow + cell.row + 1,
+                        column=startcol + cell.col + 1
+                        )
+            xcell.value = _conv_value(cell.val)
+
+            style_kwargs = {}
+            if cell.style:
+                key = str(cell.style)
+                style_kwargs = _style_cache.get(key)
+                if style_kwargs is None:
+                    style_kwargs = self._convert_to_style_kwargs(cell.style)
+                    _style_cache[key] = style_kwargs
+
+            if style_kwargs:
+                for k, v in style_kwargs.items():
+                    setattr(xcell, k, v)
+
+            if cell.mergestart is not None and cell.mergeend is not None:
+
+                wks.merge_cells(
+                        start_row=startrow + cell.row + 1,
+                        start_column=startcol + cell.col + 1,
+                        end_column=startcol + cell.mergeend + 1,
+                        end_row=startrow + cell.mergeend + 1
+                        )
+
+                # When cells are merged only the top-left cell is preserved
+                # The behaviour of the other cells in a merged range is undefined
+                if style_kwargs:
+                    first_row = startrow + cell.row + 1
+                    last_row = startrow + cell.mergestart + 1
+                    first_col = startcol + cell.col + 1
+                    last_col = startcol + cell.mergeend + 1
+
+                    for row in range(first_row, last_row + 1):
+                        for col in range(first_col, last_col + 1):
+                            if row == first_row and col == first_col:
+                                # Ignore first cell. It is already handled.
+                                continue
+                            xcell = wks.cell(column=col, row=row)
+                            for k, v in style_kwargs.items():
+                                setattr(xcell, k, v)
+
+register_writer(_Openpyxl22Writer)
 
 class _XlwtWriter(ExcelWriter):
     engine = 'xlwt'

pandas/io/tests/test_excel.py

@@ -19,7 +19,7 @@
 from pandas.io.parsers import read_csv
 from pandas.io.excel import (
     ExcelFile, ExcelWriter, read_excel, _XlwtWriter, _Openpyxl1Writer,
-    _Openpyxl2Writer, register_writer, _XlsxWriter
+    _Openpyxl20Writer, _Openpyxl22Writer, register_writer, _XlsxWriter
 )
 from pandas.io.common import URLError
 from pandas.util.testing import ensure_clean, makeCustomDataframe as mkdf
@@ -1470,17 +1470,28 @@ def test_to_excel_styleconverter(self):
                          xlsx_style.alignment.vertical)
 
 
+def skip_openpyxl_gt21(cls):
+    """Skip a TestCase instance if openpyxl >= 2.2"""
+
+    @classmethod
+    def setUpClass(cls):
+        _skip_if_no_openpyxl()
+        import openpyxl
+        ver = openpyxl.__version__
+        if not (ver >= LooseVersion('2.0.0') and ver < LooseVersion('2.2.0')):
+            raise nose.SkipTest("openpyxl >= 2.2")
+
+    cls.setUpClass = setUpClass
+    return cls
+
 @raise_on_incompat_version(2)
-class Openpyxl2Tests(ExcelWriterBase, tm.TestCase):
+@skip_openpyxl_gt21
+class Openpyxl20Tests(ExcelWriterBase, tm.TestCase):
     ext = '.xlsx'
-    engine_name = 'openpyxl2'
+    engine_name = 'openpyxl20'
     check_skip = staticmethod(lambda *args, **kwargs: None)
 
     def test_to_excel_styleconverter(self):
-        _skip_if_no_openpyxl()
-        if not openpyxl_compat.is_compat(major_ver=2):
-            raise nose.SkipTest('incompatiable openpyxl version')
-
         import openpyxl
         from openpyxl import styles
 
@@ -1532,7 +1543,7 @@ def test_to_excel_styleconverter(self):
 
         protection = styles.Protection(locked=True, hidden=False)
 
-        kw = _Openpyxl2Writer._convert_to_style_kwargs(hstyle)
+        kw = _Openpyxl20Writer._convert_to_style_kwargs(hstyle)
         self.assertEqual(kw['font'], font)
         self.assertEqual(kw['border'], border)
         self.assertEqual(kw['alignment'], alignment)
@@ -1542,7 +1553,116 @@ def test_to_excel_styleconverter(self):
 
 
     def test_write_cells_merge_styled(self):
+        from pandas.core.format import ExcelCell
+        from openpyxl import styles
+
+        sheet_name='merge_styled'
+
+        sty_b1 = {'font': {'color': '00FF0000'}}
+        sty_a2 = {'font': {'color': '0000FF00'}}
+
+        initial_cells = [
+            ExcelCell(col=1, row=0, val=42, style=sty_b1),
+            ExcelCell(col=0, row=1, val=99, style=sty_a2),
+        ]
+
+        sty_merged = {'font': { 'color': '000000FF', 'bold': True }}
+        sty_kwargs = _Openpyxl20Writer._convert_to_style_kwargs(sty_merged)
+        openpyxl_sty_merged = styles.Style(**sty_kwargs)
+        merge_cells = [
+            ExcelCell(col=0, row=0, val='pandas',
+                    mergestart=1, mergeend=1, style=sty_merged),
+        ]
+
+        with ensure_clean('.xlsx') as path:
+            writer = _Openpyxl20Writer(path)
+            writer.write_cells(initial_cells, sheet_name=sheet_name)
+            writer.write_cells(merge_cells, sheet_name=sheet_name)
+
+            wks = writer.sheets[sheet_name]
+            xcell_b1 = wks.cell('B1')
+            xcell_a2 = wks.cell('A2')
+            self.assertEqual(xcell_b1.style, openpyxl_sty_merged)
+            self.assertEqual(xcell_a2.style, openpyxl_sty_merged)
+
+def skip_openpyxl_lt22(cls):
+    """Skip a TestCase instance if openpyxl < 2.2"""
+
+    @classmethod
+    def setUpClass(cls):
         _skip_if_no_openpyxl()
+        import openpyxl
+        ver = openpyxl.__version__
+        if ver < LooseVersion('2.2.0'):
+            raise nose.SkipTest("openpyxl < 2.2")
+
+    cls.setUpClass = setUpClass
+    return cls
+
+@raise_on_incompat_version(2)
+@skip_openpyxl_lt22
+class Openpyxl22Tests(ExcelWriterBase, tm.TestCase):
+    ext = '.xlsx'
+    engine_name = 'openpyxl22'
+    check_skip = staticmethod(lambda *args, **kwargs: None)
+
+    def test_to_excel_styleconverter(self):
+        import openpyxl
+        from openpyxl import styles
+
+        hstyle = {
+            "font": {
+                "color": '00FF0000',
+                "bold": True,
+            },
+            "borders": {
+                "top": "thin",
+                "right": "thin",
+                "bottom": "thin",
+                "left": "thin",
+            },
+            "alignment": {
+                "horizontal": "center",
+                "vertical": "top",
+            },
+            "fill": {
+                "patternType": 'solid',
+                'fgColor': {
+                    'rgb': '006666FF',
+                    'tint': 0.3,
+                },
+            },
+            "number_format": {
+                "format_code": "0.00"
+            },
+            "protection": {
+                "locked": True,
+                "hidden": False,
+            },
+        }
+
+        font_color = styles.Color('00FF0000')
+        font = styles.Font(bold=True, color=font_color)
+        side = styles.Side(style=styles.borders.BORDER_THIN)
+        border = styles.Border(top=side, right=side, bottom=side, left=side)
+        alignment = styles.Alignment(horizontal='center', vertical='top')
+        fill_color = styles.Color(rgb='006666FF', tint=0.3)
+        fill = styles.PatternFill(patternType='solid', fgColor=fill_color)
+
+        number_format = '0.00'
+
+        protection = styles.Protection(locked=True, hidden=False)
+
+        kw = _Openpyxl22Writer._convert_to_style_kwargs(hstyle)
+        self.assertEqual(kw['font'], font)
+        self.assertEqual(kw['border'], border)
+        self.assertEqual(kw['alignment'], alignment)
+        self.assertEqual(kw['fill'], fill)
+        self.assertEqual(kw['number_format'], number_format)
+        self.assertEqual(kw['protection'], protection)
+
+
+    def test_write_cells_merge_styled(self):
         if not openpyxl_compat.is_compat(major_ver=2):
             raise nose.SkipTest('incompatiable openpyxl version')
 
@@ -1560,23 +1680,23 @@ def test_write_cells_merge_styled(self):
         ]
 
         sty_merged = {'font': { 'color': '000000FF', 'bold': True }}
-        sty_kwargs = _Openpyxl2Writer._convert_to_style_kwargs(sty_merged)
-        openpyxl_sty_merged = styles.Style(**sty_kwargs)
+        sty_kwargs = _Openpyxl22Writer._convert_to_style_kwargs(sty_merged)
+        openpyxl_sty_merged = sty_kwargs['font']
         merge_cells = [
             ExcelCell(col=0, row=0, val='pandas',
                     mergestart=1, mergeend=1, style=sty_merged),
         ]
 
         with ensure_clean('.xlsx') as path:
-            writer = _Openpyxl2Writer(path)
+            writer = _Openpyxl22Writer(path)
             writer.write_cells(initial_cells, sheet_name=sheet_name)
             writer.write_cells(merge_cells, sheet_name=sheet_name)
 
             wks = writer.sheets[sheet_name]
             xcell_b1 = wks.cell('B1')
             xcell_a2 = wks.cell('A2')
-            self.assertEqual(xcell_b1.style, openpyxl_sty_merged)
-            self.assertEqual(xcell_a2.style, openpyxl_sty_merged)
+            self.assertEqual(xcell_b1.font, openpyxl_sty_merged)
+            self.assertEqual(xcell_a2.font, openpyxl_sty_merged)
 
 
 class XlwtTests(ExcelWriterBase, tm.TestCase):
@@ -1676,9 +1796,9 @@ def test_column_format(self):
             cell = read_worksheet.cell('B2')
 
             try:
-                read_num_format = cell.style.number_format._format_code
+                read_num_format = cell.number_format
             except:
-                read_num_format = cell.style.number_format
+                read_num_format = cell.style.number_format._format_code
 
             self.assertEqual(read_num_format, num_format)