ENH: XLSB support

doc/source/user_guide/io.rst

@@ -2764,7 +2764,8 @@ Excel files
 
 The :func:`~pandas.read_excel` method can read Excel 2003 (``.xls``)
 files using the ``xlrd`` Python module.  Excel 2007+ (``.xlsx``) files
-can be read using either ``xlrd`` or ``openpyxl``.
+can be read using either ``xlrd`` or ``openpyxl``. Binary Excel (``.xlsb``)
+files can be read using ``pyxlsb``.
 The :meth:`~DataFrame.to_excel` instance method is used for
 saving a ``DataFrame`` to Excel.  Generally the semantics are
 similar to working with :ref:`csv<io.read_csv_table>` data.
@@ -3225,6 +3226,29 @@ OpenDocument spreadsheets match what can be done for `Excel files`_ using
    Currently pandas only supports *reading* OpenDocument spreadsheets. Writing
    is not implemented.
 
+.. _io.xlsb:
+
+Binary Excel (.xlsb) files
+-------------------------
+
+.. versionadded:: 1.0.0
+
+The :func:`~pandas.read_excel` method can also read binary Excel files
+using the ``pyxlsb`` module. The semantics and features for reading
+binary Excel files match what can be done for `Excel files`_ using
+``engine='pyxlsb'``.
+
+.. code-block:: python
+
+   # Returns a DataFrame
+   pd.read_excel('path_to_file.xlsb', engine='pyxlsb')
+
+.. note::
+
+   Currently pandas only supports *reading* binary Excel files. Writing
+   is not implemented.
+
+
 .. _io.clipboard:
 
 Clipboard

doc/source/whatsnew/v1.0.0.rst

@@ -125,6 +125,7 @@ Other enhancements
 - Roundtripping DataFrames with nullable integer or string data types to parquet
   (:meth:`~DataFrame.to_parquet` / :func:`read_parquet`) using the `'pyarrow'` engine
   now preserve those data types with pyarrow >= 1.0.0 (:issue:`20612`).
+- :func:`read_excel` now can read binary Excel (``.xlsb``) files by passing ``engine='pyxlsb'``.
 
 Build Changes
 ^^^^^^^^^^^^^

pandas/core/config_init.py

@@ -478,6 +478,7 @@ def use_inf_as_na_cb(key):
 _xlsm_options = ["xlrd", "openpyxl"]
 _xlsx_options = ["xlrd", "openpyxl"]
 _ods_options = ["odf"]
+_xlsb_options = ["pyxlsb"]
 
 
 with cf.config_prefix("io.excel.xls"):
@@ -514,6 +515,13 @@ def use_inf_as_na_cb(key):
         validator=str,
     )
 
+with cf.config_prefix("io.excel.xlsb"):
+    cf.register_option(
+        "reader",
+        "auto",
+        reader_engine_doc.format(ext="xlsb", others=", ".join(_ods_options)),
+        validator=str,
+    )
 
 # Set up the io.excel specific writer configuration.
 writer_engine_doc = """

pandas/io/excel/_base.py

@@ -794,15 +794,21 @@ class ExcelFile:
         If a string or path object, expected to be a path to xls, xlsx or odf file.
     engine : str, default None
         If io is not a buffer or path, this must be set to identify io.
-        Acceptable values are None, ``xlrd``, ``openpyxl`` or ``odf``.
+        Acceptable values are None, ``xlrd``, ``openpyxl``,  ``odf``, or ``pyxlsb``.
         Note that ``odf`` reads tables out of OpenDocument formatted files.
     """
 
     from pandas.io.excel._odfreader import _ODFReader
     from pandas.io.excel._openpyxl import _OpenpyxlReader
     from pandas.io.excel._xlrd import _XlrdReader
-
-    _engines = {"xlrd": _XlrdReader, "openpyxl": _OpenpyxlReader, "odf": _ODFReader}
+    from pandas.io.excel._pyxlsb import _PyxlsbReader
+
+    _engines = {
+        "xlrd": _XlrdReader,
+        "openpyxl": _OpenpyxlReader,
+        "odf": _ODFReader,
+        "pyxlsb": _PyxlsbReader,
+    }
 
     def __init__(self, io, engine=None):
         if engine is None:

pandas/io/excel/_pyxlsb.py

