def test_read_row(datadir, DummyWorkbook, ReadOnlyWorksheet):
datadir.join("reader").chdir()
src = b"""
<sheetData xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" >
<row r="1" spans="4:27">
<c r="D1">
<v>1</v>
</c>
<c r="K1">
<v>0.01</v>
</c>
<c r="AA1">
<v>100</v>
</c>
</row>
</sheetData>
"""
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "", "", [])
xml = fromstring(src)
row = tuple(ws._get_row(xml, 11, 11))
values = [c.value for c in row]
assert values == [0.01]
row = tuple(ws._get_row(xml, 1, 11))
values = [c.value for c in row]
assert values == [
None, None, None, 1, None, None, None, None, None, None, 0.01
]
def test_read_without_coordinates(DummyWorkbook, ReadOnlyWorksheet):
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "", "", ["Whatever"] * 10)
src = """
<row xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
<c t="s">
<v>2</v>
</c>
<c t="s">
<v>4</v>
</c>
<c t="s">
<v>3</v>
</c>
<c t="s">
<v>6</v>
</c>
<c t="s">
<v>9</v>
</c>
</row>
"""
element = fromstring(src)
row = tuple(ws._get_row(element, min_col=1, max_col=None, row_counter=1))
assert row[0].value == "Whatever"
def test_get_empty_cells_nonempty_row(datadir, DummyWorkbook,
ReadOnlyWorksheet):
"""Fix for issue #908.
Get row slice which only contains empty cells in a row containing non-empty
cells earlier in the row.
"""
datadir.join("reader").chdir()
src = b"""
<sheetData xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" >
<row r="1" spans="4:27">
<c r="A4">
<v>1</v>
</c>
</row>
</sheetData>
"""
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "", "", [])
xml = fromstring(src)
min_col = 8
max_col = 9
row = tuple(ws._get_row(xml, min_col=min_col, max_col=max_col))
assert len(row) == 2
assert all(cell is EMPTY_CELL for cell in row)
values = [cell.value for cell in row]
assert values == [None, None]
def test_force_dimension(datadir, DummyWorkbook, ReadOnlyWorksheet):
datadir.join("reader").chdir()
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "",
"sheet2_no_dimension.xml", [])
dims = ws.calculate_dimension(True)
assert dims == "A1:AA30"
def test_iter_rows_empty_rows(datadir, DummyWorkbook, ReadOnlyWorksheet):
datadir.join("reader").chdir()
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "", "empty_rows.xml", [])
rows = tuple(ws.iter_rows(min_row=1, min_col=1, max_row=10, max_col=10))
assert len(rows) == 7
assert rows[0][0].value is None
assert rows[6][6].value is None
def test_read_empty_row(datadir, DummyWorkbook, ReadOnlyWorksheet):
datadir.join("reader").chdir()
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "", "", [])
src = """
<row r="2" xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" />
"""
element = fromstring(src)
row = ws._get_row(element, max_col=10)
row = tuple(row)
assert len(row) == 10
def test_read_cell_from_empty_row(DummyWorkbook, ReadOnlyWorksheet, row,
column):
src = BytesIO()
src.write(
b"""<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
<sheetData>
<row r="2" />
<row r="4" />
</sheetData>
</worksheet>
""")
src.seek(0)
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "", "", [])
ws._xml = src
cell = ws._get_cell(row, column)
assert cell is EMPTY_CELL
def test_read_hyperlinks_read_only(datadir, Workbook, ReadOnlyWorksheet):
datadir.join("reader").chdir()
filename = 'bug328_hyperlinks.xml'
wb = Workbook()
wb._read_only = True
wb._data_only = True
ws = ReadOnlyWorksheet(wb, "Sheet", "", filename, ['SOMETEXT'])
assert ws['F2'].value is None
def test_read_with_missing_cells(datadir, DummyWorkbook, ReadOnlyWorksheet):
datadir.join("reader").chdir()
filename = "bug393-worksheet.xml"
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "", filename, [])
rows = tuple(ws.rows)
row = rows[1] # second row
values = [c.value for c in row]
assert values == [None, None, 1, 2, 3]
row = rows[3] # fourth row
values = [c.value for c in row]
assert values == [1, 2, None, None, 3]
def test_ctor(datadir, DummyWorkbook, ReadOnlyWorksheet, filename, expected):
datadir.join("reader").chdir()
with open(filename) as src:
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "", src, [])
assert (ws.min_row, ws.min_column, ws.max_row, ws.max_column) == expected
def test_read_empty_rows(datadir, DummyWorkbook, ReadOnlyWorksheet):
datadir.join("reader").chdir()
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "", "empty_rows.xml", [])
rows = tuple(ws.rows)
assert len(rows) == 7
def test_get_max_cell(datadir, DummyWorkbook, ReadOnlyWorksheet, filename):
datadir.join("reader").chdir()
ws = ReadOnlyWorksheet(DummyWorkbook, "Sheet", "", filename, [])
rows = tuple(ws.rows)
assert rows[-1][-1].coordinate == "AA30"
def load_workbook(filename,
read_only=False,
keep_vba=KEEP_VBA,
data_only=False,
guess_types=False,
keep_links=True):
"""Open the given filename and return the workbook
:param filename: the path to open or a file-like object
:type filename: string or a file-like object open in binary mode c.f., :class:`zipfile.ZipFile`
:param read_only: optimised for reading, content cannot be edited
:type read_only: bool
:param keep_vba: preseve vba content (this does NOT mean you can use it)
:type keep_vba: bool
:param guess_types: guess cell content type and do not read it from the file
:type guess_types: bool
:param data_only: controls whether cells with formulae have either the formula (default) or the value stored the last time Excel read the sheet
:type data_only: bool
:param keep_links: whether links to external workbooks should be preserved. The default is True
:type keep_links: bool
:rtype: :class:`openpyexcel.workbook.Workbook`
.. note::
When using lazy load, all worksheets will be :class:`openpyexcel.worksheet.iter_worksheet.IterableWorksheet`
and the returned workbook will be read-only.
"""
archive = _validate_archive(filename)
src = archive.read(ARC_CONTENT_TYPES)
root = fromstring(src)
package = Manifest.from_tree(root)
wb_part = _find_workbook_part(package)
parser = WorkbookParser(archive, wb_part.PartName[1:])
wb = parser.wb
wb._data_only = data_only
wb._read_only = read_only
wb._keep_links = keep_links
wb.guess_types = guess_types
wb.template = wb_part.ContentType in (XLTX, XLTM)
parser.parse()
wb._sheets = []
if read_only and guess_types:
warnings.warn('Data types are not guessed when using iterator reader')
valid_files = archive.namelist()
# If are going to preserve the vba then attach a copy of the archive to the
# workbook so that is available for the save.
if keep_vba:
wb.vba_archive = ZipFile(BytesIO(), 'a', ZIP_DEFLATED)
for name in archive.namelist():
wb.vba_archive.writestr(name, archive.read(name))
if read_only:
wb._archive = ZipFile(filename)
# get workbook-level information
if ARC_CORE in valid_files:
src = fromstring(archive.read(ARC_CORE))
wb.properties = DocumentProperties.from_tree(src)
shared_strings = []
ct = package.find(SHARED_STRINGS)
if ct is not None:
strings_path = ct.PartName[1:]
shared_strings = read_string_table(archive.read(strings_path))
if ARC_THEME in valid_files:
wb.loaded_theme = archive.read(ARC_THEME)
apply_stylesheet(archive, wb) # bind styles to workbook
pivot_caches = parser.pivot_caches
# get worksheets
for sheet, rel in parser.find_sheets():
if "chartsheet" in rel.Type:
continue
sheet_name = sheet.name
worksheet_path = rel.target
rels_path = get_rels_path(worksheet_path)
rels = []
if rels_path in valid_files:
rels = get_dependents(archive, rels_path)
if not worksheet_path in valid_files:
continue
if read_only:
ws = ReadOnlyWorksheet(wb, sheet_name, worksheet_path, None,
shared_strings)
wb._sheets.append(ws)
else:
fh = archive.open(worksheet_path)
ws = wb.create_sheet(sheet_name)
ws._rels = rels
ws_parser = WorkSheetParser(ws, fh, shared_strings)
ws_parser.parse()
if rels:
# assign any comments to cells
for r in rels.find(COMMENTS_NS):
src = archive.read(r.target)
comment_sheet = CommentSheet.from_tree(fromstring(src))
for ref, comment in comment_sheet.comments:
ws[ref].comment = comment
# preserve link to VML file if VBA
if (wb.vba_archive is not None
and ws.legacy_drawing is not None):
ws.legacy_drawing = rels[ws.legacy_drawing].target
for t in ws_parser.tables:
src = archive.read(t)
xml = fromstring(src)
table = Table.from_tree(xml)
ws.add_table(table)
drawings = rels.find(SpreadsheetDrawing._rel_type)
for rel in drawings:
charts, images = find_images(archive, rel.target)
for c in charts:
ws.add_chart(c, c.anchor)
for im in images:
ws.add_image(im, im.anchor)
pivot_rel = rels.find(TableDefinition.rel_type)
for r in pivot_rel:
pivot_path = r.Target
src = archive.read(pivot_path)
tree = fromstring(src)
pivot = TableDefinition.from_tree(tree)
pivot.cache = pivot_caches[pivot.cacheId]
ws.add_pivot(pivot)
ws.sheet_state = sheet.state
ws._rels = [] # reset
parser.assign_names()
#wb._differential_styles.styles = [] # tables may depened upon dxf
archive.close()
return wb