text: """
  Module parse to/from Excel
  """
  
  # ---------------------------------------------------------------------
  # ExcelFile class
  from datetime import datetime, date, time, MINYEAR, timedelta
  
  import os
  import abc
  import warnings
  import numpy as np
  from io import UnsupportedOperation
  
  from pandas.core.dtypes.common import (
      is_integer, is_float,
      is_bool, is_list_like)
  
  from pandas.core.frame import DataFrame
  from pandas.io.parsers import TextParser
  from pandas.errors import EmptyDataError
  from pandas.io.common import (_is_url, _urlopen, _validate_header_arg,
                                get_filepath_or_buffer, _NA_VALUES,
                                _stringify_path)
  import pandas._libs.json as json
  from pandas.compat import (map, zip, reduce, range, lrange, u, add_metaclass,
                             string_types, OrderedDict)
  from pandas.core import config
  from pandas.io.formats.printing import pprint_thing
  import pandas.compat as compat
  from warnings import warn
  from distutils.version import LooseVersion
  from pandas.util._decorators import Appender, deprecate_kwarg
  from textwrap import fill
  
  __all__ = ["read_excel", "ExcelWriter", "ExcelFile"]
  
  _writer_extensions = ["xlsx", "xls", "xlsm"]
  _writers = {}
  
  _read_excel_doc = """
  Read an Excel table into a pandas DataFrame
  
  Parameters
  ----------
  io : string, path object (pathlib.Path or py._path.local.LocalPath),
      file-like object, pandas ExcelFile, or xlrd workbook.
      The string could be a URL. Valid URL schemes include http, ftp, s3,
      and file. For file URLs, a host is expected. For instance, a local
      file could be file://localhost/path/to/workbook.xlsx
  sheet_name : string, int, mixed list of strings/ints, or None, default 0
  
      Strings are used for sheet names, Integers are used in zero-indexed
      sheet positions.
  
      Lists of strings/integers are used to request multiple sheets.
  
      Specify None to get all sheets.
  
      str|int -> DataFrame is returned.
      list|None -> Dict of DataFrames is returned, with keys representing
      sheets.
  
      Available Cases
  
      * Defaults to 0 -> 1st sheet as a DataFrame
      * 1 -> 2nd sheet as a DataFrame
      * "Sheet1" -> 1st sheet as a DataFrame
      * [0,1,"Sheet5"] -> 1st, 2nd & 5th sheet as a dictionary of DataFrames
      * None -> All sheets as a dictionary of DataFrames
  
  sheetname : string, int, mixed list of strings/ints, or None, default 0
  
      .. deprecated:: 0.21.0
         Use `sheet_name` instead
  
  header : int, list of ints, default 0
      Row (0-indexed) to use for the column labels of the parsed
      DataFrame. If a list of integers is passed those row positions will
      be combined into a ``MultiIndex``. Use None if there is no header.
  names : array-like, default None
      List of column names to use. If file contains no header row,
      then you should explicitly pass header=None
  index_col : int, list of ints, default None
      Column (0-indexed) to use as the row labels of the DataFrame.
      Pass None if there is no such column.  If a list is passed,
      those columns will be combined into a ``MultiIndex``.  If a
      subset of data is selected with ``usecols``, index_col
      is based on the subset.
  parse_cols : int or list, default None
  
      .. deprecated:: 0.21.0
         Pass in `usecols` instead.
  
  usecols : int or list, default None
      * If None then parse all columns,
      * If int then indicates last column to be parsed
      * If list of ints then indicates list of column numbers to be parsed
      * If string then indicates comma separated list of Excel column letters and
        column ranges (e.g. "A:E" or "A,C,E:F").  Ranges are inclusive of
        both sides.
  squeeze : boolean, default False
      If the parsed data only contains one column then return a Series
  dtype : Type name or dict of column -> type, default None
      Data type for data or columns. E.g. {'a': np.float64, 'b': np.int32}
      Use `object` to preserve data as stored in Excel and not interpret dtype.
      If converters are specified, they will be applied INSTEAD
      of dtype conversion.
  
      .. versionadded:: 0.20.0
  
  engine: string, default None
      If io is not a buffer or path, this must be set to identify io.
      Acceptable values are None or xlrd
  converters : dict, default None
      Dict of functions for converting values in certain columns. Keys can
      either be integers or column labels, values are functions that take one
      input argument, the Excel cell content, and return the transformed
      content.
  true_values : list, default None
      Values to consider as True
  
      .. versionadded:: 0.19.0
  
  false_values : list, default None
      Values to consider as False
  
      .. versionadded:: 0.19.0
  
  skiprows : list-like
      Rows to skip at the beginning (0-indexed)
  nrows : int, default None
      Number of rows to parse
  
      .. versionadded:: 0.23.0
  
  na_values : scalar, str, list-like, or dict, default None
      Additional strings to recognize as NA/NaN. If dict passed, specific
      per-column NA values. By default the following values are interpreted
      as NaN: '""" + fill("', '".join(sorted(_NA_VALUES)), 70, subsequent_indent="    ") + """'.
  keep_default_na : bool, default True
      If na_values are specified and keep_default_na is False the default NaN
      values are overridden, otherwise they're appended to.
  verbose : boolean, default False
      Indicate number of NA values placed in non-numeric columns
  thousands : str, default None
      Thousands separator for parsing string columns to numeric.  Note that
      this parameter is only necessary for columns stored as TEXT in Excel,
      any numeric columns will automatically be parsed, regardless of display
      format.
  comment : str, default None
      Comments out remainder of line. Pass a character or characters to this
      argument to indicate comments in the input file. Any data between the
      comment string and the end of the current line is ignored.
  skip_footer : int, default 0
  
      .. deprecated:: 0.23.0
         Pass in `skipfooter` instead.
  skipfooter : int, default 0
      Rows at the end to skip (0-indexed)
  convert_float : boolean, default True
      convert integral floats to int (i.e., 1.0 --> 1). If False, all numeric
      data will be read in as floats: Excel stores all numbers as floats
      internally
  
  Returns
  -------
  parsed : DataFrame or Dict of DataFrames
      DataFrame from the passed in Excel file.  See notes in sheet_name
      argument for more information on when a Dict of Dataframes is returned.
  
  Examples
  --------
  
  An example DataFrame written to a local file
  
  >>> df_out = pd.DataFrame([('string1', 1),
  ...                        ('string2', 2),
  ...                        ('string3', 3)],
  ...                       columns=['Name', 'Value'])
  >>> df_out
        Name  Value
  0  string1      1
  1  string2      2
  2  string3      3
  >>> df_out.to_excel('tmp.xlsx')
  
  The file can be read using the file name as string or an open file object:
  
  >>> pd.read_excel('tmp.xlsx')
        Name  Value
  0  string1      1
  1  string2      2
  2  string3      3
  
  >>> pd.read_excel(open('tmp.xlsx','rb'))
        Name  Value
  0  string1      1
  1  string2      2
  2  string3      3
  
  Index and header can be specified via the `index_col` and `header` arguments
  
  >>> pd.read_excel('tmp.xlsx', index_col=None, header=None)
       0        1      2
  0  NaN     Name  Value
  1  0.0  string1      1
  2  1.0  string2      2
  3  2.0  string3      3
  
  Column types are inferred but can be explicitly specified
  
  >>> pd.read_excel('tmp.xlsx', dtype={'Name':str, 'Value':float})
        Name  Value
  0  string1    1.0
  1  string2    2.0
  2  string3    3.0
  
  True, False, and NA values, and thousands separators have defaults,
  but can be explicitly specified, too. Supply the values you would like
  as strings or lists of strings!
  
  >>> pd.read_excel('tmp.xlsx',
  ...               na_values=['string1', 'string2'])
        Name  Value
  0      NaN      1
  1      NaN      2
  2  string3      3
  
  Comment lines in the excel input file can be skipped using the `comment` kwarg
  
  >>> df = pd.DataFrame({'a': ['1', '#2'], 'b': ['2', '3']})
  >>> df.to_excel('tmp.xlsx', index=False)
  >>> pd.read_excel('tmp.xlsx')
      a  b
  0   1  2
  1  #2  3
  
  >>> pd.read_excel('tmp.xlsx', comment='#')
     a  b
  0  1  2
  """
  
  
  def register_writer(klass):
      """Adds engine to the excel writer registry. You must use this method to
      integrate with ``to_excel``. Also adds config options for any new
      ``supported_extensions`` defined on the writer."""
      if not compat.callable(klass):
          raise ValueError("Can only register callables as engines")
      engine_name = klass.engine
      _writers[engine_name] = klass
      for ext in klass.supported_extensions:
          if ext.startswith('.'):
              ext = ext[1:]
          if ext not in _writer_extensions:
              config.register_option("io.excel.{ext}.writer".format(ext=ext),
                                     engine_name, validator=str)
              _writer_extensions.append(ext)
  
  
  def _get_default_writer(ext):
      _default_writers = {'xlsx': 'openpyxl', 'xlsm': 'openpyxl', 'xls': 'xlwt'}
      try:
          import xlsxwriter  # noqa
          _default_writers['xlsx'] = 'xlsxwriter'
      except ImportError:
          pass
      return _default_writers[ext]
  
  
  def get_writer(engine_name):
      try:
          return _writers[engine_name]
      except KeyError:
          raise ValueError("No Excel writer '{engine}'"
                           .format(engine=engine_name))
  
  
  @Appender(_read_excel_doc)
  @deprecate_kwarg("parse_cols", "usecols")
  @deprecate_kwarg("skip_footer", "skipfooter")
  def read_excel(io,
                 sheet_name=0,
                 header=0,
                 names=None,
                 index_col=None,
                 usecols=None,
                 squeeze=False,
                 dtype=None,
                 engine=None,
                 converters=None,
                 true_values=None,
                 false_values=None,
                 skiprows=None,
                 nrows=None,
                 na_values=None,
                 parse_dates=False,
                 date_parser=None,
                 thousands=None,
                 comment=None,
                 skipfooter=0,
                 convert_float=True,
                 **kwds):
  
      if not isinstance(io, ExcelFile):
          io = ExcelFile(io, engine=engine)
  
      return io.parse(
          sheet_name=sheet_name,
          header=header,
          names=names,
          index_col=index_col,
          usecols=usecols,
          squeeze=squeeze,
          dtype=dtype,
          converters=converters,
          true_values=true_values,
          false_values=false_values,
          skiprows=skiprows,
          nrows=nrows,
          na_values=na_values,
          parse_dates=parse_dates,
          date_parser=date_parser,
          thousands=thousands,
          comment=comment,
          skipfooter=skipfooter,
          convert_float=convert_float,
          **kwds)
  
  
  class ExcelFile(object):
      """
      Class for parsing tabular excel sheets into DataFrame objects.
      Uses xlrd. See read_excel for more documentation
  
      Parameters
      ----------
      io : string, path object (pathlib.Path or py._path.local.LocalPath),
          file-like object or xlrd workbook
          If a string or path object, expected to be a path to xls or xlsx file
      engine: string, default None
          If io is not a buffer or path, this must be set to identify io.
          Acceptable values are None or xlrd
      """
  
      def __init__(self, io, **kwds):
  
          err_msg = "Install xlrd >= 0.9.0 for Excel support"
  
          try:
              import xlrd
          except ImportError:
              raise ImportError(err_msg)
          else:
              ver = tuple(map(int, xlrd.__VERSION__.split(".")[:2]))
              if ver < (0, 9):  # pragma: no cover
                  raise ImportError(err_msg +
                                    ". Current version " + xlrd.__VERSION__)
  
          # could be a str, ExcelFile, Book, etc.
          self.io = io
          # Always a string
          self._io = _stringify_path(io)
  
          engine = kwds.pop('engine', None)
  
          if engine is not None and engine != 'xlrd':
              raise ValueError("Unknown engine: {engine}".format(engine=engine))
  
          # If io is a url, want to keep the data as bytes so can't pass
          # to get_filepath_or_buffer()
          if _is_url(self._io):
              io = _urlopen(self._io)
          elif not isinstance(self.io, (ExcelFile, xlrd.Book)):
              io, _, _, _ = get_filepath_or_buffer(self._io)
  
          if engine == 'xlrd' and isinstance(io, xlrd.Book):
              self.book = io
          elif not isinstance(io, xlrd.Book) and hasattr(io, "read"):
              # N.B. xlrd.Book has a read attribute too
              if hasattr(io, 'seek'):
                  try:
                      # GH 19779
                      io.seek(0)
                  except UnsupportedOperation:
                      # HTTPResponse does not support seek()
                      # GH 20434
                      pass
  
              data = io.read()
              self.book = xlrd.open_workbook(file_contents=data)
          elif isinstance(self._io, compat.string_types):
              self.book = xlrd.open_workbook(self._io)
          else:
              raise ValueError('Must explicitly set engine if not passing in'
                               ' buffer or path for io.')
  
      def __fspath__(self):
          return self._io
  
      def parse(self,
                sheet_name=0,
                header=0,
                names=None,
                index_col=None,
                usecols=None,
                squeeze=False,
                converters=None,
                true_values=None,
                false_values=None,
                skiprows=None,
                nrows=None,
                na_values=None,
                parse_dates=False,
                date_parser=None,
                thousands=None,
                comment=None,
                skipfooter=0,
                convert_float=True,
                **kwds):
          """
          Parse specified sheet(s) into a DataFrame
  
          Equivalent to read_excel(ExcelFile, ...)  See the read_excel
          docstring for more info on accepted parameters
          """
  
          # Can't use _deprecate_kwarg since sheetname=None has a special meaning
          if is_integer(sheet_name) and sheet_name == 0 and 'sheetname' in kwds:
              warnings.warn("The `sheetname` keyword is deprecated, use "
                            "`sheet_name` instead", FutureWarning, stacklevel=2)
              sheet_name = kwds.pop("sheetname")
          elif 'sheetname' in kwds:
              raise TypeError("Cannot specify both `sheet_name` "
                              "and `sheetname`. Use just `sheet_name`")
  
          return self._parse_excel(sheet_name=sheet_name,
                                   header=header,
                                   names=names,
                                   index_col=index_col,
                                   usecols=usecols,
                                   squeeze=squeeze,
                                   converters=converters,
                                   true_values=true_values,
                                   false_values=false_values,
                                   skiprows=skiprows,
                                   nrows=nrows,
                                   na_values=na_values,
                                   parse_dates=parse_dates,
                                   date_parser=date_parser,
                                   thousands=thousands,
                                   comment=comment,
                                   skipfooter=skipfooter,
                                   convert_float=convert_float,
                                   **kwds)
  
      def _should_parse(self, i, usecols):
  
          def _range2cols(areas):
              """
              Convert comma separated list of column names and column ranges to a
              list of 0-based column indexes.
  
              >>> _range2cols('A:E')
              [0, 1, 2, 3, 4]
              >>> _range2cols('A,C,Z:AB')
              [0, 2, 25, 26, 27]
              """
              def _excel2num(x):
                  "Convert Excel column name like 'AB' to 0-based column index"
                  return reduce(lambda s, a: s * 26 + ord(a) - ord('A') + 1,
                                x.upper().strip(), 0) - 1
  
              cols = []
              for rng in areas.split(','):
                  if ':' in rng:
                      rng = rng.split(':')
                      cols += lrange(_excel2num(rng[0]), _excel2num(rng[1]) + 1)
                  else:
                      cols.append(_excel2num(rng))
              return cols
  
          if isinstance(usecols, int):
              return i <= usecols
          elif isinstance(usecols, compat.string_types):
              return i in _range2cols(usecols)
          else:
              return i in usecols
  
      def _parse_excel(self,
                       sheet_name=0,
                       header=0,
                       names=None,
                       index_col=None,
                       usecols=None,
                       squeeze=False,
                       dtype=None,
                       true_values=None,
                       false_values=None,
                       skiprows=None,
                       nrows=None,
                       na_values=None,
                       verbose=False,
                       parse_dates=False,
                       date_parser=None,
                       thousands=None,
                       comment=None,
                       skipfooter=0,
                       convert_float=True,
                       **kwds):
  
          _validate_header_arg(header)
  
          if 'chunksize' in kwds:
              raise NotImplementedError("chunksize keyword of read_excel "
                                        "is not implemented")
  
          if parse_dates is True and index_col is None:
              warn("The 'parse_dates=True' keyword of read_excel was provided"
                   " without an 'index_col' keyword value.")
  
          import xlrd
          from xlrd import (xldate, XL_CELL_DATE,
                            XL_CELL_ERROR, XL_CELL_BOOLEAN,
                            XL_CELL_NUMBER)
  
          epoch1904 = self.book.datemode
  
          def _parse_cell(cell_contents, cell_typ):
              """converts the contents of the cell into a pandas
                 appropriate object"""
  
              if cell_typ == XL_CELL_DATE:
  
                  if xlrd_0_9_3:
                      # Use the newer xlrd datetime handling.
                      try:
                          cell_contents = \
                              xldate.xldate_as_datetime(cell_contents,
                                                        epoch1904)
                      except OverflowError:
                          return cell_contents
                      # Excel doesn't distinguish between dates and time,
                      # so we treat dates on the epoch as times only.
                      # Also, Excel supports 1900 and 1904 epochs.
                      year = (cell_contents.timetuple())[0:3]
                      if ((not epoch1904 and year == (1899, 12, 31)) or
                              (epoch1904 and year == (1904, 1, 1))):
                          cell_contents = time(cell_contents.hour,
                                               cell_contents.minute,
                                               cell_contents.second,
                                               cell_contents.microsecond)
                  else:
                      # Use the xlrd <= 0.9.2 date handling.
                      try:
                          dt = xldate.xldate_as_tuple(cell_contents, epoch1904)
  
                      except xldate.XLDateTooLarge:
                          return cell_contents
  
                      if dt[0] < MINYEAR:
                          cell_contents = time(*dt[3:])
                      else:
                          cell_contents = datetime(*dt)
  
              elif cell_typ == XL_CELL_ERROR:
                  cell_contents = np.nan
              elif cell_typ == XL_CELL_BOOLEAN:
                  cell_contents = bool(cell_contents)
              elif convert_float and cell_typ == XL_CELL_NUMBER:
                  # GH5394 - Excel 'numbers' are always floats
                  # it's a minimal perf hit and less surprising
                  val = int(cell_contents)
                  if val == cell_contents:
                      cell_contents = val
              return cell_contents
  
          # xlrd >= 0.9.3 can return datetime objects directly.
          if LooseVersion(xlrd.__VERSION__) >= LooseVersion("0.9.3"):
              xlrd_0_9_3 = True
          else:
              xlrd_0_9_3 = False
  
          ret_dict = False
  
          # Keep sheetname to maintain backwards compatibility.
          if isinstance(sheet_name, list):
              sheets = sheet_name
              ret_dict = True
          elif sheet_name is None:
              sheets = self.sheet_names
              ret_dict = True
          else:
              sheets = [sheet_name]
  
          # handle same-type duplicates.
          sheets = list(OrderedDict.fromkeys(sheets).keys())
  
          output = OrderedDict()
  
          for asheetname in sheets:
              if verbose:
                  print("Reading sheet {sheet}".format(sheet=asheetname))
  
              if isinstance(asheetname, compat.string_types):
                  sheet = self.book.sheet_by_name(asheetname)
              else:  # assume an integer if not a string
                  sheet = self.book.sheet_by_index(asheetname)
  
              data = []
              should_parse = {}
  
              for i in range(sheet.nrows):
                  row = []
                  for j, (value, typ) in enumerate(zip(sheet.row_values(i),
                                                       sheet.row_types(i))):
                      if usecols is not None and j not in should_parse:
                          should_parse[j] = self._should_parse(j, usecols)
  
                      if usecols is None or should_parse[j]:
                          row.append(_parse_cell(value, typ))
                  data.append(row)
  
              if sheet.nrows == 0:
                  output[asheetname] = DataFrame()
                  continue
  
              if is_list_like(header) and len(header) == 1:
                  header = header[0]
  
              # forward fill and pull out names for MultiIndex column
              header_names = None
              if header is not None:
                  if is_list_like(header):
                      header_names = []
                      control_row = [True for x in data[0]]
                      for row in header:
                          if is_integer(skiprows):
                              row += skiprows
  
                          data[row], control_row = _fill_mi_header(
                              data[row], control_row)
                          header_name, data[row] = _pop_header_name(
                              data[row], index_col)
                          header_names.append(header_name)
                  else:
                      data[header] = _trim_excel_header(data[header])
  
              if is_list_like(index_col):
                  # forward fill values for MultiIndex index
                  if not is_list_like(header):
                      offset = 1 + header
                  else:
                      offset = 1 + max(header)
  
                  for col in index_col:
                      last = data[offset][col]
                      for row in range(offset + 1, len(data)):
                          if data[row][col] == '' or data[row][col] is None:
                              data[row][col] = last
                          else:
                              last = data[row][col]
  
              has_index_names = is_list_like(header) and len(header) > 1
  
              # GH 12292 : error when read one empty column from excel file
              try:
                  parser = TextParser(data,
                                      header=header,
                                      index_col=index_col,
                                      has_index_names=has_index_names,
                                      squeeze=squeeze,
                                      dtype=dtype,
                                      true_values=true_values,
                                      false_values=false_values,
                                      skiprows=skiprows,
                                      nrows=nrows,
                                      na_values=na_values,
                                      parse_dates=parse_dates,
                                      date_parser=date_parser,
                                      thousands=thousands,
                                      comment=comment,
                                      skipfooter=skipfooter,
                                      **kwds)
  
                  output[asheetname] = parser.read(nrows=nrows)
                  if names is not None:
                      output[asheetname].columns = names
                  if not squeeze or isinstance(output[asheetname], DataFrame):
                      output[asheetname].columns = output[
                          asheetname].columns.set_names(header_names)
              except EmptyDataError:
                  # No Data, return an empty DataFrame
                  output[asheetname] = DataFrame()
  
          if ret_dict:
              return output
          else:
              return output[asheetname]
  
      @property
      def sheet_names(self):
          return self.book.sheet_names()
  
      def close(self):
          """close io if necessary"""
          if hasattr(self.io, 'close'):
              self.io.close()
  
      def __enter__(self):
          return self
  
      def __exit__(self, exc_type, exc_value, traceback):
          self.close()
  
  
  def _validate_freeze_panes(freeze_panes):
      if freeze_panes is not None:
          if (
              len(freeze_panes) == 2 and
              all(isinstance(item, int) for item in freeze_panes)
          ):
              return True
  
          raise ValueError("freeze_panes must be of form (row, column)"
                           " where row and column are integers")
  
      # freeze_panes wasn't specified, return False so it won't be applied
      # to output sheet
      return False
  
  
  def _trim_excel_header(row):
      # trim header row so auto-index inference works
      # xlrd uses '' , openpyxl None
      while len(row) > 0 and (row[0] == '' or row[0] is None):
          row = row[1:]
      return row
  
  
  def _fill_mi_header(row, control_row):
      """Forward fills blank entries in row, but only inside the same parent index
  
      Used for creating headers in Multiindex.
      Parameters
      ----------
      row : list
          List of items in a single row.
      control_row : list of boolean
          Helps to determine if particular column is in same parent index as the
          previous value. Used to stop propagation of empty cells between
          different indexes.
  
      Returns
      ----------
      Returns changed row and control_row
      """
      last = row[0]
      for i in range(1, len(row)):
          if not control_row[i]:
              last = row[i]
  
          if row[i] == '' or row[i] is None:
              row[i] = last
          else:
              control_row[i] = False
              last = row[i]
  
      return row, control_row
  
  # fill blank if index_col not None
  
  
  def _pop_header_name(row, index_col):
      """ (header, new_data) for header rows in MultiIndex parsing"""
      none_fill = lambda x: None if x == '' else x
  
      if index_col is None:
          # no index col specified, trim data for inference path
          return none_fill(row[0]), row[1:]
      else:
          # pop out header name and fill w/ blank
          i = index_col if not is_list_like(index_col) else max(index_col)
          return none_fill(row[i]), row[:i] + [''] + row[i + 1:]
  
  
  @add_metaclass(abc.ABCMeta)
  class ExcelWriter(object):
      """
      Class for writing DataFrame objects into excel sheets, default is to use
      xlwt for xls, openpyxl for xlsx.  See DataFrame.to_excel for typical usage.
  
      Parameters
      ----------
      path : string
          Path to xls or xlsx file.
      engine : string (optional)
          Engine to use for writing. If None, defaults to
          ``io.excel.<extension>.writer``.  NOTE: can only be passed as a keyword
          argument.
      date_format : string, default None
          Format string for dates written into Excel files (e.g. 'YYYY-MM-DD')
      datetime_format : string, default None
          Format string for datetime objects written into Excel files
          (e.g. 'YYYY-MM-DD HH:MM:SS')
  
      Notes
      -----
      For compatibility with CSV writers, ExcelWriter serializes lists
      and dicts to strings before writing.
      """
      # Defining an ExcelWriter implementation (see abstract methods for more...)
  
      # - Mandatory
      #   - ``write_cells(self, cells, sheet_name=None, startrow=0, startcol=0)``
      #     --> called to write additional DataFrames to disk
      #   - ``supported_extensions`` (tuple of supported extensions), used to
      #      check that engine supports the given extension.
      #   - ``engine`` - string that gives the engine name. Necessary to
      #     instantiate class directly and bypass ``ExcelWriterMeta`` engine
      #     lookup.
      #   - ``save(self)`` --> called to save file to disk
      # - Mostly mandatory (i.e. should at least exist)
      #   - book, cur_sheet, path
  
      # - Optional:
      #   - ``__init__(self, path, engine=None, **kwargs)`` --> always called
      #     with path as first argument.
  
      # You also need to register the class with ``register_writer()``.
      # Technically, ExcelWriter implementations don't need to subclass
      # ExcelWriter.
      def __new__(cls, path, engine=None, **kwargs):
          # only switch class if generic(ExcelWriter)
  
          if issubclass(cls, ExcelWriter):
              if engine is None or (isinstance(engine, string_types) and
                                    engine == 'auto'):
                  if isinstance(path, string_types):
                      ext = os.path.splitext(path)[-1][1:]
                  else:
                      ext = 'xlsx'
  
                  try:
                      engine = config.get_option('io.excel.{ext}.writer'
                                                 .format(ext=ext))
                      if engine == 'auto':
                          engine = _get_default_writer(ext)
                  except KeyError:
                      error = ValueError("No engine for filetype: '{ext}'"
                                         .format(ext=ext))
                      raise error
              cls = get_writer(engine)
  
          return object.__new__(cls)
  
      # declare external properties you can count on
      book = None
      curr_sheet = None
      path = None
  
      @abc.abstractproperty
      def supported_extensions(self):
          "extensions that writer engine supports"
          pass
  
      @abc.abstractproperty
      def engine(self):
          "name of engine"
          pass
  
      @abc.abstractmethod
      def write_cells(self, cells, sheet_name=None, startrow=0, startcol=0,
                      freeze_panes=None):
          """
          Write given formatted cells into Excel an excel sheet
  
          Parameters
          ----------
          cells : generator
              cell of formatted data to save to Excel sheet
          sheet_name : string, default None
              Name of Excel sheet, if None, then use self.cur_sheet
          startrow: upper left cell row to dump data frame
          startcol: upper left cell column to dump data frame
          freeze_panes: integer tuple of length 2
              contains the bottom-most row and right-most column to freeze
          """
          pass
  
      @abc.abstractmethod
      def save(self):
          """
          Save workbook to disk.
          """
          pass
  
      def __init__(self, path, engine=None,
                   date_format=None, datetime_format=None, **engine_kwargs):
          # validate that this engine can handle the extension
          if isinstance(path, string_types):
              ext = os.path.splitext(path)[-1]
          else:
              ext = 'xls' if engine == 'xlwt' else 'xlsx'
  
          self.check_extension(ext)
  
          self.path = path
          self.sheets = {}
          self.cur_sheet = None
  
          if date_format is None:
              self.date_format = 'YYYY-MM-DD'
          else:
              self.date_format = date_format
          if datetime_format is None:
              self.datetime_format = 'YYYY-MM-DD HH:MM:SS'
          else:
              self.datetime_format = datetime_format
  
      def __fspath__(self):
          return _stringify_path(self.path)
  
      def _get_sheet_name(self, sheet_name):
          if sheet_name is None:
              sheet_name = self.cur_sheet
          if sheet_name is None:  # pragma: no cover
              raise ValueError('Must pass explicit sheet_name or set '
                               'cur_sheet property')
          return sheet_name
  
      def _value_with_fmt(self, val):
          """Convert numpy types to Python types for the Excel writers.
  
          Parameters
          ----------
          val : object
              Value to be written into cells
  
          Returns
          -------
          Tuple with the first element being the converted value and the second
              being an optional format
          """
          fmt = None
  
          if is_integer(val):
              val = int(val)
          elif is_float(val):
              val = float(val)
          elif is_bool(val):
              val = bool(val)
          elif isinstance(val, datetime):
              fmt = self.datetime_format
          elif isinstance(val, date):
              fmt = self.date_format
          elif isinstance(val, timedelta):
              val = val.total_seconds() / float(86400)
              fmt = '0'
          else:
              val = compat.to_str(val)
  
          return val, fmt
  
      @classmethod
      def check_extension(cls, ext):
          """checks that path's extension against the Writer's supported
          extensions.  If it isn't supported, raises UnsupportedFiletypeError."""
          if ext.startswith('.'):
              ext = ext[1:]
          if not any(ext in extension for extension in cls.supported_extensions):
              msg = (u("Invalid extension for engine '{engine}': '{ext}'")
                     .format(engine=pprint_thing(cls.engine),
                             ext=pprint_thing(ext)))
              raise ValueError(msg)
          else:
              return True
  
      # Allow use as a contextmanager
      def __enter__(self):
          return self
  
      def __exit__(self, exc_type, exc_value, traceback):
          self.close()
  
      def close(self):
          """synonym for save, to make it more file-like"""
          return self.save()
  
  
  class _OpenpyxlWriter(ExcelWriter):
      engine = 'openpyxl'
      supported_extensions = ('.xlsx', '.xlsm')
  
      def __init__(self, path, engine=None, **engine_kwargs):
          # Use the openpyxl module as the Excel writer.
          from openpyxl.workbook import Workbook
  
          super(_OpenpyxlWriter, self).__init__(path, **engine_kwargs)
  
          # Create workbook object with default optimized_write=True.
          self.book = Workbook()
  
          # Openpyxl 1.6.1 adds a dummy sheet. We remove it.
          if self.book.worksheets:
              try:
                  self.book.remove(self.book.worksheets[0])
              except AttributeError:
  
                  # compat
                  self.book.remove_sheet(self.book.worksheets[0])
  
      def save(self):
          """
          Save workbook to disk.
          """
          return self.book.save(self.path)
  
      @classmethod
      def _convert_to_style(cls, style_dict):
          """
          converts a style_dict to an openpyxl style object
          Parameters
          ----------
          style_dict: style dictionary to convert
          """
  
          from openpyxl.style import Style
          xls_style = Style()
          for key, value in style_dict.items():
              for nk, nv in value.items():
                  if key == "borders":
                      (xls_style.borders.__getattribute__(nk)
                       .__setattr__('border_style', nv))
                  else:
                      xls_style.__getattribute__(key).__setattr__(nk, nv)
  
          return xls_style
  
      @classmethod
      def _convert_to_style_kwargs(cls, style_dict):
          """
          Convert a style_dict to a set of kwargs suitable for initializing
          or updating-on-copy an openpyxl v2 style object
          Parameters
          ----------
          style_dict : dict
              A dict with zero or more of the following keys (or their synonyms).
                  'font'
                  'fill'
                  'border' ('borders')
                  'alignment'
                  'number_format'
                  'protection'
          Returns
          -------
          style_kwargs : dict
              A dict with the same, normalized keys as ``style_dict`` but each
              value has been replaced with a native openpyxl style object of the
              appropriate class.
          """
  
          _style_key_map = {
              'borders': 'border',
          }
  
          style_kwargs = {}
          for k, v in style_dict.items():
              if k in _style_key_map:
                  k = _style_key_map[k]
              _conv_to_x = getattr(cls, '_convert_to_{k}'.format(k=k),
                                   lambda x: None)
              new_v = _conv_to_x(v)
              if new_v:
                  style_kwargs[k] = new_v
  
          return style_kwargs
  
      @classmethod
      def _convert_to_color(cls, color_spec):
          """
          Convert ``color_spec`` to an openpyxl v2 Color object
          Parameters
          ----------
          color_spec : str, dict
              A 32-bit ARGB hex string, or a dict with zero or more of the
              following keys.
                  'rgb'
                  'indexed'
                  'auto'
                  'theme'
                  'tint'
                  'index'
                  'type'
          Returns
          -------
          color : openpyxl.styles.Color
          """
  
          from openpyxl.styles import Color
  
          if isinstance(color_spec, str):
              return Color(color_spec)
          else:
              return Color(**color_spec)
  
      @classmethod
      def _convert_to_font(cls, font_dict):
          """
          Convert ``font_dict`` to an openpyxl v2 Font object
          Parameters
          ----------
          font_dict : dict
              A dict with zero or more of the following keys (or their synonyms).
                  'name'
                  'size' ('sz')
                  'bold' ('b')
                  'italic' ('i')
                  'underline' ('u')
                  'strikethrough' ('strike')
                  'color'
                  'vertAlign' ('vertalign')
                  'charset'
                  'scheme'
                  'family'
                  'outline'
                  'shadow'
                  'condense'
          Returns
          -------
          font : openpyxl.styles.Font
          """
  
          from openpyxl.styles import Font
  
          _font_key_map = {
              'sz': 'size',
              'b': 'bold',
              'i': 'italic',
              'u': 'underline',
              'strike': 'strikethrough',
              'vertalign': 'vertAlign',
          }
  
          font_kwargs = {}
          for k, v in font_dict.items():
              if k in _font_key_map:
                  k = _font_key_map[k]
              if k == 'color':
                  v = cls._convert_to_color(v)
              font_kwargs[k] = v
  
          return Font(**font_kwargs)
  
      @classmethod
      def _convert_to_stop(cls, stop_seq):
          """
          Convert ``stop_seq`` to a list of openpyxl v2 Color objects,
          suitable for initializing the ``GradientFill`` ``stop`` parameter.
          Parameters
          ----------
          stop_seq : iterable
              An iterable that yields objects suitable for consumption by
              ``_convert_to_color``.
          Returns
          -------
          stop : list of openpyxl.styles.Color
          """
  
          return map(cls._convert_to_color, stop_seq)
  
      @classmethod
      def _convert_to_fill(cls, fill_dict):
          """
          Convert ``fill_dict`` to an openpyxl v2 Fill object
          Parameters
          ----------
          fill_dict : dict
              A dict with one or more of the following keys (or their synonyms),
                  'fill_type' ('patternType', 'patterntype')
                  'start_color' ('fgColor', 'fgcolor')
                  'end_color' ('bgColor', 'bgcolor')
              or one or more of the following keys (or their synonyms).
                  'type' ('fill_type')
                  'degree'
                  'left'
                  'right'
                  'top'
                  'bottom'
                  'stop'
          Returns
          -------
          fill : openpyxl.styles.Fill
          """
  
          from openpyxl.styles import PatternFill, GradientFill
  
          _pattern_fill_key_map = {
              'patternType': 'fill_type',
              'patterntype': 'fill_type',
              'fgColor': 'start_color',
              'fgcolor': 'start_color',
              'bgColor': 'end_color',
              'bgcolor': 'end_color',
          }
  
          _gradient_fill_key_map = {
              'fill_type': 'type',
          }
  
          pfill_kwargs = {}
          gfill_kwargs = {}
          for k, v in fill_dict.items():
              pk = gk = None
              if k in _pattern_fill_key_map:
                  pk = _pattern_fill_key_map[k]
              if k in _gradient_fill_key_map:
                  gk = _gradient_fill_key_map[k]
              if pk in ['start_color', 'end_color']:
                  v = cls._convert_to_color(v)
              if gk == 'stop':
                  v = cls._convert_to_stop(v)
              if pk:
                  pfill_kwargs[pk] = v
              elif gk:
                  gfill_kwargs[gk] = v
              else:
                  pfill_kwargs[k] = v
                  gfill_kwargs[k] = v
  
          try:
              return PatternFill(**pfill_kwargs)
          except TypeError:
              return GradientFill(**gfill_kwargs)
  
      @classmethod
      def _convert_to_side(cls, side_spec):
          """
          Convert ``side_spec`` to an openpyxl v2 Side object
          Parameters
          ----------
          side_spec : str, dict
              A string specifying the border style, or a dict with zero or more
              of the following keys (or their synonyms).
                  'style' ('border_style')
                  'color'
          Returns
          -------
          side : openpyxl.styles.Side
          """
  
          from openpyxl.styles import Side
  
          _side_key_map = {
              'border_style': 'style',
          }
  
          if isinstance(side_spec, str):
              return Side(style=side_spec)
  
          side_kwargs = {}
          for k, v in side_spec.items():
              if k in _side_key_map:
                  k = _side_key_map[k]
              if k == 'color':
                  v = cls._convert_to_color(v)
              side_kwargs[k] = v
  
          return Side(**side_kwargs)
  
      @classmethod
      def _convert_to_border(cls, border_dict):
          """
          Convert ``border_dict`` to an openpyxl v2 Border object
          Parameters
          ----------
          border_dict : dict
              A dict with zero or more of the following keys (or their synonyms).
                  'left'
                  'right'
                  'top'
                  'bottom'
                  'diagonal'
                  'diagonal_direction'
                  'vertical'
                  'horizontal'
                  'diagonalUp' ('diagonalup')
                  'diagonalDown' ('diagonaldown')
                  'outline'
          Returns
          -------
          border : openpyxl.styles.Border
          """
  
          from openpyxl.styles import Border
  
          _border_key_map = {
              'diagonalup': 'diagonalUp',
              'diagonaldown': 'diagonalDown',
          }
  
          border_kwargs = {}
          for k, v in border_dict.items():
              if k in _border_key_map:
                  k = _border_key_map[k]
              if k == 'color':
                  v = cls._convert_to_color(v)
              if k in ['left', 'right', 'top', 'bottom', 'diagonal']:
                  v = cls._convert_to_side(v)
              border_kwargs[k] = v
  
          return Border(**border_kwargs)
  
      @classmethod
      def _convert_to_alignment(cls, alignment_dict):
          """
          Convert ``alignment_dict`` to an openpyxl v2 Alignment object
          Parameters
          ----------
          alignment_dict : dict
              A dict with zero or more of the following keys (or their synonyms).
                  'horizontal'
                  'vertical'
                  'text_rotation'
                  'wrap_text'
                  'shrink_to_fit'
                  'indent'
          Returns
          -------
          alignment : openpyxl.styles.Alignment
          """
  
          from openpyxl.styles import Alignment
  
          return Alignment(**alignment_dict)
  
      @classmethod
      def _convert_to_number_format(cls, number_format_dict):
          """
          Convert ``number_format_dict`` to an openpyxl v2.1.0 number format
          initializer.
          Parameters
          ----------
          number_format_dict : dict
              A dict with zero or more of the following keys.
                  'format_code' : str
          Returns
          -------
          number_format : str
          """
          return number_format_dict['format_code']
  
      @classmethod
      def _convert_to_protection(cls, protection_dict):
          """
          Convert ``protection_dict`` to an openpyxl v2 Protection object.
          Parameters
          ----------
          protection_dict : dict
              A dict with zero or more of the following keys.
                  'locked'
                  'hidden'
          Returns
          -------
          """
  
          from openpyxl.styles import Protection
  
          return Protection(**protection_dict)
  
      def write_cells(self, cells, sheet_name=None, startrow=0, startcol=0,
                      freeze_panes=None):
          # Write the frame cells using openpyxl.
          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
  
          if _validate_freeze_panes(freeze_panes):
              wks.freeze_panes = wks.cell(row=freeze_panes[0] + 1,
                                          column=freeze_panes[1] + 1)
  
          for cell in cells:
              xcell = wks.cell(
                  row=startrow + cell.row + 1,
                  column=startcol + cell.col + 1
              )
              xcell.value, fmt = self._value_with_fmt(cell.val)
              if fmt:
                  xcell.number_format = fmt
  
              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.mergestart + 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(_OpenpyxlWriter)
  
  
  class _XlwtWriter(ExcelWriter):
      engine = 'xlwt'
      supported_extensions = ('.xls',)
  
      def __init__(self, path, engine=None, encoding=None, **engine_kwargs):
          # Use the xlwt module as the Excel writer.
          import xlwt
          engine_kwargs['engine'] = engine
          super(_XlwtWriter, self).__init__(path, **engine_kwargs)
  
          if encoding is None:
              encoding = 'ascii'
          self.book = xlwt.Workbook(encoding=encoding)
          self.fm_datetime = xlwt.easyxf(num_format_str=self.datetime_format)
          self.fm_date = xlwt.easyxf(num_format_str=self.date_format)
  
      def save(self):
          """
          Save workbook to disk.
          """
          return self.book.save(self.path)
  
      def write_cells(self, cells, sheet_name=None, startrow=0, startcol=0,
                      freeze_panes=None):
          # Write the frame cells using xlwt.
  
          sheet_name = self._get_sheet_name(sheet_name)
  
          if sheet_name in self.sheets:
              wks = self.sheets[sheet_name]
          else:
              wks = self.book.add_sheet(sheet_name)
              self.sheets[sheet_name] = wks
  
          if _validate_freeze_panes(freeze_panes):
              wks.set_panes_frozen(True)
              wks.set_horz_split_pos(freeze_panes[0])
              wks.set_vert_split_pos(freeze_panes[1])
  
          style_dict = {}
  
          for cell in cells:
              val, fmt = self._value_with_fmt(cell.val)
  
              stylekey = json.dumps(cell.style)
              if fmt:
                  stylekey += fmt
  
              if stylekey in style_dict:
                  style = style_dict[stylekey]
              else:
                  style = self._convert_to_style(cell.style, fmt)
                  style_dict[stylekey] = style
  
              if cell.mergestart is not None and cell.mergeend is not None:
                  wks.write_merge(startrow + cell.row,
                                  startrow + cell.mergestart,
                                  startcol + cell.col,
                                  startcol + cell.mergeend,
                                  val, style)
              else:
                  wks.write(startrow + cell.row,
                            startcol + cell.col,
                            val, style)
  
      @classmethod
      def _style_to_xlwt(cls, item, firstlevel=True, field_sep=',',
                         line_sep=';'):
          """helper which recursively generate an xlwt easy style string
          for example:
  
              hstyle = {"font": {"bold": True},
              "border": {"top": "thin",
                      "right": "thin",
                      "bottom": "thin",
                      "left": "thin"},
              "align": {"horiz": "center"}}
              will be converted to
              font: bold on; \
                      border: top thin, right thin, bottom thin, left thin; \
                      align: horiz center;
          """
          if hasattr(item, 'items'):
              if firstlevel:
                  it = ["{key}: {val}"
                        .format(key=key, val=cls._style_to_xlwt(value, False))
                        for key, value in item.items()]
                  out = "{sep} ".format(sep=(line_sep).join(it))
                  return out
              else:
                  it = ["{key} {val}"
                        .format(key=key, val=cls._style_to_xlwt(value, False))
                        for key, value in item.items()]
                  out = "{sep} ".format(sep=(field_sep).join(it))
                  return out
          else:
              item = "{item}".format(item=item)
              item = item.replace("True", "on")
              item = item.replace("False", "off")
              return item
  
      @classmethod
      def _convert_to_style(cls, style_dict, num_format_str=None):
          """
          converts a style_dict to an xlwt style object
          Parameters
          ----------
          style_dict: style dictionary to convert
          num_format_str: optional number format string
          """
          import xlwt
  
          if style_dict:
              xlwt_stylestr = cls._style_to_xlwt(style_dict)
              style = xlwt.easyxf(xlwt_stylestr, field_sep=',', line_sep=';')
          else:
              style = xlwt.XFStyle()
          if num_format_str is not None:
              style.num_format_str = num_format_str
  
          return style
  
  
  register_writer(_XlwtWriter)
  
  
  class _XlsxStyler(object):
      # Map from openpyxl-oriented styles to flatter xlsxwriter representation
      # Ordering necessary for both determinism and because some are keyed by
      # prefixes of others.
      STYLE_MAPPING = {
          'font': [
              (('name',), 'font_name'),
              (('sz',), 'font_size'),
              (('size',), 'font_size'),
              (('color', 'rgb',), 'font_color'),
              (('color',), 'font_color'),
              (('b',), 'bold'),
              (('bold',), 'bold'),
              (('i',), 'italic'),
              (('italic',), 'italic'),
              (('u',), 'underline'),
              (('underline',), 'underline'),
              (('strike',), 'font_strikeout'),
              (('vertAlign',), 'font_script'),
              (('vertalign',), 'font_script'),
          ],
          'number_format': [
              (('format_code',), 'num_format'),
              ((), 'num_format',),
          ],
          'protection': [
              (('locked',), 'locked'),
              (('hidden',), 'hidden'),
          ],
          'alignment': [
              (('horizontal',), 'align'),
              (('vertical',), 'valign'),
              (('text_rotation',), 'rotation'),
              (('wrap_text',), 'text_wrap'),
              (('indent',), 'indent'),
              (('shrink_to_fit',), 'shrink'),
          ],
          'fill': [
              (('patternType',), 'pattern'),
              (('patterntype',), 'pattern'),
              (('fill_type',), 'pattern'),
              (('start_color', 'rgb',), 'fg_color'),
              (('fgColor', 'rgb',), 'fg_color'),
              (('fgcolor', 'rgb',), 'fg_color'),
              (('start_color',), 'fg_color'),
              (('fgColor',), 'fg_color'),
              (('fgcolor',), 'fg_color'),
              (('end_color', 'rgb',), 'bg_color'),
              (('bgColor', 'rgb',), 'bg_color'),
              (('bgcolor', 'rgb',), 'bg_color'),
              (('end_color',), 'bg_color'),
              (('bgColor',), 'bg_color'),
              (('bgcolor',), 'bg_color'),
          ],
          'border': [
              (('color', 'rgb',), 'border_color'),
              (('color',), 'border_color'),
              (('style',), 'border'),
              (('top', 'color', 'rgb',), 'top_color'),
              (('top', 'color',), 'top_color'),
              (('top', 'style',), 'top'),
              (('top',), 'top'),
              (('right', 'color', 'rgb',), 'right_color'),
              (('right', 'color',), 'right_color'),
              (('right', 'style',), 'right'),
              (('right',), 'right'),
              (('bottom', 'color', 'rgb',), 'bottom_color'),
              (('bottom', 'color',), 'bottom_color'),
              (('bottom', 'style',), 'bottom'),
              (('bottom',), 'bottom'),
              (('left', 'color', 'rgb',), 'left_color'),
              (('left', 'color',), 'left_color'),
              (('left', 'style',), 'left'),
              (('left',), 'left'),
          ],
      }
  
      @classmethod
      def convert(cls, style_dict, num_format_str=None):
          """
          converts a style_dict to an xlsxwriter format dict
  
          Parameters
          ----------
          style_dict: style dictionary to convert
          num_format_str: optional number format string
          """
  
          # Create a XlsxWriter format object.
          props = {}
  
          if num_format_str is not None:
              props['num_format'] = num_format_str
  
          if style_dict is None:
              return props
  
          if 'borders' in style_dict:
              style_dict = style_dict.copy()
              style_dict['border'] = style_dict.pop('borders')
  
          for style_group_key, style_group in style_dict.items():
              for src, dst in cls.STYLE_MAPPING.get(style_group_key, []):
                  # src is a sequence of keys into a nested dict
                  # dst is a flat key
                  if dst in props:
                      continue
                  v = style_group
                  for k in src:
                      try:
                          v = v[k]
                      except (KeyError, TypeError):
                          break
                  else:
                      props[dst] = v
  
          if isinstance(props.get('pattern'), string_types):
              # TODO: support other fill patterns
              props['pattern'] = 0 if props['pattern'] == 'none' else 1
  
          for k in ['border', 'top', 'right', 'bottom', 'left']:
              if isinstance(props.get(k), string_types):
                  try:
                      props[k] = ['none', 'thin', 'medium', 'dashed', 'dotted',
                                  'thick', 'double', 'hair', 'mediumDashed',
                                  'dashDot', 'mediumDashDot', 'dashDotDot',
                                  'mediumDashDotDot', 'slantDashDot'].\
                          index(props[k])
                  except ValueError:
                      props[k] = 2
  
          if isinstance(props.get('font_script'), string_types):
              props['font_script'] = ['baseline', 'superscript', 'subscript'].\
                  index(props['font_script'])
  
          if isinstance(props.get('underline'), string_types):
              props['underline'] = {'none': 0, 'single': 1, 'double': 2,
                                    'singleAccounting': 33,
                                    'doubleAccounting': 34}[props['underline']]
  
          return props
  
  
  class _XlsxWriter(ExcelWriter):
      engine = 'xlsxwriter'
      supported_extensions = ('.xlsx',)
  
      def __init__(self, path, engine=None,
                   date_format=None, datetime_format=None, **engine_kwargs):
          # Use the xlsxwriter module as the Excel writer.
          import xlsxwriter
  
          super(_XlsxWriter, self).__init__(path, engine=engine,
                                            date_format=date_format,
                                            datetime_format=datetime_format,
                                            **engine_kwargs)
  
          self.book = xlsxwriter.Workbook(path, **engine_kwargs)
  
      def save(self):
          """
          Save workbook to disk.
          """
  
          return self.book.close()
  
      def write_cells(self, cells, sheet_name=None, startrow=0, startcol=0,
                      freeze_panes=None):
          # Write the frame cells using xlsxwriter.
          sheet_name = self._get_sheet_name(sheet_name)
  
          if sheet_name in self.sheets:
              wks = self.sheets[sheet_name]
          else:
              wks = self.book.add_worksheet(sheet_name)
              self.sheets[sheet_name] = wks
  
          style_dict = {'null': None}
  
          if _validate_freeze_panes(freeze_panes):
              wks.freeze_panes(*(freeze_panes))
  
          for cell in cells:
              val, fmt = self._value_with_fmt(cell.val)
  
              stylekey = json.dumps(cell.style)
              if fmt:
                  stylekey += fmt
  
              if stylekey in style_dict:
                  style = style_dict[stylekey]
              else:
                  style = self.book.add_format(
                      _XlsxStyler.convert(cell.style, fmt))
                  style_dict[stylekey] = style
  
              if cell.mergestart is not None and cell.mergeend is not None:
                  wks.merge_range(startrow + cell.row,
                                  startcol + cell.col,
                                  startrow + cell.mergestart,
                                  startcol + cell.mergeend,
                                  cell.val, style)
              else:
                  wks.write(startrow + cell.row,
                            startcol + cell.col,
                            val, style)
  
  
  register_writer(_XlsxWriter)
  