@@ -0,0 +1,65 @@
+from typing import List
+
+from pandas.compat._optional import import_optional_dependency
+
+from pandas._typing import FilePathOrBuffer, Scalar
+
+from pandas.io.excel._base import _BaseExcelReader
+
+
+class _PyxlsbReader(_BaseExcelReader):
+    def __init__(self, filepath_or_buffer: FilePathOrBuffer):
+        """Reader using pyxlsb engine.
+
+        Parameters
+        __________
+        filepath_or_buffer: string, path object, or Workbook
+            Object to be parsed.
+        """
+        import_optional_dependency("pyxlsb")
+        # This will call load_workbook on the filepath or buffer
+        # And set the result to the book-attribute
+        super().__init__(filepath_or_buffer)
+
+    @property
+    def _workbook_class(self):
+        from pyxlsb import Workbook
+
+        return Workbook
+
+    def load_workbook(self, filepath_or_buffer: FilePathOrBuffer):
+        from pyxlsb import open_workbook
+
+        # Todo: hack in buffer capability
+        # This might need some modifications to the Pyxlsb library
+        # Actual work for opening it is in xlsbpackage.py, line 20-ish
+
+        return open_workbook(filepath_or_buffer)
+
+    @property
+    def sheet_names(self) -> List[str]:
+        return self.book.sheets
+
+    def get_sheet_by_name(self, name: str):
+        return self.book.get_sheet(name)
+
+    def get_sheet_by_index(self, index: int):
+        # pyxlsb sheets are indexed from 1 onwards
+        # There's a fix for this in the source, but the pypi package doesn't have it
+        return self.book.get_sheet(index + 1)
+
+    def _convert_cell(self, cell, convert_float: bool) -> Scalar:
+        # Todo: there is no way to distinguish between floats and datetimes in pyxlsb
+        # This means that there is no way to read datetime types from an xlsb file yet
+
+        if isinstance(cell.v, float) and convert_float:
+            val = int(cell.v)
+            if val == cell.v:
+                return val
+            else:
+                return float(cell.v)
+
+        return cell.v
+
+    def get_sheet_data(self, sheet, convert_float: bool) -> List[List[Scalar]]:
+        return [[self._convert_cell(c, convert_float) for c in r] for r in sheet]

pandas/tests/io/excel/conftest.py

@@ -33,7 +33,7 @@ def df_ref(datapath):
     return df_ref
 
 
-@pytest.fixture(params=[".xls", ".xlsx", ".xlsm", ".ods"])
+@pytest.fixture(params=[".xls", ".xlsx", ".xlsm", ".ods", ".xlsb"])
 def read_ext(request):
     """
     Valid extensions for reading Excel files.

pandas/tests/io/excel/test_readers.py

@@ -57,6 +57,13 @@ def ignore_xlrd_time_clock_warning():
                 pytest.mark.filterwarnings("ignore:.*(tree\\.iter|html argument)"),
             ],
         ),
+        pytest.param(
+            None,
+            marks=[
+                td.skip_if_no("pyxlsb"),
+                pytest.mark.filterwarnings("ignore:.*(tree\\.iter|html argument)"),
+            ],
+        ),
         pytest.param("odf", marks=td.skip_if_no("odf")),
     ]
 )
@@ -73,12 +80,16 @@ def cd_and_set_engine(self, engine, datapath, monkeypatch, read_ext):
         """
         Change directory and set engine for read_excel calls.
         """
-        if engine == "openpyxl" and read_ext == ".xls":
+        if engine == "openpyxl" and read_ext in (".xls", ".xlsb"):
             pytest.skip()
         if engine == "odf" and read_ext != ".ods":
             pytest.skip()
         if read_ext == ".ods" and engine != "odf":
             pytest.skip()
+        if engine == "pyxlsb" and read_ext != ".xlsb":
+            pytest.skip()
+        if read_ext == ".xlsb" and engine != "pyxlsb":
+            pytest.skip()
 
         func = partial(pd.read_excel, engine=engine)
         monkeypatch.chdir(datapath("io", "data", "excel"))
@@ -813,7 +824,9 @@ def cd_and_set_engine(self, engine, datapath, monkeypatch, read_ext):
             pytest.skip()
         if read_ext == ".ods" and engine != "odf":
             pytest.skip()
-        if engine == "openpyxl" and read_ext == ".xls":
+        if engine == "openpyxl" and read_ext in (".xls", ".xlsb"):
+            pytest.skip()
+        if engine == "pyxlsb" and read_ext != ".xlsb":
             pytest.skip()
 
         func = partial(pd.ExcelFile, engine=engine)