From 15e25ef735430c0a20be6533b11b147a7dcc7c9d Mon Sep 17 00:00:00 2001 From: Kenneth Reitz Date: Tue, 10 May 2011 21:24:56 -0400 Subject: [PATCH 1/3] no more reqs --- reqs.txt | 3 --- 1 file changed, 3 deletions(-) delete mode 100644 reqs.txt diff --git a/reqs.txt b/reqs.txt deleted file mode 100644 index 4059edf..0000000 --- a/reqs.txt +++ /dev/null @@ -1,3 +0,0 @@ -xlwt -simplejson -PyYAML \ No newline at end of file From 87ce64d4c859efb7c3d37b1e715fa04a0c1cc631 Mon Sep 17 00:00:00 2001 From: Mark Rogers Date: Thu, 12 May 2011 15:12:46 -0500 Subject: [PATCH 2/3] Merely a proof of concept, soon to be tidied up --- tablib/core.py | 4 + tablib/formats/__init__.py | 3 +- tablib/formats/_xlsx.py | 104 ++++ tablib/packages/openpyxl/__init__.py | 53 ++ tablib/packages/openpyxl/cell.py | 384 +++++++++++++ tablib/packages/openpyxl/chart.py | 340 +++++++++++ tablib/packages/openpyxl/drawing.py | 402 +++++++++++++ tablib/packages/openpyxl/namedrange.py | 68 +++ tablib/packages/openpyxl/reader/__init__.py | 33 ++ tablib/packages/openpyxl/reader/excel.py | 111 ++++ .../openpyxl/reader/iter_worksheet.py | 343 +++++++++++ tablib/packages/openpyxl/reader/strings.py | 64 +++ tablib/packages/openpyxl/reader/style.py | 69 +++ tablib/packages/openpyxl/reader/workbook.py | 156 +++++ tablib/packages/openpyxl/reader/worksheet.py | 112 ++++ tablib/packages/openpyxl/shared/__init__.py | 33 ++ tablib/packages/openpyxl/shared/date_time.py | 154 +++++ tablib/packages/openpyxl/shared/exc.py | 59 ++ tablib/packages/openpyxl/shared/ooxml.py | 60 ++ .../openpyxl/shared/password_hasher.py | 47 ++ tablib/packages/openpyxl/shared/units.py | 67 +++ tablib/packages/openpyxl/shared/xmltools.py | 96 ++++ tablib/packages/openpyxl/style.py | 392 +++++++++++++ tablib/packages/openpyxl/tests/__init__.py | 24 + tablib/packages/openpyxl/tests/helper.py | 94 +++ tablib/packages/openpyxl/tests/test_cell.py | 200 +++++++ tablib/packages/openpyxl/tests/test_chart.py | 131 +++++ tablib/packages/openpyxl/tests/test_dump.py | 109 ++++ tablib/packages/openpyxl/tests/test_iter.py | 112 ++++ tablib/packages/openpyxl/tests/test_meta.py | 50 ++ .../openpyxl/tests/test_named_range.py | 102 ++++ .../openpyxl/tests/test_number_format.py | 142 +++++ .../openpyxl/tests/test_password_hash.py | 41 ++ tablib/packages/openpyxl/tests/test_props.py | 124 ++++ tablib/packages/openpyxl/tests/test_read.py | 134 +++++ .../packages/openpyxl/tests/test_strings.py | 68 +++ tablib/packages/openpyxl/tests/test_style.py | 181 ++++++ tablib/packages/openpyxl/tests/test_theme.py | 37 ++ .../packages/openpyxl/tests/test_workbook.py | 148 +++++ .../packages/openpyxl/tests/test_worksheet.py | 258 +++++++++ tablib/packages/openpyxl/tests/test_write.py | 203 +++++++ tablib/packages/openpyxl/workbook.py | 186 ++++++ tablib/packages/openpyxl/worksheet.py | 534 ++++++++++++++++++ tablib/packages/openpyxl/writer/__init__.py | 34 ++ tablib/packages/openpyxl/writer/charts.py | 261 +++++++++ tablib/packages/openpyxl/writer/drawings.py | 192 +++++++ .../openpyxl/writer/dump_worksheet.py | 256 +++++++++ tablib/packages/openpyxl/writer/excel.py | 156 +++++ tablib/packages/openpyxl/writer/strings.py | 86 +++ tablib/packages/openpyxl/writer/styles.py | 256 +++++++++ tablib/packages/openpyxl/writer/theme.py | 202 +++++++ tablib/packages/openpyxl/writer/workbook.py | 204 +++++++ tablib/packages/openpyxl/writer/worksheet.py | 209 +++++++ 53 files changed, 7887 insertions(+), 1 deletion(-) create mode 100644 tablib/formats/_xlsx.py create mode 100644 tablib/packages/openpyxl/__init__.py create mode 100644 tablib/packages/openpyxl/cell.py create mode 100644 tablib/packages/openpyxl/chart.py create mode 100644 tablib/packages/openpyxl/drawing.py create mode 100644 tablib/packages/openpyxl/namedrange.py create mode 100644 tablib/packages/openpyxl/reader/__init__.py create mode 100644 tablib/packages/openpyxl/reader/excel.py create mode 100644 tablib/packages/openpyxl/reader/iter_worksheet.py create mode 100644 tablib/packages/openpyxl/reader/strings.py create mode 100644 tablib/packages/openpyxl/reader/style.py create mode 100644 tablib/packages/openpyxl/reader/workbook.py create mode 100644 tablib/packages/openpyxl/reader/worksheet.py create mode 100644 tablib/packages/openpyxl/shared/__init__.py create mode 100644 tablib/packages/openpyxl/shared/date_time.py create mode 100644 tablib/packages/openpyxl/shared/exc.py create mode 100644 tablib/packages/openpyxl/shared/ooxml.py create mode 100644 tablib/packages/openpyxl/shared/password_hasher.py create mode 100644 tablib/packages/openpyxl/shared/units.py create mode 100644 tablib/packages/openpyxl/shared/xmltools.py create mode 100644 tablib/packages/openpyxl/style.py create mode 100644 tablib/packages/openpyxl/tests/__init__.py create mode 100644 tablib/packages/openpyxl/tests/helper.py create mode 100644 tablib/packages/openpyxl/tests/test_cell.py create mode 100644 tablib/packages/openpyxl/tests/test_chart.py create mode 100644 tablib/packages/openpyxl/tests/test_dump.py create mode 100644 tablib/packages/openpyxl/tests/test_iter.py create mode 100644 tablib/packages/openpyxl/tests/test_meta.py create mode 100644 tablib/packages/openpyxl/tests/test_named_range.py create mode 100644 tablib/packages/openpyxl/tests/test_number_format.py create mode 100644 tablib/packages/openpyxl/tests/test_password_hash.py create mode 100644 tablib/packages/openpyxl/tests/test_props.py create mode 100644 tablib/packages/openpyxl/tests/test_read.py create mode 100644 tablib/packages/openpyxl/tests/test_strings.py create mode 100644 tablib/packages/openpyxl/tests/test_style.py create mode 100644 tablib/packages/openpyxl/tests/test_theme.py create mode 100644 tablib/packages/openpyxl/tests/test_workbook.py create mode 100644 tablib/packages/openpyxl/tests/test_worksheet.py create mode 100644 tablib/packages/openpyxl/tests/test_write.py create mode 100644 tablib/packages/openpyxl/workbook.py create mode 100644 tablib/packages/openpyxl/worksheet.py create mode 100644 tablib/packages/openpyxl/writer/__init__.py create mode 100644 tablib/packages/openpyxl/writer/charts.py create mode 100644 tablib/packages/openpyxl/writer/drawings.py create mode 100644 tablib/packages/openpyxl/writer/dump_worksheet.py create mode 100644 tablib/packages/openpyxl/writer/excel.py create mode 100644 tablib/packages/openpyxl/writer/strings.py create mode 100644 tablib/packages/openpyxl/writer/styles.py create mode 100644 tablib/packages/openpyxl/writer/theme.py create mode 100644 tablib/packages/openpyxl/writer/workbook.py create mode 100644 tablib/packages/openpyxl/writer/worksheet.py diff --git a/tablib/core.py b/tablib/core.py index 896dfcc..71f4f71 100644 --- a/tablib/core.py +++ b/tablib/core.py @@ -390,6 +390,10 @@ class Dataset(object): """ pass + @property + def xlsx(): + pass + @property def csv(): diff --git a/tablib/formats/__init__.py b/tablib/formats/__init__.py index 305026d..306ca30 100644 --- a/tablib/formats/__init__.py +++ b/tablib/formats/__init__.py @@ -9,5 +9,6 @@ from . import _xls as xls from . import _yaml as yaml from . import _tsv as tsv from . import _html as html +from . import _xlsx as xlsx -available = (json, xls, yaml, csv, tsv, html) +available = (json, xls, yaml, csv, tsv, html, xlsx) diff --git a/tablib/formats/_xlsx.py b/tablib/formats/_xlsx.py new file mode 100644 index 0000000..92e33f9 --- /dev/null +++ b/tablib/formats/_xlsx.py @@ -0,0 +1,104 @@ +# -*- coding: utf-8 -*- + +""" Tablib - XLSX Support. +""" + +import sys + + +if sys.version_info[0] > 2: + from io import BytesIO + import tablib.packages.xlwt3 as xlwt + +else: + from cStringIO import StringIO as BytesIO + import tablib.packages.xlwt as xlwt + +from tablib.packages.openpyxl.workbook import Workbook +from tablib.packages.openpyxl.writer.excel import ExcelWriter + +from tablib.packages.openpyxl.cell import get_column_letter + + + +title = 'xlsx' +extentions = ('xlsx',) + +# special styles +#wrap = xlwt.easyxf("alignment: wrap on") +#bold = xlwt.easyxf("font: bold on") + + +def export_set(dataset): + """Returns XLS representation of Dataset.""" + + wb = Workbook() + ws = wb.worksheets[0] + ws.title = dataset.title if dataset.title else 'Tablib Dataset' + + dset_sheet(dataset, ws) + + stream = BytesIO() + wb.save(stream) + return stream.getvalue() + + +def export_book(databook): + """Returns XLS representation of DataBook.""" + + wb = Workbook() + ew = ExcelWriter(workbook = wb) + for i, dset in enumerate(databook._datasets): + ws = wb.add_sheet() + ws.title = dset.title if dset.title else 'Sheet%s' % (i) + + dset_sheet(dset, ws) + + + stream = BytesIO() + ew.save(filename='test.xlsx') + return stream.getvalue() + + +def dset_sheet(dataset, ws): + """Completes given worksheet from given Dataset.""" + _package = dataset._package(dicts=False) + + for i, sep in enumerate(dataset._separators): + _offset = i + _package.insert((sep[0] + _offset), (sep[1],)) + + for i, row in enumerate(_package): + row_number = i + 1 + for j, col in enumerate(row): + col_idx = get_column_letter(j + 1) + + # bold headers + if (row_number == 1) and dataset.headers: + ws.cell('%s%s'%(col_idx, row_number)).value = '%s' % col + #ws.write(i, j, col, bold) + + # frozen header row + #ws.panes_frozen = True + #ws.horz_split_pos = 1 + + + # bold separators + elif len(row) < dataset.width: + ws.cell('%s%s'%(col_idx, row_number)).value = '%s' % col + #ws.write(i, j, col, bold) + + # wrap the rest + else: + try: + if '\n' in col: + ws.cell('%s%s'%(col_idx, row_number)).value = '%s' % col + #ws.write(i, j, col, wrap) + else: + ws.cell('%s%s'%(col_idx, row_number)).value = '%s' % col + #ws.write(i, j, col) + except TypeError: + ws.cell('%s%s'%(col_idx, row_number)).value = '%s' % col + #ws.write(i, j, col) + + diff --git a/tablib/packages/openpyxl/__init__.py b/tablib/packages/openpyxl/__init__.py new file mode 100644 index 0000000..c3dcc5e --- /dev/null +++ b/tablib/packages/openpyxl/__init__.py @@ -0,0 +1,53 @@ +# file openpyxl/__init__.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Imports for the openpyxl package.""" + +# package imports +from openpyxl import cell +from openpyxl import namedrange +from openpyxl import style +from openpyxl import workbook +from openpyxl import worksheet +from openpyxl import reader +from openpyxl import shared +from openpyxl import writer + +# constants + +__major__ = 1 # for major interface/format changes +__minor__ = 5 # for minor interface/format changes +__release__ = 2 # for tweaks, bug-fixes, or development + +__version__ = '%d.%d.%d' % (__major__, __minor__, __release__) + +__author__ = 'Eric Gazoni' +__license__ = 'MIT/Expat' +__author_email__ = 'eric.gazoni@gmail.com' +__maintainer_email__ = 'openpyxl-users@googlegroups.com' +__url__ = 'http://bitbucket.org/ericgazoni/openpyxl/wiki/Home' +__downloadUrl__ = "http://bitbucket.org/ericgazoni/openpyxl/downloads" + +__all__ = ('reader', 'shared', 'writer',) diff --git a/tablib/packages/openpyxl/cell.py b/tablib/packages/openpyxl/cell.py new file mode 100644 index 0000000..324fc96 --- /dev/null +++ b/tablib/packages/openpyxl/cell.py @@ -0,0 +1,384 @@ +# file openpyxl/cell.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Manage individual cells in a spreadsheet. + +The Cell class is required to know its value and type, display options, +and any other features of an Excel cell. Utilities for referencing +cells using Excel's 'A1' column/row nomenclature are also provided. + +""" + +__docformat__ = "restructuredtext en" + +# Python stdlib imports +import datetime +import re + +# package imports +from openpyxl.shared.date_time import SharedDate +from openpyxl.shared.exc import CellCoordinatesException, \ + ColumnStringIndexException, DataTypeException +from openpyxl.style import NumberFormat + +# constants +COORD_RE = re.compile('^[$]?([A-Z]+)[$]?(\d+)$') + +ABSOLUTE_RE = re.compile('^[$]?([A-Z]+)[$]?(\d+)(:[$]?([A-Z]+)[$]?(\d+))?$') + +def coordinate_from_string(coord_string): + """Convert a coordinate string like 'B12' to a tuple ('B', 12)""" + match = COORD_RE.match(coord_string.upper()) + if not match: + msg = 'Invalid cell coordinates (%s)' % coord_string + raise CellCoordinatesException(msg) + column, row = match.groups() + return (column, int(row)) + + +def absolute_coordinate(coord_string): + """Convert a coordinate to an absolute coordinate string (B12 -> $B$12)""" + parts = ABSOLUTE_RE.match(coord_string).groups() + + if all(parts[-2:]): + return '$%s$%s:$%s$%s' % (parts[0], parts[1], parts[3], parts[4]) + else: + return '$%s$%s' % (parts[0], parts[1]) + + +def column_index_from_string(column, fast = False): + """Convert a column letter into a column number (e.g. B -> 2) + + Excel only supports 1-3 letter column names from A -> ZZZ, so we + restrict our column names to 1-3 characters, each in the range A-Z. + + .. note:: + + Fast mode is faster but does not check that all letters are capitals between A and Z + + """ + column = column.upper() + + clen = len(column) + + if not fast and not all('A' <= char <= 'Z' for char in column): + msg = 'Column string must contain only characters A-Z: got %s' % column + raise ColumnStringIndexException(msg) + + if clen == 1: + return ord(column[0]) - 64 + elif clen == 2: + return ((1 + (ord(column[0]) - 65)) * 26) + (ord(column[1]) - 64) + elif clen == 3: + return ((1 + (ord(column[0]) - 65)) * 676) + ((1 + (ord(column[1]) - 65)) * 26) + (ord(column[2]) - 64) + elif clen > 3: + raise ColumnStringIndexException('Column string index can not be longer than 3 characters') + else: + raise ColumnStringIndexException('Column string index can not be empty') + + +def get_column_letter(col_idx): + """Convert a column number into a column letter (3 -> 'C') + + Right shift the column col_idx by 26 to find column letters in reverse + order. These numbers are 1-based, and can be converted to ASCII + ordinals by adding 64. + + """ + # these indicies corrospond to A -> ZZZ and include all allowed + # columns + if not 1 <= col_idx <= 18278: + msg = 'Column index out of bounds: %s' % col_idx + raise ColumnStringIndexException(msg) + ordinals = [] + temp = col_idx + while temp: + quotient, remainder = divmod(temp, 26) + # check for exact division and borrow if needed + if remainder == 0: + quotient -= 1 + remainder = 26 + ordinals.append(remainder + 64) + temp = quotient + ordinals.reverse() + return ''.join([chr(ordinal) for ordinal in ordinals]) + + +class Cell(object): + """Describes cell associated properties. + + Properties of interest include style, type, value, and address. + + """ + __slots__ = ('column', + 'row', + '_value', + '_data_type', + 'parent', + 'xf_index', + '_hyperlink_rel') + + ERROR_CODES = {'#NULL!': 0, + '#DIV/0!': 1, + '#VALUE!': 2, + '#REF!': 3, + '#NAME?': 4, + '#NUM!': 5, + '#N/A': 6} + + TYPE_STRING = 's' + TYPE_FORMULA = 'f' + TYPE_NUMERIC = 'n' + TYPE_BOOL = 'b' + TYPE_NULL = 's' + TYPE_INLINE = 'inlineStr' + TYPE_ERROR = 'e' + + VALID_TYPES = [TYPE_STRING, TYPE_FORMULA, TYPE_NUMERIC, TYPE_BOOL, + TYPE_NULL, TYPE_INLINE, TYPE_ERROR] + + RE_PATTERNS = { + 'percentage': re.compile('^\-?[0-9]*\.?[0-9]*\s?\%$'), + 'time': re.compile('^(\d|[0-1]\d|2[0-3]):[0-5]\d(:[0-5]\d)?$'), + 'numeric': re.compile('^\-?([0-9]+\\.?[0-9]*|[0-9]*\\.?[0-9]+)((E|e)\-?[0-9]+)?$'), } + + def __init__(self, worksheet, column, row, value = None): + self.column = column.upper() + self.row = row + # _value is the stored value, while value is the displayed value + self._value = None + self._hyperlink_rel = None + self._data_type = self.TYPE_NULL + if value: + self.value = value + self.parent = worksheet + self.xf_index = 0 + + def __repr__(self): + return u"" % (self.parent.title, self.get_coordinate()) + + def check_string(self, value): + """Check string coding, length, and line break character""" + # convert to unicode string + value = unicode(value) + # string must never be longer than 32,767 characters + # truncate if necessary + value = value[:32767] + # we require that newline is represented as "\n" in core, + # not as "\r\n" or "\r" + value = value.replace('\r\n', '\n') + return value + + def check_numeric(self, value): + """Cast value to int or float if necessary""" + if not isinstance(value, (int, float)): + try: + value = int(value) + except ValueError: + value = float(value) + return value + + def set_value_explicit(self, value = None, data_type = TYPE_STRING): + """Coerce values according to their explicit type""" + type_coercion_map = { + self.TYPE_INLINE: self.check_string, + self.TYPE_STRING: self.check_string, + self.TYPE_FORMULA: unicode, + self.TYPE_NUMERIC: self.check_numeric, + self.TYPE_BOOL: bool, } + try: + self._value = type_coercion_map[data_type](value) + except KeyError: + if data_type not in self.VALID_TYPES: + msg = 'Invalid data type: %s' % data_type + raise DataTypeException(msg) + self._data_type = data_type + + def data_type_for_value(self, value): + """Given a value, infer the correct data type""" + if value is None: + data_type = self.TYPE_NULL + elif value is True or value is False: + data_type = self.TYPE_BOOL + elif isinstance(value, (int, float)): + data_type = self.TYPE_NUMERIC + elif not value: + data_type = self.TYPE_STRING + elif isinstance(value, (datetime.datetime, datetime.date)): + data_type = self.TYPE_NUMERIC + elif isinstance(value, basestring) and value[0] == '=': + data_type = self.TYPE_FORMULA + elif self.RE_PATTERNS['numeric'].match(value): + data_type = self.TYPE_NUMERIC + elif value.strip() in self.ERROR_CODES: + data_type = self.TYPE_ERROR + else: + data_type = self.TYPE_STRING + return data_type + + def bind_value(self, value): + """Given a value, infer type and display options.""" + self._data_type = self.data_type_for_value(value) + if value is None: + self.set_value_explicit('', self.TYPE_NULL) + return True + elif self._data_type == self.TYPE_STRING: + # percentage detection + percentage_search = self.RE_PATTERNS['percentage'].match(value) + if percentage_search and value.strip() != '%': + value = float(value.replace('%', '')) / 100.0 + self.set_value_explicit(value, self.TYPE_NUMERIC) + self._set_number_format(NumberFormat.FORMAT_PERCENTAGE) + return True + # time detection + time_search = self.RE_PATTERNS['time'].match(value) + if time_search: + sep_count = value.count(':') #pylint: disable-msg=E1103 + if sep_count == 1: + hours, minutes = [int(bit) for bit in value.split(':')] #pylint: disable-msg=E1103 + seconds = 0 + elif sep_count == 2: + hours, minutes, seconds = \ + [int(bit) for bit in value.split(':')] #pylint: disable-msg=E1103 + days = (hours / 24.0) + (minutes / 1440.0) + \ + (seconds / 86400.0) + self.set_value_explicit(days, self.TYPE_NUMERIC) + self._set_number_format(NumberFormat.FORMAT_DATE_TIME3) + return True + if self._data_type == self.TYPE_NUMERIC: + # date detection + # if the value is a date, but not a date time, make it a + # datetime, and set the time part to 0 + if isinstance(value, datetime.date) and not \ + isinstance(value, datetime.datetime): + value = datetime.datetime.combine(value, datetime.time()) + if isinstance(value, datetime.datetime): + value = SharedDate().datetime_to_julian(date = value) + self.set_value_explicit(value, self.TYPE_NUMERIC) + self._set_number_format(NumberFormat.FORMAT_DATE_YYYYMMDD2) + return True + self.set_value_explicit(value, self._data_type) + + def _get_value(self): + """Return the value, formatted as a date if needed""" + value = self._value + if self.is_date(): + value = SharedDate().from_julian(value) + return value + + def _set_value(self, value): + """Set the value and infer type and display options.""" + self.bind_value(value) + + value = property(_get_value, _set_value, + doc = 'Get or set the value held in the cell.\n\n' + ':rtype: depends on the value (string, float, int or ' + ':class:`datetime.datetime`)') + + def _set_hyperlink(self, val): + """Set value and display for hyperlinks in a cell""" + if self._hyperlink_rel is None: + self._hyperlink_rel = self.parent.create_relationship("hyperlink") + self._hyperlink_rel.target = val + self._hyperlink_rel.target_mode = "External" + if self._value is None: + self.value = val + + def _get_hyperlink(self): + """Return the hyperlink target or an empty string""" + return self._hyperlink_rel is not None and \ + self._hyperlink_rel.target or '' + + hyperlink = property(_get_hyperlink, _set_hyperlink, + doc = 'Get or set the hyperlink held in the cell. ' + 'Automatically sets the `value` of the cell with link text, ' + 'but you can modify it afterwards by setting the ' + '`value` property, and the hyperlink will remain.\n\n' + ':rtype: string') + + @property + def hyperlink_rel_id(self): + """Return the id pointed to by the hyperlink, or None""" + return self._hyperlink_rel is not None and \ + self._hyperlink_rel.id or None + + def _set_number_format(self, format_code): + """Set a new formatting code for numeric values""" + self.style.number_format.format_code = format_code + + @property + def has_style(self): + """Check if the parent worksheet has a style for this cell""" + return self.get_coordinate() in self.parent._styles #pylint: disable-msg=W0212 + + @property + def style(self): + """Returns the :class:`openpyxl.style.Style` object for this cell""" + return self.parent.get_style(self.get_coordinate()) + + @property + def data_type(self): + """Return the data type represented by this cell""" + return self._data_type + + def get_coordinate(self): + """Return the coordinate string for this cell (e.g. 'B12') + + :rtype: string + """ + return '%s%s' % (self.column, self.row) + + @property + def address(self): + """Return the coordinate string for this cell (e.g. 'B12') + + :rtype: string + """ + return self.get_coordinate() + + def offset(self, row = 0, column = 0): + """Returns a cell location relative to this cell. + + :param row: number of rows to offset + :type row: int + + :param column: number of columns to offset + :type column: int + + :rtype: :class:`openpyxl.cell.Cell` + """ + offset_column = get_column_letter(column_index_from_string( + column = self.column) + column) + offset_row = self.row + row + return self.parent.cell('%s%s' % (offset_column, offset_row)) + + def is_date(self): + """Returns whether the value is *probably* a date or not + + :rtype: bool + """ + return (self.has_style + and self.style.number_format.is_date_format() + and isinstance(self._value, (int, float))) diff --git a/tablib/packages/openpyxl/chart.py b/tablib/packages/openpyxl/chart.py new file mode 100644 index 0000000..c23e78f --- /dev/null +++ b/tablib/packages/openpyxl/chart.py @@ -0,0 +1,340 @@ +''' +Copyright (c) 2010 openpyxl + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +@license: http://www.opensource.org/licenses/mit-license.php +@author: Eric Gazoni +''' + +import math + +from openpyxl.style import NumberFormat +from openpyxl.drawing import Drawing, Shape +from openpyxl.shared.units import pixels_to_EMU, short_color +from openpyxl.cell import get_column_letter + +class Axis(object): + + POSITION_BOTTOM = 'b' + POSITION_LEFT = 'l' + + ORIENTATION_MIN_MAX = "minMax" + + def __init__(self): + + self.orientation = self.ORIENTATION_MIN_MAX + self.number_format = NumberFormat() + for attr in ('position','tick_label_position','crosses', + 'auto','label_align','label_offset','cross_between'): + setattr(self, attr, None) + self.min = 0 + self.max = None + self.unit = None + + @classmethod + def default_category(cls): + """ default values for category axes """ + + ax = Axis() + ax.id = 60871424 + ax.cross = 60873344 + ax.position = Axis.POSITION_BOTTOM + ax.tick_label_position = 'nextTo' + ax.crosses = "autoZero" + ax.auto = True + ax.label_align = 'ctr' + ax.label_offset = 100 + return ax + + @classmethod + def default_value(cls): + """ default values for value axes """ + + ax = Axis() + ax.id = 60873344 + ax.cross = 60871424 + ax.position = Axis.POSITION_LEFT + ax.major_gridlines = None + ax.tick_label_position = 'nextTo' + ax.crosses = 'autoZero' + ax.auto = False + ax.cross_between = 'between' + return ax + +class Reference(object): + """ a simple wrapper around a serie of reference data """ + + def __init__(self, sheet, pos1, pos2=None): + + self.sheet = sheet + self.pos1 = pos1 + self.pos2 = pos2 + + def get_type(self): + + if isinstance(self.cache[0], basestring): + return 'str' + else: + return 'num' + + def _get_ref(self): + """ format excel reference notation """ + + if self.pos2: + return '%s!$%s$%s:$%s$%s' % (self.sheet.title, + get_column_letter(self.pos1[1]+1), self.pos1[0]+1, + get_column_letter(self.pos2[1]+1), self.pos2[0]+1) + else: + return '%s!$%s$%s' % (self.sheet.title, + get_column_letter(self.pos1[1]+1), self.pos1[0]+1) + + + def _get_cache(self): + """ read data in sheet - to be used at writing time """ + + cache = [] + if self.pos2: + for row in range(self.pos1[0], self.pos2[0]+1): + for col in range(self.pos1[1], self.pos2[1]+1): + cache.append(self.sheet.cell(row=row, column=col).value) + else: + cell = self.sheet.cell(row=self.pos1[0], column=self.pos1[1]) + cache.append(cell.value) + return cache + + +class Serie(object): + """ a serie of data and possibly associated labels """ + + MARKER_NONE = 'none' + + def __init__(self, values, labels=None, legend=None, color=None, xvalues=None): + + self.marker = Serie.MARKER_NONE + self.values = values + self.xvalues = xvalues + self.labels = labels + self.legend = legend + self.error_bar = None + self._color = color + + def _get_color(self): + return self._color + + def _set_color(self, color): + self._color = short_color(color) + + color = property(_get_color, _set_color) + + def get_min_max(self): + + if self.error_bar: + err_cache = self.error_bar.values._get_cache() + vals = [v + err_cache[i] \ + for i,v in enumerate(self.values._get_cache())] + else: + vals = self.values._get_cache() + return min(vals), max(vals) + + def __len__(self): + + return len(self.values.cache) + +class Legend(object): + + def __init__(self): + + self.position = 'r' + self.layout = None + +class ErrorBar(object): + + PLUS = 1 + MINUS = 2 + PLUS_MINUS = 3 + + def __init__(self, _type, values): + + self.type = _type + self.values = values + +class Chart(object): + """ raw chart class """ + + GROUPING_CLUSTERED = 'clustered' + GROUPING_STANDARD = 'standard' + + BAR_CHART = 1 + LINE_CHART = 2 + SCATTER_CHART = 3 + + def __init__(self, _type, grouping): + + self._series = [] + + # public api + self.type = _type + self.grouping = grouping + self.x_axis = Axis.default_category() + self.y_axis = Axis.default_value() + self.legend = Legend() + self.lang = 'fr-FR' + self.title = '' + self.print_margins = dict(b=.75, l=.7, r=.7, t=.75, header=0.3, footer=.3) + + # the containing drawing + self.drawing = Drawing() + + # the offset for the plot part in percentage of the drawing size + self.width = .6 + self.height = .6 + self.margin_top = self._get_max_margin_top() + self.margin_left = 0 + + # the user defined shapes + self._shapes = [] + + def add_serie(self, serie): + + serie.id = len(self._series) + self._series.append(serie) + self._compute_min_max() + if not None in [s.xvalues for s in self._series]: + self._compute_xmin_xmax() + + def add_shape(self, shape): + + shape._chart = self + self._shapes.append(shape) + + def get_x_units(self): + """ calculate one unit for x axis in EMU """ + + return max([len(s.values._get_cache()) for s in self._series]) + + def get_y_units(self): + """ calculate one unit for y axis in EMU """ + + dh = pixels_to_EMU(self.drawing.height) + return (dh * self.height) / self.y_axis.max + + def get_y_chars(self): + """ estimate nb of chars for y axis """ + + _max = max([max(s.values._get_cache()) for s in self._series]) + return len(str(int(_max))) + + def _compute_min_max(self): + """ compute y axis limits and units """ + + maxi = max([max(s.values._get_cache()) for s in self._series]) + + mul = None + if maxi < 1: + s = str(maxi).split('.')[1] + mul = 10 + for x in s: + if x == '0': + mul *= 10 + else: + break + maxi = maxi * mul + + maxi = math.ceil(maxi * 1.1) + sz = len(str(int(maxi))) - 1 + unit = math.ceil(math.ceil(maxi / pow(10, sz)) * pow(10, sz-1)) + maxi = math.ceil(maxi/unit) * unit + + if mul is not None: + maxi = maxi/mul + unit = unit/mul + + if maxi / unit > 9: + # no more that 10 ticks + unit *= 2 + + self.y_axis.max = maxi + self.y_axis.unit = unit + + def _compute_xmin_xmax(self): + """ compute x axis limits and units """ + + maxi = max([max(s.xvalues._get_cache()) for s in self._series]) + + mul = None + if maxi < 1: + s = str(maxi).split('.')[1] + mul = 10 + for x in s: + if x == '0': + mul *= 10 + else: + break + maxi = maxi * mul + + maxi = math.ceil(maxi * 1.1) + sz = len(str(int(maxi))) - 1 + unit = math.ceil(math.ceil(maxi / pow(10, sz)) * pow(10, sz-1)) + maxi = math.ceil(maxi/unit) * unit + + if mul is not None: + maxi = maxi/mul + unit = unit/mul + + if maxi / unit > 9: + # no more that 10 ticks + unit *= 2 + + self.x_axis.max = maxi + self.x_axis.unit = unit + + def _get_max_margin_top(self): + + mb = Shape.FONT_HEIGHT + Shape.MARGIN_BOTTOM + plot_height = self.drawing.height * self.height + return float(self.drawing.height - plot_height - mb)/self.drawing.height + + def _get_min_margin_left(self): + + ml = (self.get_y_chars() * Shape.FONT_WIDTH) + Shape.MARGIN_LEFT + return float(ml)/self.drawing.width + + def _get_margin_top(self): + """ get margin in percent """ + + return min(self.margin_top, self._get_max_margin_top()) + + def _get_margin_left(self): + + return max(self._get_min_margin_left(), self.margin_left) + +class BarChart(Chart): + def __init__(self): + super(BarChart, self).__init__(Chart.BAR_CHART, Chart.GROUPING_CLUSTERED) + +class LineChart(Chart): + def __init__(self): + super(LineChart, self).__init__(Chart.LINE_CHART, Chart.GROUPING_STANDARD) + +class ScatterChart(Chart): + def __init__(self): + super(ScatterChart, self).__init__(Chart.SCATTER_CHART, Chart.GROUPING_STANDARD) + + diff --git a/tablib/packages/openpyxl/drawing.py b/tablib/packages/openpyxl/drawing.py new file mode 100644 index 0000000..c9cf084 --- /dev/null +++ b/tablib/packages/openpyxl/drawing.py @@ -0,0 +1,402 @@ +''' +Copyright (c) 2010 openpyxl + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +@license: http://www.opensource.org/licenses/mit-license.php +@author: Eric Gazoni +''' + +import math +from openpyxl.style import Color +from openpyxl.shared.units import pixels_to_EMU, EMU_to_pixels, short_color + +class Shadow(object): + + SHADOW_BOTTOM = 'b' + SHADOW_BOTTOM_LEFT = 'bl' + SHADOW_BOTTOM_RIGHT = 'br' + SHADOW_CENTER = 'ctr' + SHADOW_LEFT = 'l' + SHADOW_TOP = 't' + SHADOW_TOP_LEFT = 'tl' + SHADOW_TOP_RIGHT = 'tr' + + def __init__(self): + self.visible = False + self.blurRadius = 6 + self.distance = 2 + self.direction = 0 + self.alignment = self.SHADOW_BOTTOM_RIGHT + self.color = Color(Color.BLACK) + self.alpha = 50 + +class Drawing(object): + """ a drawing object - eg container for shapes or charts + we assume user specifies dimensions in pixels; units are + converted to EMU in the drawing part + """ + + count = 0 + + def __init__(self): + + self.name = '' + self.description = '' + self.coordinates = ((1,2), (16,8)) + self.left = 0 + self.top = 0 + self._width = EMU_to_pixels(200000) + self._height = EMU_to_pixels(1828800) + self.resize_proportional = False + self.rotation = 0 +# self.shadow = Shadow() + + def _set_width(self, w): + + if self.resize_proportional and w: + ratio = self._height / self._width + self._height = round(ratio * w) + self._width = w + + def _get_width(self): + + return self._width + + width = property(_get_width, _set_width) + + def _set_height(self, h): + + if self.resize_proportional and h: + ratio = self._width / self._height + self._width = round(ratio * h) + self._height = h + + def _get_height(self): + + return self._height + + height = property(_get_height, _set_height) + + def set_dimension(self, w=0, h=0): + + xratio = w / self._width + yratio = h / self._height + + if self.resize_proportional and w and h: + if (xratio * self._height) < h: + self._height = math.ceil(xratio * self._height) + self._width = width + else: + self._width = math.ceil(yratio * self._width) + self._height = height + + def get_emu_dimensions(self): + """ return (x, y, w, h) in EMU """ + + return (pixels_to_EMU(self.left), pixels_to_EMU(self.top), + pixels_to_EMU(self._width), pixels_to_EMU(self._height)) + + +class Shape(object): + """ a drawing inside a chart + coordiantes are specified by the user in the axis units + """ + + MARGIN_LEFT = 6 + 13 + 1 + MARGIN_BOTTOM = 17 + 11 + + FONT_WIDTH = 7 + FONT_HEIGHT = 8 + + ROUND_RECT = 'roundRect' + RECT = 'rect' + + # other shapes to define : + ''' + "line" + "lineInv" + "triangle" + "rtTriangle" + "diamond" + "parallelogram" + "trapezoid" + "nonIsoscelesTrapezoid" + "pentagon" + "hexagon" + "heptagon" + "octagon" + "decagon" + "dodecagon" + "star4" + "star5" + "star6" + "star7" + "star8" + "star10" + "star12" + "star16" + "star24" + "star32" + "roundRect" + "round1Rect" + "round2SameRect" + "round2DiagRect" + "snipRoundRect" + "snip1Rect" + "snip2SameRect" + "snip2DiagRect" + "plaque" + "ellipse" + "teardrop" + "homePlate" + "chevron" + "pieWedge" + "pie" + "blockArc" + "donut" + "noSmoking" + "rightArrow" + "leftArrow" + "upArrow" + "downArrow" + "stripedRightArrow" + "notchedRightArrow" + "bentUpArrow" + "leftRightArrow" + "upDownArrow" + "leftUpArrow" + "leftRightUpArrow" + "quadArrow" + "leftArrowCallout" + "rightArrowCallout" + "upArrowCallout" + "downArrowCallout" + "leftRightArrowCallout" + "upDownArrowCallout" + "quadArrowCallout" + "bentArrow" + "uturnArrow" + "circularArrow" + "leftCircularArrow" + "leftRightCircularArrow" + "curvedRightArrow" + "curvedLeftArrow" + "curvedUpArrow" + "curvedDownArrow" + "swooshArrow" + "cube" + "can" + "lightningBolt" + "heart" + "sun" + "moon" + "smileyFace" + "irregularSeal1" + "irregularSeal2" + "foldedCorner" + "bevel" + "frame" + "halfFrame" + "corner" + "diagStripe" + "chord" + "arc" + "leftBracket" + "rightBracket" + "leftBrace" + "rightBrace" + "bracketPair" + "bracePair" + "straightConnector1" + "bentConnector2" + "bentConnector3" + "bentConnector4" + "bentConnector5" + "curvedConnector2" + "curvedConnector3" + "curvedConnector4" + "curvedConnector5" + "callout1" + "callout2" + "callout3" + "accentCallout1" + "accentCallout2" + "accentCallout3" + "borderCallout1" + "borderCallout2" + "borderCallout3" + "accentBorderCallout1" + "accentBorderCallout2" + "accentBorderCallout3" + "wedgeRectCallout" + "wedgeRoundRectCallout" + "wedgeEllipseCallout" + "cloudCallout" + "cloud" + "ribbon" + "ribbon2" + "ellipseRibbon" + "ellipseRibbon2" + "leftRightRibbon" + "verticalScroll" + "horizontalScroll" + "wave" + "doubleWave" + "plus" + "flowChartProcess" + "flowChartDecision" + "flowChartInputOutput" + "flowChartPredefinedProcess" + "flowChartInternalStorage" + "flowChartDocument" + "flowChartMultidocument" + "flowChartTerminator" + "flowChartPreparation" + "flowChartManualInput" + "flowChartManualOperation" + "flowChartConnector" + "flowChartPunchedCard" + "flowChartPunchedTape" + "flowChartSummingJunction" + "flowChartOr" + "flowChartCollate" + "flowChartSort" + "flowChartExtract" + "flowChartMerge" + "flowChartOfflineStorage" + "flowChartOnlineStorage" + "flowChartMagneticTape" + "flowChartMagneticDisk" + "flowChartMagneticDrum" + "flowChartDisplay" + "flowChartDelay" + "flowChartAlternateProcess" + "flowChartOffpageConnector" + "actionButtonBlank" + "actionButtonHome" + "actionButtonHelp" + "actionButtonInformation" + "actionButtonForwardNext" + "actionButtonBackPrevious" + "actionButtonEnd" + "actionButtonBeginning" + "actionButtonReturn" + "actionButtonDocument" + "actionButtonSound" + "actionButtonMovie" + "gear6" + "gear9" + "funnel" + "mathPlus" + "mathMinus" + "mathMultiply" + "mathDivide" + "mathEqual" + "mathNotEqual" + "cornerTabs" + "squareTabs" + "plaqueTabs" + "chartX" + "chartStar" + "chartPlus" + ''' + + def __init__(self, coordinates=((0,0), (1,1)), text=None, scheme="accent1"): + + self.coordinates = coordinates # in axis unit + self.text = text + self.scheme = scheme + self.style = Shape.RECT + self._border_width = 3175 # in EMU + self._border_color = Color.BLACK[2:] #"F3B3C5" + self._color = Color.WHITE[2:] + self._text_color = Color.BLACK[2:] + + def _get_border_color(self): + return self._border_color + + def _set_border_color(self, color): + self._border_color = short_color(color) + + border_color = property(_get_border_color, _set_border_color) + + def _get_color(self): + return self._color + + def _set_color(self, color): + self._color = short_color(color) + + color = property(_get_color, _set_color) + + def _get_text_color(self): + return self._text_color + + def _set_text_color(self, color): + self._text_color = short_color(color) + + text_color = property(_get_text_color, _set_text_color) + + def _get_border_width(self): + + return EMU_to_pixels(self._border_width) + + def _set_border_width(self, w): + + self._border_width = pixels_to_EMU(w) + print self._border_width + + border_width = property(_get_border_width, _set_border_width) + + def get_coordinates(self): + """ return shape coordinates in percentages (left, top, right, bottom) """ + + (x1, y1), (x2, y2) = self.coordinates + + drawing_width = pixels_to_EMU(self._chart.drawing.width) + drawing_height = pixels_to_EMU(self._chart.drawing.height) + plot_width = drawing_width * self._chart.width + plot_height = drawing_height * self._chart.height + + margin_left = self._chart._get_margin_left() * drawing_width + xunit = plot_width / self._chart.get_x_units() + + margin_top = self._chart._get_margin_top() * drawing_height + yunit = self._chart.get_y_units() + + x_start = (margin_left + (float(x1) * xunit)) / drawing_width + y_start = (margin_top + plot_height - (float(y1) * yunit)) / drawing_height + + x_end = (margin_left + (float(x2) * xunit)) / drawing_width + y_end = (margin_top + plot_height - (float(y2) * yunit)) / drawing_height + + def _norm_pct(pct): + """ force shapes to appear by truncating too large sizes """ + if pct>1: pct = 1 + elif pct<0: pct = 0 + return pct + + # allow user to specify y's in whatever order + # excel expect y_end to be lower + if y_end < y_start: + y_end, y_start = y_start, y_end + + return (_norm_pct(x_start), _norm_pct(y_start), + _norm_pct(x_end), _norm_pct(y_end)) + \ No newline at end of file diff --git a/tablib/packages/openpyxl/namedrange.py b/tablib/packages/openpyxl/namedrange.py new file mode 100644 index 0000000..617847a --- /dev/null +++ b/tablib/packages/openpyxl/namedrange.py @@ -0,0 +1,68 @@ +# file openpyxl/namedrange.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Track named groups of cells in a worksheet""" + +# Python stdlib imports +import re + +# package imports +from openpyxl.shared.exc import NamedRangeException + +# constants +NAMED_RANGE_RE = re.compile("'?([^']*)'?!((\$([A-Za-z]+))?\$([0-9]+)(:(\$([A-Za-z]+))?(\$([0-9]+)))?)$") + +class NamedRange(object): + """A named group of cells""" + __slots__ = ('name', 'destinations', 'local_only') + + def __init__(self, name, destinations): + self.name = name + self.destinations = destinations + self.local_only = False + + def __str__(self): + return ','.join([u'%s!%s' % (sheet, name) for sheet, name in self.destinations]) + + def __repr__(self): + + return '<%s "%s">' % (self.__class__.__name__, str(self)) + + +def split_named_range(range_string): + """Separate a named range into its component parts""" + + destinations = [] + + for range_string in range_string.split(','): + + match = NAMED_RANGE_RE.match(range_string) + if not match: + raise NamedRangeException('Invalid named range string: "%s"' % range_string) + else: + sheet_name, xlrange = match.groups()[:2] + destinations.append((sheet_name, xlrange)) + + return destinations diff --git a/tablib/packages/openpyxl/reader/__init__.py b/tablib/packages/openpyxl/reader/__init__.py new file mode 100644 index 0000000..a45d67e --- /dev/null +++ b/tablib/packages/openpyxl/reader/__init__.py @@ -0,0 +1,33 @@ +# file openpyxl/reader/__init__.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Imports for the openpyxl.reader namespace.""" + +# package imports +from openpyxl.reader import excel +from openpyxl.reader import strings +from openpyxl.reader import style +from openpyxl.reader import workbook +from openpyxl.reader import worksheet diff --git a/tablib/packages/openpyxl/reader/excel.py b/tablib/packages/openpyxl/reader/excel.py new file mode 100644 index 0000000..ba633e6 --- /dev/null +++ b/tablib/packages/openpyxl/reader/excel.py @@ -0,0 +1,111 @@ +# file openpyxl/reader/excel.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Read an xlsx file into Python""" + +# Python stdlib imports +from zipfile import ZipFile, ZIP_DEFLATED, BadZipfile + +# package imports +from openpyxl.shared.exc import OpenModeError, InvalidFileException +from openpyxl.shared.ooxml import ARC_SHARED_STRINGS, ARC_CORE, ARC_APP, \ + ARC_WORKBOOK, PACKAGE_WORKSHEETS, ARC_STYLE +from openpyxl.workbook import Workbook +from openpyxl.reader.strings import read_string_table +from openpyxl.reader.style import read_style_table +from openpyxl.reader.workbook import read_sheets_titles, read_named_ranges, \ + read_properties_core, get_sheet_ids +from openpyxl.reader.worksheet import read_worksheet +from openpyxl.reader.iter_worksheet import unpack_worksheet + +def load_workbook(filename, use_iterators = False): + """Open the given filename and return the workbook + + :param filename: the path to open + :type filename: string + + :param use_iterators: use lazy load for cells + :type use_iterators: bool + + :rtype: :class:`openpyxl.workbook.Workbook` + + .. note:: + + When using lazy load, all worksheets will be :class:`openpyxl.reader.iter_worksheet.IterableWorksheet` + and the returned workbook will be read-only. + + """ + + if isinstance(filename, file): + # fileobject must have been opened with 'rb' flag + # it is required by zipfile + if 'b' not in filename.mode: + raise OpenModeError("File-object must be opened in binary mode") + + try: + archive = ZipFile(filename, 'r', ZIP_DEFLATED) + except (BadZipfile, RuntimeError, IOError, ValueError), e: + raise InvalidFileException(unicode(e)) + wb = Workbook() + + if use_iterators: + wb._set_optimized_read() + + try: + _load_workbook(wb, archive, filename, use_iterators) + except KeyError, e: + raise InvalidFileException(unicode(e)) + except Exception, e: + raise e + finally: + archive.close() + return wb + +def _load_workbook(wb, archive, filename, use_iterators): + + # get workbook-level information + wb.properties = read_properties_core(archive.read(ARC_CORE)) + try: + string_table = read_string_table(archive.read(ARC_SHARED_STRINGS)) + except KeyError: + string_table = {} + style_table = read_style_table(archive.read(ARC_STYLE)) + + # get worksheets + wb.worksheets = [] # remove preset worksheet + sheet_names = read_sheets_titles(archive.read(ARC_APP)) + for i, sheet_name in enumerate(sheet_names): + sheet_codename = 'sheet%d.xml' % (i + 1) + worksheet_path = '%s/%s' % (PACKAGE_WORKSHEETS, sheet_codename) + + if not use_iterators: + new_ws = read_worksheet(archive.read(worksheet_path), wb, sheet_name, string_table, style_table) + else: + xml_source = unpack_worksheet(archive, worksheet_path) + new_ws = read_worksheet(xml_source, wb, sheet_name, string_table, style_table, filename, sheet_codename) + #new_ws = read_worksheet(archive.read(worksheet_path), wb, sheet_name, string_table, style_table, filename, sheet_codename) + wb.add_sheet(new_ws, index = i) + + wb._named_ranges = read_named_ranges(archive.read(ARC_WORKBOOK), wb) diff --git a/tablib/packages/openpyxl/reader/iter_worksheet.py b/tablib/packages/openpyxl/reader/iter_worksheet.py new file mode 100644 index 0000000..f8e9399 --- /dev/null +++ b/tablib/packages/openpyxl/reader/iter_worksheet.py @@ -0,0 +1,343 @@ +# file openpyxl/reader/iter_worksheet.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +""" Iterators-based worksheet reader +*Still very raw* +""" + +from StringIO import StringIO +import warnings +import operator +from functools import partial +from itertools import ifilter, groupby +from openpyxl.worksheet import Worksheet +from openpyxl.cell import coordinate_from_string, get_column_letter, Cell +from openpyxl.reader.excel import get_sheet_ids +from openpyxl.reader.strings import read_string_table +from openpyxl.reader.style import read_style_table, NumberFormat +from openpyxl.shared.date_time import SharedDate +from openpyxl.reader.worksheet import read_dimension +from openpyxl.shared.ooxml import (MIN_COLUMN, MAX_COLUMN, PACKAGE_WORKSHEETS, + MAX_ROW, MIN_ROW, ARC_SHARED_STRINGS, ARC_APP, ARC_STYLE) +from xml.etree.cElementTree import iterparse +from zipfile import ZipFile +import openpyxl.cell +import re +import tempfile +import zlib +import zipfile +import struct + +TYPE_NULL = Cell.TYPE_NULL +MISSING_VALUE = None + +RE_COORDINATE = re.compile('^([A-Z]+)([0-9]+)$') + +SHARED_DATE = SharedDate() + +_COL_CONVERSION_CACHE = dict((get_column_letter(i), i) for i in xrange(1, 18279)) +def column_index_from_string(str_col, _col_conversion_cache=_COL_CONVERSION_CACHE): + # we use a function argument to get indexed name lookup + return _col_conversion_cache[str_col] +del _COL_CONVERSION_CACHE + +RAW_ATTRIBUTES = ['row', 'column', 'coordinate', 'internal_value', 'data_type', 'style_id', 'number_format'] + +try: + from collections import namedtuple + BaseRawCell = namedtuple('RawCell', RAW_ATTRIBUTES) +except ImportError: + + warnings.warn("""Unable to import 'namedtuple' module, this may cause memory issues when using optimized reader. Please upgrade your Python installation to 2.6+""") + + class BaseRawCell(object): + + def __init__(self, *args): + assert len(args)==len(RAW_ATTRIBUTES) + + for attr, val in zip(RAW_ATTRIBUTES, args): + setattr(self, attr, val) + + def _replace(self, **kwargs): + + self.__dict__.update(kwargs) + + return self + + +class RawCell(BaseRawCell): + """Optimized version of the :class:`openpyxl.cell.Cell`, using named tuples. + + Useful attributes are: + + * row + * column + * coordinate + * internal_value + + You can also access if needed: + + * data_type + * number_format + + """ + + @property + def is_date(self): + res = (self.data_type == Cell.TYPE_NUMERIC + and self.number_format is not None + and ('d' in self.number_format + or 'm' in self.number_format + or 'y' in self.number_format + or 'h' in self.number_format + or 's' in self.number_format + )) + + return res + +def iter_rows(workbook_name, sheet_name, xml_source, range_string = '', row_offset = 0, column_offset = 0): + + archive = get_archive_file(workbook_name) + + source = xml_source + + if range_string: + min_col, min_row, max_col, max_row = get_range_boundaries(range_string, row_offset, column_offset) + else: + min_col, min_row, max_col, max_row = read_dimension(xml_source = source) + min_col = column_index_from_string(min_col) + max_col = column_index_from_string(max_col) + 1 + max_row += 6 + + try: + string_table = read_string_table(archive.read(ARC_SHARED_STRINGS)) + except KeyError: + string_table = {} + + style_table = read_style_table(archive.read(ARC_STYLE)) + + source.seek(0) + p = iterparse(source) + + return get_squared_range(p, min_col, min_row, max_col, max_row, string_table, style_table) + + +def get_rows(p, min_column = MIN_COLUMN, min_row = MIN_ROW, max_column = MAX_COLUMN, max_row = MAX_ROW): + + return groupby(get_cells(p, min_row, min_column, max_row, max_column), operator.attrgetter('row')) + +def get_cells(p, min_row, min_col, max_row, max_col, _re_coordinate=RE_COORDINATE): + + for _event, element in p: + + if element.tag == '{http://schemas.openxmlformats.org/spreadsheetml/2006/main}c': + coord = element.get('r') + column_str, row = _re_coordinate.match(coord).groups() + + row = int(row) + column = column_index_from_string(column_str) + + if min_col <= column <= max_col and min_row <= row <= max_row: + data_type = element.get('t', 'n') + style_id = element.get('s') + value = element.findtext('{http://schemas.openxmlformats.org/spreadsheetml/2006/main}v') + yield RawCell(row, column_str, coord, value, data_type, style_id, None) + + if element.tag == '{http://schemas.openxmlformats.org/spreadsheetml/2006/main}v': + continue + element.clear() + + + +def get_range_boundaries(range_string, row = 0, column = 0): + + if ':' in range_string: + min_range, max_range = range_string.split(':') + min_col, min_row = coordinate_from_string(min_range) + max_col, max_row = coordinate_from_string(max_range) + + min_col = column_index_from_string(min_col) + column + max_col = column_index_from_string(max_col) + column + min_row += row + max_row += row + + else: + min_col, min_row = coordinate_from_string(range_string) + min_col = column_index_from_string(min_col) + max_col = min_col + 1 + max_row = min_row + + return (min_col, min_row, max_col, max_row) + +def get_archive_file(archive_name): + + return ZipFile(archive_name, 'r') + +def get_xml_source(archive_file, sheet_name): + + return archive_file.read('%s/%s' % (PACKAGE_WORKSHEETS, sheet_name)) + +def get_missing_cells(row, columns): + + return dict([(column, RawCell(row, column, '%s%s' % (column, row), MISSING_VALUE, TYPE_NULL, None, None)) for column in columns]) + +def get_squared_range(p, min_col, min_row, max_col, max_row, string_table, style_table): + + expected_columns = [get_column_letter(ci) for ci in xrange(min_col, max_col)] + + current_row = min_row + for row, cells in get_rows(p, min_row = min_row, max_row = max_row, min_column = min_col, max_column = max_col): + full_row = [] + if current_row < row: + + for gap_row in xrange(current_row, row): + + dummy_cells = get_missing_cells(gap_row, expected_columns) + + yield tuple([dummy_cells[column] for column in expected_columns]) + + current_row = row + + temp_cells = list(cells) + + retrieved_columns = dict([(c.column, c) for c in temp_cells]) + + missing_columns = list(set(expected_columns) - set(retrieved_columns.keys())) + + replacement_columns = get_missing_cells(row, missing_columns) + + for column in expected_columns: + + if column in retrieved_columns: + cell = retrieved_columns[column] + + if cell.style_id is not None: + style = style_table[int(cell.style_id)] + cell = cell._replace(number_format = style.number_format.format_code) #pylint: disable-msg=W0212 + if cell.internal_value is not None: + if cell.data_type == Cell.TYPE_STRING: + cell = cell._replace(internal_value = string_table[int(cell.internal_value)]) #pylint: disable-msg=W0212 + elif cell.data_type == Cell.TYPE_BOOL: + cell = cell._replace(internal_value = cell.internal_value == 'True') + elif cell.is_date: + cell = cell._replace(internal_value = SHARED_DATE.from_julian(float(cell.internal_value))) + elif cell.data_type == Cell.TYPE_NUMERIC: + cell = cell._replace(internal_value = float(cell.internal_value)) + full_row.append(cell) + + else: + full_row.append(replacement_columns[column]) + + current_row = row + 1 + + yield tuple(full_row) + +#------------------------------------------------------------------------------ + +class IterableWorksheet(Worksheet): + + def __init__(self, parent_workbook, title, workbook_name, + sheet_codename, xml_source): + + Worksheet.__init__(self, parent_workbook, title) + self._workbook_name = workbook_name + self._sheet_codename = sheet_codename + self._xml_source = xml_source + + def iter_rows(self, range_string = '', row_offset = 0, column_offset = 0): + """ Returns a squared range based on the `range_string` parameter, + using generators. + + :param range_string: range of cells (e.g. 'A1:C4') + :type range_string: string + + :param row: row index of the cell (e.g. 4) + :type row: int + + :param column: column index of the cell (e.g. 3) + :type column: int + + :rtype: generator + + """ + + return iter_rows(workbook_name = self._workbook_name, + sheet_name = self._sheet_codename, + xml_source = self._xml_source, + range_string = range_string, + row_offset = row_offset, + column_offset = column_offset) + + def cell(self, *args, **kwargs): + + raise NotImplementedError("use 'iter_rows()' instead") + + def range(self, *args, **kwargs): + + raise NotImplementedError("use 'iter_rows()' instead") + +def unpack_worksheet(archive, filename): + + temp_file = tempfile.TemporaryFile(mode='r+', prefix='openpyxl.', suffix='.unpack.temp') + + zinfo = archive.getinfo(filename) + + if zinfo.compress_type == zipfile.ZIP_STORED: + decoder = None + elif zinfo.compress_type == zipfile.ZIP_DEFLATED: + decoder = zlib.decompressobj(-zlib.MAX_WBITS) + else: + raise zipfile.BadZipFile("Unrecognized compression method") + + archive.fp.seek(_get_file_offset(archive, zinfo)) + bytes_to_read = zinfo.compress_size + + while True: + buff = archive.fp.read(min(bytes_to_read, 102400)) + if not buff: + break + bytes_to_read -= len(buff) + if decoder: + buff = decoder.decompress(buff) + temp_file.write(buff) + + if decoder: + temp_file.write(decoder.decompress('Z')) + + return temp_file + +def _get_file_offset(archive, zinfo): + + try: + return zinfo.file_offset + except AttributeError: + # From http://stackoverflow.com/questions/3781261/how-to-simulate-zipfile-open-in-python-2-5 + + # Seek over the fixed size fields to the "file name length" field in + # the file header (26 bytes). Unpack this and the "extra field length" + # field ourselves as info.extra doesn't seem to be the correct length. + archive.fp.seek(zinfo.header_offset + 26) + file_name_len, extra_len = struct.unpack(" 10000: + msg = 'Year not supported by Excel: %s' % year + raise ValueError(msg) + if self.excel_base_date == self.CALENDAR_WINDOWS_1900: + # Fudge factor for the erroneous fact that the year 1900 is + # treated as a Leap Year in MS Excel. This affects every date + # following 28th February 1900 + if year == 1900 and month <= 2: + excel_1900_leap_year = False + else: + excel_1900_leap_year = True + excel_base_date = 2415020 + else: + raise NotImplementedError('Mac dates are not yet supported.') + #excel_base_date = 2416481 + #excel_1900_leap_year = False + + # Julian base date adjustment + if month > 2: + month = month - 3 + else: + month = month + 9 + year -= 1 + + # Calculate the Julian Date, then subtract the Excel base date + # JD 2415020 = 31 - Dec - 1899 -> Excel Date of 0 + century, decade = int(str(year)[:2]), int(str(year)[2:]) + excel_date = floor(146097 * century / 4) + \ + floor((1461 * decade) / 4) + floor((153 * month + 2) / 5) + \ + day + 1721119 - excel_base_date + if excel_1900_leap_year: + excel_date += 1 + + # check to ensure that we exclude 2/29/1900 as a possible value + if self.excel_base_date == self.CALENDAR_WINDOWS_1900 \ + and excel_date == 60: + msg = 'Error: Excel believes 1900 was a leap year' + raise ValueError(msg) + excel_time = ((hours * 3600) + (minutes * 60) + seconds) / 86400 + return excel_date + excel_time + + def from_julian(self, value=0): + """Convert from the Excel JD back to a date""" + if self.excel_base_date == self.CALENDAR_WINDOWS_1900: + excel_base_date = 25569 + if value < 60: + excel_base_date -= 1 + elif value == 60: + msg = 'Error: Excel believes 1900 was a leap year' + raise ValueError(msg) + else: + raise NotImplementedError('Mac dates are not yet supported.') + #excel_base_date = 24107 + + if value >= 1: + utc_days = value - excel_base_date + + return EPOCH + datetime.timedelta(days=utc_days) + + elif value >= 0: + hours = floor(value * 24) + mins = floor(value * 24 * 60) - floor(hours * 60) + secs = floor(value * 24 * 60 * 60) - floor(hours * 60 * 60) - \ + floor(mins * 60) + return datetime.time(int(hours), int(mins), int(secs)) + else: + msg = 'Negative dates (%s) are not supported' % value + raise ValueError(msg) diff --git a/tablib/packages/openpyxl/shared/exc.py b/tablib/packages/openpyxl/shared/exc.py new file mode 100644 index 0000000..94a3e2c --- /dev/null +++ b/tablib/packages/openpyxl/shared/exc.py @@ -0,0 +1,59 @@ +# file openpyxl/shared/exc.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Definitions for openpyxl shared exception classes.""" + + +class CellCoordinatesException(Exception): + """Error for converting between numeric and A1-style cell references.""" + +class ColumnStringIndexException(Exception): + """Error for bad column names in A1-style cell references.""" + +class DataTypeException(Exception): + """Error for any data type inconsistencies.""" + +class NamedRangeException(Exception): + """Error for badly formatted named ranges.""" + +class SheetTitleException(Exception): + """Error for bad sheet names.""" + +class InsufficientCoordinatesException(Exception): + """Error for partially specified cell coordinates.""" + +class OpenModeError(Exception): + """Error for fileobj opened in non-binary mode.""" + +class InvalidFileException(Exception): + """Error for trying to open a non-ooxml file.""" + +class ReadOnlyWorkbookException(Exception): + """Error for trying to modify a read-only workbook""" + +class MissingNumberFormat(Exception): + """Error when a referenced number format is not in the stylesheet""" + + diff --git a/tablib/packages/openpyxl/shared/ooxml.py b/tablib/packages/openpyxl/shared/ooxml.py new file mode 100644 index 0000000..979b172 --- /dev/null +++ b/tablib/packages/openpyxl/shared/ooxml.py @@ -0,0 +1,60 @@ +# file openpyxl/shared/ooxml.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Constants for fixed paths in a file and xml namespace urls.""" + +MIN_ROW = 0 +MIN_COLUMN = 0 +MAX_COLUMN = 16384 +MAX_ROW = 1048576 + +# constants +PACKAGE_PROPS = 'docProps' +PACKAGE_XL = 'xl' +PACKAGE_RELS = '_rels' +PACKAGE_THEME = PACKAGE_XL + '/' + 'theme' +PACKAGE_WORKSHEETS = PACKAGE_XL + '/' + 'worksheets' +PACKAGE_DRAWINGS = PACKAGE_XL + '/' + 'drawings' +PACKAGE_CHARTS = PACKAGE_XL + '/' + 'charts' + +ARC_CONTENT_TYPES = '[Content_Types].xml' +ARC_ROOT_RELS = PACKAGE_RELS + '/.rels' +ARC_WORKBOOK_RELS = PACKAGE_XL + '/' + PACKAGE_RELS + '/workbook.xml.rels' +ARC_CORE = PACKAGE_PROPS + '/core.xml' +ARC_APP = PACKAGE_PROPS + '/app.xml' +ARC_WORKBOOK = PACKAGE_XL + '/workbook.xml' +ARC_STYLE = PACKAGE_XL + '/styles.xml' +ARC_THEME = PACKAGE_THEME + '/theme1.xml' +ARC_SHARED_STRINGS = PACKAGE_XL + '/sharedStrings.xml' + +NAMESPACES = { + 'cp': 'http://schemas.openxmlformats.org/package/2006/metadata/core-properties', + 'dc': 'http://purl.org/dc/elements/1.1/', + 'dcterms': 'http://purl.org/dc/terms/', + 'dcmitype': 'http://purl.org/dc/dcmitype/', + 'xsi': 'http://www.w3.org/2001/XMLSchema-instance', + 'vt': 'http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes', + 'xml': 'http://www.w3.org/XML/1998/namespace' +} diff --git a/tablib/packages/openpyxl/shared/password_hasher.py b/tablib/packages/openpyxl/shared/password_hasher.py new file mode 100644 index 0000000..b5d0dd0 --- /dev/null +++ b/tablib/packages/openpyxl/shared/password_hasher.py @@ -0,0 +1,47 @@ +# file openpyxl/shared/password_hasher.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Basic password hashing.""" + + +def hash_password(plaintext_password=''): + """Create a password hash from a given string. + + This method is based on the algorithm provided by + Daniel Rentz of OpenOffice and the PEAR package + Spreadsheet_Excel_Writer by Xavier Noguer . + + """ + password = 0x0000 + i = 1 + for char in plaintext_password: + value = ord(char) << i + rotated_bits = value >> 15 + value &= 0x7fff + password ^= (value | rotated_bits) + i += 1 + password ^= len(plaintext_password) + password ^= 0xCE4B + return str(hex(password)).upper()[2:] diff --git a/tablib/packages/openpyxl/shared/units.py b/tablib/packages/openpyxl/shared/units.py new file mode 100644 index 0000000..fba82d7 --- /dev/null +++ b/tablib/packages/openpyxl/shared/units.py @@ -0,0 +1,67 @@ +# file openpyxl/shared/units.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +import math + +def pixels_to_EMU(value): + return int(round(value * 9525)) + +def EMU_to_pixels(value): + if not value: + return 0 + else: + return round(value / 9525.) + +def EMU_to_cm(value): + if not value: + return 0 + else: + return (EMU_to_pixels(value) * 2.57 / 96) + +def pixels_to_points(value): + return value * 0.67777777 + +def points_to_pixels(value): + if not value: + return 0 + else: + return int(math.ceil(value * 1.333333333)) + +def degrees_to_angle(value): + return int(round(value * 60000)) + +def angle_to_degrees(value): + if not value: + return 0 + else: + return round(value / 60000.) + +def short_color(color): + """ format a color to its short size """ + + if len(color) > 6: + return color[2:] + else: + return color diff --git a/tablib/packages/openpyxl/shared/xmltools.py b/tablib/packages/openpyxl/shared/xmltools.py new file mode 100644 index 0000000..9f0f943 --- /dev/null +++ b/tablib/packages/openpyxl/shared/xmltools.py @@ -0,0 +1,96 @@ +# file openpyxl/shared/xmltools.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Shared xml tools. + +Shortcut functions taken from: + http://lethain.com/entry/2009/jan/22/handling-very-large-csv-and-xml-files-in-python/ + +""" + +# Python stdlib imports +from xml.sax.xmlreader import AttributesNSImpl +from xml.sax.saxutils import XMLGenerator +try: + from xml.etree.ElementTree import ElementTree, Element, SubElement, \ + QName, fromstring, tostring +except ImportError: + from cElementTree import ElementTree, Element, SubElement, \ + QName, fromstring, tostring + +# package imports +from openpyxl import __name__ as prefix + + +def get_document_content(xml_node): + """Print nicely formatted xml to a string.""" + pretty_indent(xml_node) + return tostring(xml_node, 'utf-8') + + +def pretty_indent(elem, level=0): + """Format xml with nice indents and line breaks.""" + i = "\n" + level * " " + if len(elem): + if not elem.text or not elem.text.strip(): + elem.text = i + " " + if not elem.tail or not elem.tail.strip(): + elem.tail = i + for elem in elem: + pretty_indent(elem, level + 1) + if not elem.tail or not elem.tail.strip(): + elem.tail = i + else: + if level and (not elem.tail or not elem.tail.strip()): + elem.tail = i + + +def start_tag(doc, name, attr=None, body=None, namespace=None): + """Wrapper to start an xml tag.""" + if attr is None: + attr = {} + attr_vals = {} + attr_keys = {} + for key, val in attr.iteritems(): + key_tuple = (namespace, key) + attr_vals[key_tuple] = val + attr_keys[key_tuple] = key + attr2 = AttributesNSImpl(attr_vals, attr_keys) + doc.startElementNS((namespace, name), name, attr2) + if body: + doc.characters(body) + + +def end_tag(doc, name, namespace=None): + """Wrapper to close an xml tag.""" + doc.endElementNS((namespace, name), name) + + +def tag(doc, name, attr=None, body=None, namespace=None): + """Wrapper to print xml tags and comments.""" + if attr is None: + attr = {} + start_tag(doc, name, attr, body, namespace) + end_tag(doc, name, namespace) diff --git a/tablib/packages/openpyxl/style.py b/tablib/packages/openpyxl/style.py new file mode 100644 index 0000000..0828105 --- /dev/null +++ b/tablib/packages/openpyxl/style.py @@ -0,0 +1,392 @@ +# file openpyxl/style.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Style and formatting option tracking.""" + +# Python stdlib imports +import re +try: + from hashlib import md5 +except ImportError: + from md5 import md5 + + +class HashableObject(object): + """Define how to hash property classes.""" + __fields__ = None + __leaf__ = False + + def __repr__(self): + + return ':'.join([repr(getattr(self, x)) for x in self.__fields__]) + + def __hash__(self): + +# return int(md5(repr(self)).hexdigest(), 16) + return hash(repr(self)) + +class Color(HashableObject): + """Named colors for use in styles.""" + BLACK = 'FF000000' + WHITE = 'FFFFFFFF' + RED = 'FFFF0000' + DARKRED = 'FF800000' + BLUE = 'FF0000FF' + DARKBLUE = 'FF000080' + GREEN = 'FF00FF00' + DARKGREEN = 'FF008000' + YELLOW = 'FFFFFF00' + DARKYELLOW = 'FF808000' + + __fields__ = ('index',) + __slots__ = __fields__ + __leaf__ = True + + def __init__(self, index): + super(Color, self).__init__() + self.index = index + + +class Font(HashableObject): + """Font options used in styles.""" + UNDERLINE_NONE = 'none' + UNDERLINE_DOUBLE = 'double' + UNDERLINE_DOUBLE_ACCOUNTING = 'doubleAccounting' + UNDERLINE_SINGLE = 'single' + UNDERLINE_SINGLE_ACCOUNTING = 'singleAccounting' + + __fields__ = ('name', + 'size', + 'bold', + 'italic', + 'superscript', + 'subscript', + 'underline', + 'strikethrough', + 'color') + __slots__ = __fields__ + + def __init__(self): + super(Font, self).__init__() + self.name = 'Calibri' + self.size = 11 + self.bold = False + self.italic = False + self.superscript = False + self.subscript = False + self.underline = self.UNDERLINE_NONE + self.strikethrough = False + self.color = Color(Color.BLACK) + + +class Fill(HashableObject): + """Area fill patterns for use in styles.""" + FILL_NONE = 'none' + FILL_SOLID = 'solid' + FILL_GRADIENT_LINEAR = 'linear' + FILL_GRADIENT_PATH = 'path' + FILL_PATTERN_DARKDOWN = 'darkDown' + FILL_PATTERN_DARKGRAY = 'darkGray' + FILL_PATTERN_DARKGRID = 'darkGrid' + FILL_PATTERN_DARKHORIZONTAL = 'darkHorizontal' + FILL_PATTERN_DARKTRELLIS = 'darkTrellis' + FILL_PATTERN_DARKUP = 'darkUp' + FILL_PATTERN_DARKVERTICAL = 'darkVertical' + FILL_PATTERN_GRAY0625 = 'gray0625' + FILL_PATTERN_GRAY125 = 'gray125' + FILL_PATTERN_LIGHTDOWN = 'lightDown' + FILL_PATTERN_LIGHTGRAY = 'lightGray' + FILL_PATTERN_LIGHTGRID = 'lightGrid' + FILL_PATTERN_LIGHTHORIZONTAL = 'lightHorizontal' + FILL_PATTERN_LIGHTTRELLIS = 'lightTrellis' + FILL_PATTERN_LIGHTUP = 'lightUp' + FILL_PATTERN_LIGHTVERTICAL = 'lightVertical' + FILL_PATTERN_MEDIUMGRAY = 'mediumGray' + + __fields__ = ('fill_type', + 'rotation', + 'start_color', + 'end_color') + __slots__ = __fields__ + + def __init__(self): + super(Fill, self).__init__() + self.fill_type = self.FILL_NONE + self.rotation = 0 + self.start_color = Color(Color.WHITE) + self.end_color = Color(Color.BLACK) + + +class Border(HashableObject): + """Border options for use in styles.""" + BORDER_NONE = 'none' + BORDER_DASHDOT = 'dashDot' + BORDER_DASHDOTDOT = 'dashDotDot' + BORDER_DASHED = 'dashed' + BORDER_DOTTED = 'dotted' + BORDER_DOUBLE = 'double' + BORDER_HAIR = 'hair' + BORDER_MEDIUM = 'medium' + BORDER_MEDIUMDASHDOT = 'mediumDashDot' + BORDER_MEDIUMDASHDOTDOT = 'mediumDashDotDot' + BORDER_MEDIUMDASHED = 'mediumDashed' + BORDER_SLANTDASHDOT = 'slantDashDot' + BORDER_THICK = 'thick' + BORDER_THIN = 'thin' + + __fields__ = ('border_style', + 'color') + __slots__ = __fields__ + + def __init__(self): + super(Border, self).__init__() + self.border_style = self.BORDER_NONE + self.color = Color(Color.BLACK) + + +class Borders(HashableObject): + """Border positioning for use in styles.""" + DIAGONAL_NONE = 0 + DIAGONAL_UP = 1 + DIAGONAL_DOWN = 2 + DIAGONAL_BOTH = 3 + + __fields__ = ('left', + 'right', + 'top', + 'bottom', + 'diagonal', + 'diagonal_direction', + 'all_borders', + 'outline', + 'inside', + 'vertical', + 'horizontal') + __slots__ = __fields__ + + def __init__(self): + super(Borders, self).__init__() + self.left = Border() + self.right = Border() + self.top = Border() + self.bottom = Border() + self.diagonal = Border() + self.diagonal_direction = self.DIAGONAL_NONE + + self.all_borders = Border() + self.outline = Border() + self.inside = Border() + self.vertical = Border() + self.horizontal = Border() + + +class Alignment(HashableObject): + """Alignment options for use in styles.""" + HORIZONTAL_GENERAL = 'general' + HORIZONTAL_LEFT = 'left' + HORIZONTAL_RIGHT = 'right' + HORIZONTAL_CENTER = 'center' + HORIZONTAL_CENTER_CONTINUOUS = 'centerContinuous' + HORIZONTAL_JUSTIFY = 'justify' + VERTICAL_BOTTOM = 'bottom' + VERTICAL_TOP = 'top' + VERTICAL_CENTER = 'center' + VERTICAL_JUSTIFY = 'justify' + + __fields__ = ('horizontal', + 'vertical', + 'text_rotation', + 'wrap_text', + 'shrink_to_fit', + 'indent') + __slots__ = __fields__ + __leaf__ = True + + def __init__(self): + super(Alignment, self).__init__() + self.horizontal = self.HORIZONTAL_GENERAL + self.vertical = self.VERTICAL_BOTTOM + self.text_rotation = 0 + self.wrap_text = False + self.shrink_to_fit = False + self.indent = 0 + + +class NumberFormat(HashableObject): + """Numer formatting for use in styles.""" + FORMAT_GENERAL = 'General' + FORMAT_TEXT = '@' + FORMAT_NUMBER = '0' + FORMAT_NUMBER_00 = '0.00' + FORMAT_NUMBER_COMMA_SEPARATED1 = '#,##0.00' + FORMAT_NUMBER_COMMA_SEPARATED2 = '#,##0.00_-' + FORMAT_PERCENTAGE = '0%' + FORMAT_PERCENTAGE_00 = '0.00%' + FORMAT_DATE_YYYYMMDD2 = 'yyyy-mm-dd' + FORMAT_DATE_YYYYMMDD = 'yy-mm-dd' + FORMAT_DATE_DDMMYYYY = 'dd/mm/yy' + FORMAT_DATE_DMYSLASH = 'd/m/y' + FORMAT_DATE_DMYMINUS = 'd-m-y' + FORMAT_DATE_DMMINUS = 'd-m' + FORMAT_DATE_MYMINUS = 'm-y' + FORMAT_DATE_XLSX14 = 'mm-dd-yy' + FORMAT_DATE_XLSX15 = 'd-mmm-yy' + FORMAT_DATE_XLSX16 = 'd-mmm' + FORMAT_DATE_XLSX17 = 'mmm-yy' + FORMAT_DATE_XLSX22 = 'm/d/yy h:mm' + FORMAT_DATE_DATETIME = 'd/m/y h:mm' + FORMAT_DATE_TIME1 = 'h:mm AM/PM' + FORMAT_DATE_TIME2 = 'h:mm:ss AM/PM' + FORMAT_DATE_TIME3 = 'h:mm' + FORMAT_DATE_TIME4 = 'h:mm:ss' + FORMAT_DATE_TIME5 = 'mm:ss' + FORMAT_DATE_TIME6 = 'h:mm:ss' + FORMAT_DATE_TIME7 = 'i:s.S' + FORMAT_DATE_TIME8 = 'h:mm:ss@' + FORMAT_DATE_YYYYMMDDSLASH = 'yy/mm/dd@' + FORMAT_CURRENCY_USD_SIMPLE = '"$"#,##0.00_-' + FORMAT_CURRENCY_USD = '$#,##0_-' + FORMAT_CURRENCY_EUR_SIMPLE = '[$EUR ]#,##0.00_-' + _BUILTIN_FORMATS = { + 0: 'General', + 1: '0', + 2: '0.00', + 3: '#,##0', + 4: '#,##0.00', + + 9: '0%', + 10: '0.00%', + 11: '0.00E+00', + 12: '# ?/?', + 13: '# ??/??', + 14: 'mm-dd-yy', + 15: 'd-mmm-yy', + 16: 'd-mmm', + 17: 'mmm-yy', + 18: 'h:mm AM/PM', + 19: 'h:mm:ss AM/PM', + 20: 'h:mm', + 21: 'h:mm:ss', + 22: 'm/d/yy h:mm', + + 37: '#,##0 (#,##0)', + 38: '#,##0 [Red](#,##0)', + 39: '#,##0.00(#,##0.00)', + 40: '#,##0.00[Red](#,##0.00)', + + 41: '_(* #,##0_);_(* \(#,##0\);_(* "-"_);_(@_)', + 42: '_("$"* #,##0_);_("$"* \(#,##0\);_("$"* "-"_);_(@_)', + 43: '_(* #,##0.00_);_(* \(#,##0.00\);_(* "-"??_);_(@_)', + + 44: '_("$"* #,##0.00_)_("$"* \(#,##0.00\)_("$"* "-"??_)_(@_)', + 45: 'mm:ss', + 46: '[h]:mm:ss', + 47: 'mmss.0', + 48: '##0.0E+0', + 49: '@', } + _BUILTIN_FORMATS_REVERSE = dict( + [(value, key) for key, value in _BUILTIN_FORMATS.iteritems()]) + + __fields__ = ('_format_code', + '_format_index') + __slots__ = __fields__ + __leaf__ = True + + DATE_INDICATORS = 'dmyhs' + + def __init__(self): + super(NumberFormat, self).__init__() + self._format_code = self.FORMAT_GENERAL + self._format_index = 0 + + def _set_format_code(self, format_code = FORMAT_GENERAL): + """Setter for the format_code property.""" + self._format_code = format_code + self._format_index = self.builtin_format_id(format = format_code) + + def _get_format_code(self): + """Getter for the format_code property.""" + return self._format_code + + format_code = property(_get_format_code, _set_format_code) + + def builtin_format_code(self, index): + """Return one of the standard format codes by index.""" + return self._BUILTIN_FORMATS[index] + + def is_builtin(self, format = None): + """Check if a format code is a standard format code.""" + if format is None: + format = self._format_code + return format in self._BUILTIN_FORMATS.values() + + def builtin_format_id(self, format): + """Return the id of a standard style.""" + return self._BUILTIN_FORMATS_REVERSE.get(format, None) + + def is_date_format(self, format = None): + """Check if the number format is actually representing a date.""" + if format is None: + format = self._format_code + + return any([x in format for x in self.DATE_INDICATORS]) + +class Protection(HashableObject): + """Protection options for use in styles.""" + PROTECTION_INHERIT = 'inherit' + PROTECTION_PROTECTED = 'protected' + PROTECTION_UNPROTECTED = 'unprotected' + + __fields__ = ('locked', + 'hidden') + __slots__ = __fields__ + __leaf__ = True + + def __init__(self): + super(Protection, self).__init__() + self.locked = self.PROTECTION_INHERIT + self.hidden = self.PROTECTION_INHERIT + + +class Style(HashableObject): + """Style object containing all formatting details.""" + __fields__ = ('font', + 'fill', + 'borders', + 'alignment', + 'number_format', + 'protection') + __slots__ = __fields__ + + def __init__(self): + super(Style, self).__init__() + self.font = Font() + self.fill = Fill() + self.borders = Borders() + self.alignment = Alignment() + self.number_format = NumberFormat() + self.protection = Protection() + +DEFAULTS = Style() diff --git a/tablib/packages/openpyxl/tests/__init__.py b/tablib/packages/openpyxl/tests/__init__.py new file mode 100644 index 0000000..de89032 --- /dev/null +++ b/tablib/packages/openpyxl/tests/__init__.py @@ -0,0 +1,24 @@ +# file openpyxl/tests/__init__.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni diff --git a/tablib/packages/openpyxl/tests/helper.py b/tablib/packages/openpyxl/tests/helper.py new file mode 100644 index 0000000..ae9c8b4 --- /dev/null +++ b/tablib/packages/openpyxl/tests/helper.py @@ -0,0 +1,94 @@ +# file openpyxl/tests/helper.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from __future__ import with_statement +import os +import os.path +import shutil +import difflib +from StringIO import StringIO +from pprint import pprint +from tempfile import gettempdir + +# package imports +from openpyxl.shared.xmltools import fromstring, ElementTree +from openpyxl.shared.xmltools import pretty_indent + +# constants +DATADIR = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test_data')) +TMPDIR = os.path.join(gettempdir(), 'openpyxl_test_temp') + + +def make_tmpdir(): + try: + os.makedirs(TMPDIR) + except OSError: + pass + + +def clean_tmpdir(): + if os.path.isdir(TMPDIR): + shutil.rmtree(TMPDIR, ignore_errors = True) + + +def assert_equals_file_content(reference_file, fixture, filetype = 'xml'): + if os.path.isfile(fixture): + with open(fixture) as fixture_file: + fixture_content = fixture_file.read() + else: + fixture_content = fixture + + with open(reference_file) as expected_file: + expected_content = expected_file.read() + + if filetype == 'xml': + fixture_content = fromstring(fixture_content) + pretty_indent(fixture_content) + temp = StringIO() + ElementTree(fixture_content).write(temp) + fixture_content = temp.getvalue() + + expected_content = fromstring(expected_content) + pretty_indent(expected_content) + temp = StringIO() + ElementTree(expected_content).write(temp) + expected_content = temp.getvalue() + + fixture_lines = fixture_content.split('\n') + expected_lines = expected_content.split('\n') + differences = list(difflib.unified_diff(expected_lines, fixture_lines)) + if differences: + temp = StringIO() + pprint(differences, stream = temp) + assert False, 'Differences found : %s' % temp.getvalue() + +def get_xml(xml_node): + + io = StringIO() + ElementTree(xml_node).write(io, encoding = 'UTF-8') + ret = io.getvalue() + io.close() + return ret.replace('\n', '') diff --git a/tablib/packages/openpyxl/tests/test_cell.py b/tablib/packages/openpyxl/tests/test_cell.py new file mode 100644 index 0000000..edc35c0 --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_cell.py @@ -0,0 +1,200 @@ +# file openpyxl/tests/test_cell.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from datetime import time, datetime + +# 3rd party imports +from nose.tools import eq_, raises, assert_raises + +# package imports +from openpyxl.worksheet import Worksheet +from openpyxl.workbook import Workbook +from openpyxl.shared.exc import ColumnStringIndexException, \ + CellCoordinatesException, DataTypeException +from openpyxl.cell import column_index_from_string, \ + coordinate_from_string, get_column_letter, Cell, absolute_coordinate + + +def test_coordinates(): + column, row = coordinate_from_string('ZF46') + eq_("ZF", column) + eq_(46, row) + + +@raises(CellCoordinatesException) +def test_invalid_coordinate(): + coordinate_from_string('AAA') + + +def test_absolute(): + eq_('$ZF$51', absolute_coordinate('ZF51')) + +def test_absolute_multiple(): + + eq_('$ZF$51:$ZF$53', absolute_coordinate('ZF51:ZF$53')) + + +def test_column_index(): + eq_(10, column_index_from_string('J')) + eq_(270, column_index_from_string('jJ')) + eq_(7030, column_index_from_string('jjj')) + + +def test_bad_column_index(): + + @raises(ColumnStringIndexException) + def _check(bad_string): + column_index_from_string(bad_string) + + bad_strings = ('JJJJ', '', '$', '1',) + for bad_string in bad_strings: + yield _check, bad_string + + +def test_column_letter_boundries(): + assert_raises(ColumnStringIndexException, get_column_letter, 0) + assert_raises(ColumnStringIndexException, get_column_letter, 18279) + + +def test_column_letter(): + eq_('ZZZ', get_column_letter(18278)) + eq_('JJJ', get_column_letter(7030)) + eq_('AB', get_column_letter(28)) + eq_('AA', get_column_letter(27)) + eq_('Z', get_column_letter(26)) + + +def test_initial_value(): + cell = Cell(None, 'A', 1, value = '17.5') + eq_(cell.TYPE_NUMERIC, cell.data_type) + + +class TestCellValueTypes(): + + @classmethod + def setup_class(cls): + cls.cell = Cell(None, 'A', 1) + + def test_1st(self): + eq_(self.cell.TYPE_NULL, self.cell.data_type) + + def test_null(self): + self.cell.value = None + eq_(self.cell.TYPE_NULL, self.cell.data_type) + + def test_numeric(self): + + def check_numeric(value): + self.cell.value = value + eq_(self.cell.TYPE_NUMERIC, self.cell.data_type) + + values = (42, '4.2', '-42.000', '0', 0, 0.0001, '0.9999', '99E-02') + for value in values: + yield check_numeric, value + + def test_string(self): + self.cell.value = 'hello' + eq_(self.cell.TYPE_STRING, self.cell.data_type) + + def test_formula(self): + self.cell.value = '=42' + eq_(self.cell.TYPE_FORMULA, self.cell.data_type) + + def test_boolean(self): + self.cell.value = True + eq_(self.cell.TYPE_BOOL, self.cell.data_type) + self.cell.value = False + eq_(self.cell.TYPE_BOOL, self.cell.data_type) + + def test_error_codes(self): + + def check_error(): + eq_(self.cell.TYPE_ERROR, self.cell.data_type) + + for error_string in self.cell.ERROR_CODES.keys(): + self.cell.value = error_string + yield check_error + + +def test_data_type_check(): + cell = Cell(None, 'A', 1) + cell.bind_value(None) + eq_(Cell.TYPE_NULL, cell._data_type) + + cell.bind_value('.0e000') + eq_(Cell.TYPE_NUMERIC, cell._data_type) + + cell.bind_value('-0.e-0') + eq_(Cell.TYPE_NUMERIC, cell._data_type) + + cell.bind_value('1E') + eq_(Cell.TYPE_STRING, cell._data_type) + +@raises(DataTypeException) +def test_set_bad_type(): + cell = Cell(None, 'A', 1) + cell.set_value_explicit(1, 'q') + + +def test_time(): + + def check_time(raw_value, coerced_value): + cell.value = raw_value + eq_(cell.value, coerced_value) + eq_(cell.TYPE_NUMERIC, cell.data_type) + + wb = Workbook() + ws = Worksheet(wb) + cell = Cell(ws, 'A', 1) + values = (('03:40:16', time(3, 40, 16)), ('03:40', time(3, 40)),) + for raw_value, coerced_value in values: + yield check_time, raw_value, coerced_value + + +def test_date_format_on_non_date(): + wb = Workbook() + ws = Worksheet(wb) + cell = Cell(ws, 'A', 1) + cell.value = datetime.now() + cell.value = 'testme' + eq_('testme', cell.value) + + +def test_repr(): + wb = Workbook() + ws = Worksheet(wb) + cell = Cell(ws, 'A', 1) + eq_(repr(cell), '', 'Got bad repr: %s' % repr(cell)) + +def test_is_date(): + wb = Workbook() + ws = Worksheet(wb) + cell = Cell(ws, 'A', 1) + cell.value = datetime.now() + eq_(cell.is_date(), True) + cell.value = 'testme' + eq_('testme', cell.value) + eq_(cell.is_date(), False) diff --git a/tablib/packages/openpyxl/tests/test_chart.py b/tablib/packages/openpyxl/tests/test_chart.py new file mode 100644 index 0000000..2605a2b --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_chart.py @@ -0,0 +1,131 @@ +# file openpyxl/tests/test_chart.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +from nose.tools import eq_ + +from openpyxl.tests.helper import get_xml +from openpyxl.shared.xmltools import Element +from openpyxl.writer.charts import ChartWriter +from openpyxl.workbook import Workbook +from openpyxl.chart import BarChart, ScatterChart, Serie, Reference +from openpyxl.style import Color + +class TestChartWriter(object): + + def setUp(self): + + wb = Workbook() + ws = wb.get_active_sheet() + ws.title = u'data' + for i in range(10): + ws.cell(row = i, column = 0).value = i + self.chart = BarChart() + self.chart.title = 'TITLE' + self.chart.add_serie(Serie(Reference(ws, (0, 0), (10, 0)))) + self.chart._series[-1].color = Color.GREEN + self.cw = ChartWriter(self.chart) + self.root = Element('test') + + def test_write_title(self): + self.cw._write_title(self.root) + eq_(get_xml(self.root), 'TITLE') + + def test_write_xaxis(self): + + self.cw._write_axis(self.root, self.chart.x_axis, 'c:catAx') + eq_(get_xml(self.root), '') + + def test_write_yaxis(self): + + self.cw._write_axis(self.root, self.chart.y_axis, 'c:valAx') + eq_(get_xml(self.root), '') + + def test_write_series(self): + + self.cw._write_series(self.root) + eq_(get_xml(self.root), 'data!$A$1:$A$11General0123456789None') + + def test_write_legend(self): + + self.cw._write_legend(self.root) + eq_(get_xml(self.root), '') + + def test_write_print_settings(self): + + self.cw._write_print_settings(self.root) + eq_(get_xml(self.root), '') + + def test_write_chart(self): + + self.cw._write_chart(self.root) + eq_(get_xml(self.root), 'TITLEdata!$A$1:$A$11General0123456789None') + + +class TestScatterChartWriter(object): + + def setUp(self): + + wb = Workbook() + ws = wb.get_active_sheet() + ws.title = u'data' + for i in range(10): + ws.cell(row = i, column = 0).value = i + ws.cell(row = i, column = 1).value = i + self.scatterchart = ScatterChart() + self.scatterchart.add_serie(Serie(Reference(ws, (0, 0), (10, 0)), + xvalues = Reference(ws, (0, 1), (10, 1)))) + self.cw = ChartWriter(self.scatterchart) + self.root = Element('test') + + def test_write_xaxis(self): + + self.cw._write_axis(self.root, self.scatterchart.x_axis, 'c:valAx') + eq_(get_xml(self.root), '') + + + def test_write_yaxis(self): + + self.cw._write_axis(self.root, self.scatterchart.y_axis, 'c:valAx') + eq_(get_xml(self.root), '') + + def test_write_series(self): + + self.cw._write_series(self.root) + eq_(get_xml(self.root), 'data!$B$1:$B$11General0123456789Nonedata!$A$1:$A$11General0123456789None') + + def test_write_legend(self): + + self.cw._write_legend(self.root) + eq_(get_xml(self.root), '') + + def test_write_print_settings(self): + + self.cw._write_print_settings(self.root) + eq_(get_xml(self.root), '') + + def test_write_chart(self): + + self.cw._write_chart(self.root) + eq_(get_xml(self.root), 'data!$B$1:$B$11General0123456789Nonedata!$A$1:$A$11General0123456789None') diff --git a/tablib/packages/openpyxl/tests/test_dump.py b/tablib/packages/openpyxl/tests/test_dump.py new file mode 100644 index 0000000..58794b7 --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_dump.py @@ -0,0 +1,109 @@ + +# file openpyxl/tests/test_dump.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from datetime import time, datetime + +# 3rd party imports +from nose.tools import eq_, raises, assert_raises + +from openpyxl.workbook import Workbook +from openpyxl.cell import get_column_letter + +from openpyxl.reader.excel import load_workbook + +from openpyxl.writer.strings import StringTableBuilder + +from tempfile import NamedTemporaryFile +import os +import shutil + +def test_dump_sheet(): + + test_file = NamedTemporaryFile(prefix='openpyxl.', suffix='.xlsx', delete=False) + test_file.close() + test_filename = test_file.name + + wb = Workbook(optimized_write = True) + + ws = wb.create_sheet() + + letters = [get_column_letter(x+1) for x in xrange(20)] + + expected_rows = [] + + for row in xrange(20): + + expected_rows.append(['%s%d' % (letter, row+1) for letter in letters]) + + for row in xrange(20): + + expected_rows.append([(row+1) for letter in letters]) + + for row in xrange(10): + + expected_rows.append([datetime(2010, ((x % 12)+1), row+1) for x in range(len(letters))]) + + for row in xrange(20): + + expected_rows.append(['=%s%d' % (letter, row+1) for letter in letters]) + + for row in expected_rows: + + ws.append(row) + + wb.save(test_filename) + + wb2 = load_workbook(test_filename, True) + + ws = wb2.worksheets[0] + + + for ex_row, ws_row in zip(expected_rows[:-20], ws.iter_rows()): + + for ex_cell, ws_cell in zip(ex_row, ws_row): + + eq_(ex_cell, ws_cell.internal_value) + + os.remove(test_filename) + + +def test_table_builder(): + + sb = StringTableBuilder() + + result = {'a':0, 'b':1, 'c':2, 'd':3} + + for letter in sorted(result.keys()): + + for x in range(5): + + sb.add(letter) + + table = dict(sb.get_table()) + + for key,idx in result.iteritems(): + eq_(idx, table[key]) diff --git a/tablib/packages/openpyxl/tests/test_iter.py b/tablib/packages/openpyxl/tests/test_iter.py new file mode 100644 index 0000000..a68237d --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_iter.py @@ -0,0 +1,112 @@ +# file openpyxl/tests/test_iter.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +from nose.tools import eq_, raises, assert_raises +import os.path as osp +from openpyxl.tests.helper import DATADIR +from openpyxl.reader.iter_worksheet import get_range_boundaries +from openpyxl.reader.excel import load_workbook +import datetime + +class TestWorksheet(object): + + workbook_name = osp.join(DATADIR, 'genuine', 'empty.xlsx') + +class TestText(TestWorksheet): + sheet_name = 'Sheet1 - Text' + + expected = [['This is cell A1 in Sheet 1', None, None, None, None, None, None], + [None, None, None, None, None, None, None], + [None, None, None, None, None, None, None], + [None, None, None, None, None, None, None], + [None, None, None, None, None, None, 'This is cell G5'], ] + + def test_read_fast_integrated(self): + + wb = load_workbook(filename = self.workbook_name, use_iterators = True) + ws = wb.get_sheet_by_name(name = self.sheet_name) + + for row, expected_row in zip(ws.iter_rows(), self.expected): + + row_values = [x.internal_value for x in row] + + eq_(row_values, expected_row) + + + def test_get_boundaries_range(self): + + eq_(get_range_boundaries('C1:C4'), (3, 1, 3, 4)) + + def test_get_boundaries_one(self): + + + eq_(get_range_boundaries('C1'), (3, 1, 4, 1)) + + def test_read_single_cell_range(self): + + wb = load_workbook(filename = self.workbook_name, use_iterators = True) + ws = wb.get_sheet_by_name(name = self.sheet_name) + + eq_('This is cell A1 in Sheet 1', list(ws.iter_rows('A1'))[0][0].internal_value) + +class TestIntegers(TestWorksheet): + + sheet_name = 'Sheet2 - Numbers' + + expected = [[x + 1] for x in xrange(30)] + + query_range = 'D1:E30' + + def test_read_fast_integrated(self): + + wb = load_workbook(filename = self.workbook_name, use_iterators = True) + ws = wb.get_sheet_by_name(name = self.sheet_name) + + for row, expected_row in zip(ws.iter_rows(self.query_range), self.expected): + + row_values = [x.internal_value for x in row] + + eq_(row_values, expected_row) + +class TestFloats(TestWorksheet): + + sheet_name = 'Sheet2 - Numbers' + query_range = 'K1:L30' + expected = expected = [[(x + 1) / 100.0] for x in xrange(30)] + +class TestDates(TestWorksheet): + + sheet_name = 'Sheet4 - Dates' + + def test_read_single_cell_date(self): + + wb = load_workbook(filename = self.workbook_name, use_iterators = True) + ws = wb.get_sheet_by_name(name = self.sheet_name) + + eq_(datetime.datetime(1973, 5, 20), list(ws.iter_rows('A1'))[0][0].internal_value) + eq_(datetime.datetime(1973, 5, 20, 9, 15, 2), list(ws.iter_rows('C1'))[0][0].internal_value) + + + diff --git a/tablib/packages/openpyxl/tests/test_meta.py b/tablib/packages/openpyxl/tests/test_meta.py new file mode 100644 index 0000000..3aefdcf --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_meta.py @@ -0,0 +1,50 @@ +# file openpyxl/tests/test_meta.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from __future__ import with_statement +import os.path + +# package imports +from openpyxl.tests.helper import DATADIR, assert_equals_file_content +from openpyxl.writer.workbook import write_content_types, write_root_rels +from openpyxl.workbook import Workbook + + +def test_write_content_types(): + wb = Workbook() + wb.create_sheet() + wb.create_sheet() + content = write_content_types(wb) + reference_file = os.path.join(DATADIR, 'writer', 'expected', + '[Content_Types].xml') + assert_equals_file_content(reference_file, content) + + +def test_write_root_rels(): + wb = Workbook() + content = write_root_rels(wb) + reference_file = os.path.join(DATADIR, 'writer', 'expected', '.rels') + assert_equals_file_content(reference_file, content) diff --git a/tablib/packages/openpyxl/tests/test_named_range.py b/tablib/packages/openpyxl/tests/test_named_range.py new file mode 100644 index 0000000..a56ed86 --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_named_range.py @@ -0,0 +1,102 @@ +# file openpyxl/tests/test_named_range.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from __future__ import with_statement +import os.path + +# 3rd-party imports +from nose.tools import eq_, assert_raises + +# package imports +from openpyxl.tests.helper import DATADIR +from openpyxl.namedrange import split_named_range +from openpyxl.reader.workbook import read_named_ranges +from openpyxl.shared.exc import NamedRangeException +from openpyxl.reader.excel import load_workbook + + +def test_split(): + eq_([('My Sheet', '$D$8'), ], split_named_range("'My Sheet'!$D$8")) + + +def test_split_no_quotes(): + eq_([('HYPOTHESES', '$B$3:$L$3'), ], split_named_range('HYPOTHESES!$B$3:$L$3')) + + +def test_bad_range_name(): + assert_raises(NamedRangeException, split_named_range, 'HYPOTHESES$B$3') + + +def test_read_named_ranges(): + + class DummyWs(object): + title = 'My Sheeet' + + def __str__(self): + return self.title + + class DummyWB(object): + + def get_sheet_by_name(self, name): + return DummyWs() + + with open(os.path.join(DATADIR, 'reader', 'workbook.xml')) as handle: + content = handle.read() + named_ranges = read_named_ranges(content, DummyWB()) + eq_(["My Sheeet!$D$8"], [str(range) for range in named_ranges]) + +def test_oddly_shaped_named_ranges(): + + ranges_counts = ((4, 'TEST_RANGE'), + (3, 'TRAP_1'), + (13, 'TRAP_2')) + + def check_ranges(ws, count, range_name): + + eq_(count, len(ws.range(range_name))) + + wb = load_workbook(os.path.join(DATADIR, 'genuine', 'merge_range.xlsx'), + use_iterators = False) + + ws = wb.worksheets[0] + + for count, range_name in ranges_counts: + + yield check_ranges, ws, count, range_name + + +def test_merged_cells_named_range(): + + wb = load_workbook(os.path.join(DATADIR, 'genuine', 'merge_range.xlsx'), + use_iterators = False) + + ws = wb.worksheets[0] + + cell = ws.range('TRAP_3') + + eq_('B15', cell.get_coordinate()) + + eq_(10, cell.value) diff --git a/tablib/packages/openpyxl/tests/test_number_format.py b/tablib/packages/openpyxl/tests/test_number_format.py new file mode 100644 index 0000000..2f5c9da --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_number_format.py @@ -0,0 +1,142 @@ +# file openpyxl/tests/test_number_format.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from __future__ import with_statement +from datetime import datetime, date + +# 3rd party imports +from nose.tools import eq_, assert_almost_equal, assert_raises + +# package imports +from openpyxl.workbook import Workbook +from openpyxl.worksheet import Worksheet +from openpyxl.cell import Cell +from openpyxl.style import NumberFormat +from openpyxl.shared.date_time import SharedDate + + +class TestNumberFormat(object): + + @classmethod + def setup_class(cls): + cls.workbook = Workbook() + cls.worksheet = Worksheet(cls.workbook, 'Test') + cls.sd = SharedDate() + + def test_convert_date_to_julian(self): + eq_(40167, self.sd.to_julian(2009, 12, 20)) + + def test_convert_date_from_julian(self): + + def test_date_equal(julian, datetime): + + eq_(self.sd.from_julian(julian), datetime) + + date_pairs= ( + (40167, datetime(2009, 12, 20)), + (21980, datetime(1960, 03, 05)), + ) + + for count, dt in date_pairs: + yield test_date_equal, count, dt + + def test_convert_datetime_to_julian(self): + eq_(40167, self.sd.datetime_to_julian(datetime(2009, 12, 20))) + + def test_insert_float(self): + self.worksheet.cell('A1').value = 3.14 + eq_(Cell.TYPE_NUMERIC, self.worksheet.cell('A1')._data_type) + + def test_insert_percentage(self): + self.worksheet.cell('A1').value = '3.14%' + eq_(Cell.TYPE_NUMERIC, self.worksheet.cell('A1')._data_type) + assert_almost_equal(0.0314, self.worksheet.cell('A1').value) + + def test_insert_datetime(self): + self.worksheet.cell('A1').value = date.today() + eq_(Cell.TYPE_NUMERIC, self.worksheet.cell('A1')._data_type) + + def test_insert_date(self): + self.worksheet.cell('A1').value = datetime.now() + eq_(Cell.TYPE_NUMERIC, self.worksheet.cell('A1')._data_type) + + def test_internal_date(self): + dt = datetime(2010, 7, 13, 6, 37, 41) + self.worksheet.cell('A3').value = dt + eq_(40372.27616898148, self.worksheet.cell('A3')._value) + + def test_datetime_interpretation(self): + dt = datetime(2010, 7, 13, 6, 37, 41) + self.worksheet.cell('A3').value = dt + eq_(dt, self.worksheet.cell('A3').value) + + def test_date_interpretation(self): + dt = date(2010, 7, 13) + self.worksheet.cell('A3').value = dt + eq_(datetime(2010, 7, 13, 0, 0), self.worksheet.cell('A3').value) + + def test_number_format_style(self): + self.worksheet.cell('A1').value = '12.6%' + eq_(NumberFormat.FORMAT_PERCENTAGE, \ + self.worksheet.cell('A1').style.number_format.format_code) + + def test_date_format_on_non_date(self): + cell = self.worksheet.cell('A1') + + def check_date_pair(count, date_string): + cell.value = datetime.strptime(date_string, '%Y-%m-%d') + eq_(count, cell._value) + + date_pairs = ( + (15, '1900-01-15'), + (59, '1900-02-28'), + (61, '1900-03-01'), + (367, '1901-01-01'), + (2958465, '9999-12-31'), ) + for count, date_string in date_pairs: + yield check_date_pair, count, date_string + + def test_1900_leap_year(self): + assert_raises(ValueError, self.sd.from_julian, 60) + assert_raises(ValueError, self.sd.to_julian, 1900, 2, 29) + + def test_bad_date(self): + + def check_bad_date(year, month, day): + assert_raises(ValueError, self.sd.to_julian, year, month, day) + + bad_dates = ((1776, 07, 04), (1899, 12, 31), ) + for year, month, day in bad_dates: + yield check_bad_date, year, month, day + + def test_bad_julian_date(self): + assert_raises(ValueError, self.sd.from_julian, -1) + + def test_mac_date(self): + self.sd.excel_base_date = self.sd.CALENDAR_MAC_1904 + assert_raises(NotImplementedError, self.sd.to_julian, 2000, 1, 1) + assert_raises(NotImplementedError, self.sd.from_julian, 1) + self.sd.excel_base_date = self.sd.CALENDAR_WINDOWS_1900 diff --git a/tablib/packages/openpyxl/tests/test_password_hash.py b/tablib/packages/openpyxl/tests/test_password_hash.py new file mode 100644 index 0000000..fd2fddf --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_password_hash.py @@ -0,0 +1,41 @@ +# file openpyxl/tests/test_password_hash.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# 3rd party imports +from nose.tools import eq_ + +# package imports +from openpyxl.shared.password_hasher import hash_password +from openpyxl.worksheet import SheetProtection + + +def test_hasher(): + eq_('CBEB', hash_password('test')) + + +def test_sheet_protection(): + protection = SheetProtection() + protection.password = 'test' + eq_('CBEB', protection.password) diff --git a/tablib/packages/openpyxl/tests/test_props.py b/tablib/packages/openpyxl/tests/test_props.py new file mode 100644 index 0000000..fb9c5d0 --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_props.py @@ -0,0 +1,124 @@ +# coding=utf-8 +# file openpyxl/tests/test_props.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from __future__ import with_statement +from zipfile import ZipFile, ZIP_DEFLATED +from datetime import datetime +import os.path + +# 3rd party imports +from nose.tools import eq_ + +# package imports +from openpyxl.tests.helper import DATADIR, TMPDIR, make_tmpdir, clean_tmpdir, \ + assert_equals_file_content +from openpyxl.reader.workbook import read_properties_core, \ + read_sheets_titles, get_number_of_parts +from openpyxl.writer.workbook import write_properties_core, \ + write_properties_app +from openpyxl.shared.ooxml import ARC_APP, ARC_CORE +from openpyxl.workbook import DocumentProperties, Workbook + + +class TestReaderProps(object): + + @classmethod + def setup_class(cls): + cls.genuine_filename = os.path.join(DATADIR, 'genuine', 'empty.xlsx') + cls.archive = ZipFile(cls.genuine_filename, 'r', ZIP_DEFLATED) + + @classmethod + def teardown_class(cls): + cls.archive.close() + + def test_read_properties_core(self): + content = self.archive.read(ARC_CORE) + prop = read_properties_core(content) + eq_(prop.creator, '*.*') + eq_(prop.last_modified_by, u'Aurélien Campéas') + eq_(prop.created, datetime(2010, 4, 9, 20, 43, 12)) + eq_(prop.modified, datetime(2011, 2, 9, 13, 49, 32)) + + def test_read_sheets_titles(self): + content = self.archive.read(ARC_APP) + sheet_titles = read_sheets_titles(content) + eq_(sheet_titles, \ + ['Sheet1 - Text', 'Sheet2 - Numbers', 'Sheet3 - Formulas', 'Sheet4 - Dates']) + + +class TestReaderPropsMixed(object): + + @classmethod + def setup_class(cls): + reference_filename = \ + os.path.join(DATADIR, 'reader', 'app-multi-titles.xml') + with open(reference_filename) as handle: + cls.content = handle.read() + + def test_read_sheet_titles_mixed(self): + sheet_titles = read_sheets_titles(self.content) + eq_(sheet_titles, + ['ToC', 'ContractYear', 'ContractTier', 'Demand', + 'LinearizedFunction', 'Market', 'Transmission']) + + def test_number_of_parts(self): + parts_number = get_number_of_parts(self.content) + eq_(parts_number, + ({'Worksheets': 7, 'Named Ranges': 7}, + ['Worksheets', 'Named Ranges'])) + + +class TestWriteProps(object): + + @classmethod + def setup_class(cls): + make_tmpdir() + cls.tmp_filename = os.path.join(TMPDIR, 'test.xlsx') + cls.prop = DocumentProperties() + + @classmethod + def teardown_class(cls): + clean_tmpdir() + + def test_write_properties_core(self): + self.prop.creator = 'TEST_USER' + self.prop.last_modified_by = 'SOMEBODY' + self.prop.created = datetime(2010, 4, 1, 20, 30, 00) + self.prop.modified = datetime(2010, 4, 5, 14, 5, 30) + content = write_properties_core(self.prop) + assert_equals_file_content( + os.path.join(DATADIR, 'writer', 'expected', 'core.xml'), + content) + + def test_write_properties_app(self): + wb = Workbook() + wb.create_sheet() + wb.create_sheet() + content = write_properties_app(wb) + assert_equals_file_content( + os.path.join(DATADIR, 'writer', 'expected', 'app.xml'), + content) diff --git a/tablib/packages/openpyxl/tests/test_read.py b/tablib/packages/openpyxl/tests/test_read.py new file mode 100644 index 0000000..eb6ab07 --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_read.py @@ -0,0 +1,134 @@ +# file openpyxl/tests/test_read.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from __future__ import with_statement +import os.path + +# 3rd party imports +from nose.tools import eq_, raises + +# package imports +from openpyxl.tests.helper import DATADIR +from openpyxl.worksheet import Worksheet +from openpyxl.workbook import Workbook +from openpyxl.style import NumberFormat, Style +from openpyxl.reader.worksheet import read_worksheet, read_dimension +from openpyxl.reader.excel import load_workbook +from openpyxl.shared.exc import InvalidFileException + + +def test_read_standalone_worksheet(): + + class DummyWb(object): + + def get_sheet_by_name(self, value): + return None + + path = os.path.join(DATADIR, 'reader', 'sheet2.xml') + with open(path) as handle: + ws = read_worksheet(handle.read(), DummyWb(), + 'Sheet 2', {1: 'hello'}, {1: Style()}) + assert isinstance(ws, Worksheet) + eq_(ws.cell('G5').value, 'hello') + eq_(ws.cell('D30').value, 30) + eq_(ws.cell('K9').value, 0.09) + + +def test_read_standard_workbook(): + path = os.path.join(DATADIR, 'genuine', 'empty.xlsx') + wb = load_workbook(path) + assert isinstance(wb, Workbook) + +def test_read_standard_workbook_from_fileobj(): + path = os.path.join(DATADIR, 'genuine', 'empty.xlsx') + fo = open(path, mode = 'rb') + wb = load_workbook(fo) + assert isinstance(wb, Workbook) + +def test_read_worksheet(): + path = os.path.join(DATADIR, 'genuine', 'empty.xlsx') + wb = load_workbook(path) + sheet2 = wb.get_sheet_by_name('Sheet2 - Numbers') + assert isinstance(sheet2, Worksheet) + eq_('This is cell G5', sheet2.cell('G5').value) + eq_(18, sheet2.cell('D18').value) + + +def test_read_nostring_workbook(): + genuine_wb = os.path.join(DATADIR, 'genuine', 'empty-no-string.xlsx') + wb = load_workbook(genuine_wb) + assert isinstance(wb, Workbook) + +@raises(InvalidFileException) +def test_read_empty_file(): + + null_file = os.path.join(DATADIR, 'reader', 'null_file.xlsx') + wb = load_workbook(null_file) + +@raises(InvalidFileException) +def test_read_empty_archive(): + + null_file = os.path.join(DATADIR, 'reader', 'null_archive.xlsx') + wb = load_workbook(null_file) + +def test_read_dimension(): + + path = os.path.join(DATADIR, 'reader', 'sheet2.xml') + + with open(path) as handle: + + dimension = read_dimension(xml_source = handle.read()) + + eq_(('D', 1, 'K', 30), dimension) + +class TestReadWorkbookWithStyles(object): + + @classmethod + def setup_class(cls): + cls.genuine_wb = os.path.join(DATADIR, 'genuine', \ + 'empty-with-styles.xlsx') + wb = load_workbook(cls.genuine_wb) + cls.ws = wb.get_sheet_by_name('Sheet1') + + def test_read_general_style(self): + eq_(self.ws.cell('A1').style.number_format.format_code, + NumberFormat.FORMAT_GENERAL) + + def test_read_date_style(self): + eq_(self.ws.cell('A2').style.number_format.format_code, + NumberFormat.FORMAT_DATE_XLSX14) + + def test_read_number_style(self): + eq_(self.ws.cell('A3').style.number_format.format_code, + NumberFormat.FORMAT_NUMBER_00) + + def test_read_time_style(self): + eq_(self.ws.cell('A4').style.number_format.format_code, + NumberFormat.FORMAT_DATE_TIME3) + + def test_read_percentage_style(self): + eq_(self.ws.cell('A5').style.number_format.format_code, + NumberFormat.FORMAT_PERCENTAGE_00) diff --git a/tablib/packages/openpyxl/tests/test_strings.py b/tablib/packages/openpyxl/tests/test_strings.py new file mode 100644 index 0000000..bf3cc57 --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_strings.py @@ -0,0 +1,68 @@ +# file openpyxl/tests/test_strings.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from __future__ import with_statement +import os.path + +# 3rd party imports +from nose.tools import eq_ + +# package imports +from openpyxl.tests.helper import DATADIR +from openpyxl.workbook import Workbook +from openpyxl.writer.strings import create_string_table +from openpyxl.reader.strings import read_string_table + + +def test_create_string_table(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('B12').value = 'hello' + ws.cell('B13').value = 'world' + ws.cell('D28').value = 'hello' + table = create_string_table(wb) + eq_({'hello': 1, 'world': 0}, table) + + +def test_read_string_table(): + with open(os.path.join(DATADIR, 'reader', 'sharedStrings.xml')) as handle: + content = handle.read() + string_table = read_string_table(content) + eq_({0: 'This is cell A1 in Sheet 1', 1: 'This is cell G5'}, string_table) + +def test_empty_string(): + with open(os.path.join(DATADIR, 'reader', 'sharedStrings-emptystring.xml')) as handle: + content = handle.read() + string_table = read_string_table(content) + eq_({0: 'Testing empty cell', 1:''}, string_table) + +def test_formatted_string_table(): + with open(os.path.join(DATADIR, 'reader', 'shared-strings-rich.xml')) \ + as handle: + content = handle.read() + string_table = read_string_table(content) + eq_({0: 'Welcome', 1: 'to the best shop in town', + 2: " let's play "}, string_table) diff --git a/tablib/packages/openpyxl/tests/test_style.py b/tablib/packages/openpyxl/tests/test_style.py new file mode 100644 index 0000000..ee51123 --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_style.py @@ -0,0 +1,181 @@ +# file openpyxl/tests/test_style.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from __future__ import with_statement +import os.path +import datetime + +# 3rd party imports +from nose.tools import eq_, assert_false, ok_ + +# package imports +from openpyxl.tests.helper import DATADIR, assert_equals_file_content, get_xml +from openpyxl.reader.style import read_style_table +from openpyxl.workbook import Workbook +from openpyxl.style import NumberFormat +from openpyxl.writer.styles import StyleWriter +from openpyxl.style import NumberFormat, Border, Color + + +class TestCreateStyle(object): + + @classmethod + def setup_class(cls): + now = datetime.datetime.now() + cls.workbook = Workbook() + cls.worksheet = cls.workbook.create_sheet() + cls.worksheet.cell(coordinate = 'A1').value = '12.34%' + cls.worksheet.cell(coordinate = 'B4').value = now + cls.worksheet.cell(coordinate = 'B5').value = now + cls.worksheet.cell(coordinate = 'C14').value = u'This is a test' + cls.worksheet.cell(coordinate = 'D9').value = '31.31415' + cls.worksheet.cell(coordinate = 'D9').style.number_format.format_code = \ + NumberFormat.FORMAT_NUMBER_00 + cls.writer = StyleWriter(cls.workbook) + + def test_create_style_table(self): + eq_(3, len(self.writer.style_table)) + + def test_write_style_table(self): + reference_file = os.path.join(DATADIR, 'writer', 'expected', 'simple-styles.xml') + assert_equals_file_content(reference_file, self.writer.write_table()) + +class TestStyleWriter(object): + + def setUp(self): + + self.workbook = Workbook() + self.worksheet = self.workbook.create_sheet() + + def test_no_style(self): + + w = StyleWriter(self.workbook) + eq_(0, len(w.style_table)) + + def test_nb_style(self): + + for i in range(1, 6): + self.worksheet.cell(row=1, column=i).style.font.size += i + w = StyleWriter(self.workbook) + eq_(5, len(w.style_table)) + + self.worksheet.cell('A10').style.borders.top = Border.BORDER_THIN + w = StyleWriter(self.workbook) + eq_(6, len(w.style_table)) + + def test_style_unicity(self): + + for i in range(1, 6): + self.worksheet.cell(row=1, column=i).style.font.bold = True + w = StyleWriter(self.workbook) + eq_(1, len(w.style_table)) + + def test_fonts(self): + + self.worksheet.cell('A1').style.font.size = 12 + self.worksheet.cell('A1').style.font.bold = True + w = StyleWriter(self.workbook) + w._write_fonts() + eq_(get_xml(w._root), '') + + def test_fills(self): + + self.worksheet.cell('A1').style.fill.fill_type = 'solid' + self.worksheet.cell('A1').style.fill.start_color.index = Color.DARKYELLOW + w = StyleWriter(self.workbook) + w._write_fills() + eq_(get_xml(w._root), '') + + def test_borders(self): + + self.worksheet.cell('A1').style.borders.top.border_style = Border.BORDER_THIN + self.worksheet.cell('A1').style.borders.top.color.index = Color.DARKYELLOW + w = StyleWriter(self.workbook) + w._write_borders() + eq_(get_xml(w._root), '') + + def test_write_cell_xfs_1(self): + + self.worksheet.cell('A1').style.font.size = 12 + w = StyleWriter(self.workbook) + ft = w._write_fonts() + nft = w._write_number_formats() + w._write_cell_xfs(nft, ft, {}, {}) + xml = get_xml(w._root) + ok_('applyFont="1"' in xml) + ok_('applyFillId="1"' not in xml) + ok_('applyBorder="1"' not in xml) + ok_('applyAlignment="1"' not in xml) + + def test_alignment(self): + self.worksheet.cell('A1').style.alignment.horizontal = 'center' + self.worksheet.cell('A1').style.alignment.vertical = 'center' + w = StyleWriter(self.workbook) + nft = w._write_number_formats() + w._write_cell_xfs(nft,{},{},{}) + xml = get_xml(w._root) + ok_('applyAlignment="1"' in xml) + ok_('horizontal="center"' in xml) + ok_('vertical="center"' in xml) + + +#def test_format_comparisions(): +# format1 = NumberFormat() +# format2 = NumberFormat() +# format3 = NumberFormat() +# format1.format_code = 'm/d/yyyy' +# format2.format_code = 'm/d/yyyy' +# format3.format_code = 'mm/dd/yyyy' +# assert not format1 < format2 +# assert format1 < format3 +# assert format1 == format2 +# assert format1 != format3 + + +def test_builtin_format(): + format = NumberFormat() + format.format_code = '0.00' + eq_(format.builtin_format_code(2), format._format_code) + + +def test_read_style(): + reference_file = os.path.join(DATADIR, 'reader', 'simple-styles.xml') + with open(reference_file, 'r') as handle: + content = handle.read() + style_table = read_style_table(content) + eq_(4, len(style_table)) + eq_(NumberFormat._BUILTIN_FORMATS[9], + style_table[1].number_format.format_code) + eq_('yyyy-mm-dd', style_table[2].number_format.format_code) + + +def test_read_cell_style(): + reference_file = os.path.join( + DATADIR, 'reader', 'empty-workbook-styles.xml') + with open(reference_file, 'r') as handle: + content = handle.read() + style_table = read_style_table(content) + eq_(2, len(style_table)) diff --git a/tablib/packages/openpyxl/tests/test_theme.py b/tablib/packages/openpyxl/tests/test_theme.py new file mode 100644 index 0000000..b0f6f00 --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_theme.py @@ -0,0 +1,37 @@ +# file openpyxl/tests/test_theme.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +import os.path + +# package imports +from openpyxl.tests.helper import DATADIR, assert_equals_file_content +from openpyxl.writer.theme import write_theme + + +def test_write_theme(): + content = write_theme() + assert_equals_file_content( + os.path.join(DATADIR, 'writer', 'expected', 'theme1.xml'), content) diff --git a/tablib/packages/openpyxl/tests/test_workbook.py b/tablib/packages/openpyxl/tests/test_workbook.py new file mode 100644 index 0000000..20191d2 --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_workbook.py @@ -0,0 +1,148 @@ +# file openpyxl/tests/test_workbook.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# 3rd party imports +from nose.tools import eq_, with_setup, raises +import os.path as osp + +# package imports +from openpyxl.workbook import Workbook +from openpyxl.reader.excel import load_workbook +from openpyxl.namedrange import NamedRange +from openpyxl.shared.exc import ReadOnlyWorkbookException +from openpyxl.tests.helper import TMPDIR, clean_tmpdir, make_tmpdir + +import datetime + +def test_get_active_sheet(): + wb = Workbook() + active_sheet = wb.get_active_sheet() + eq_(active_sheet, wb.worksheets[0]) + + +def test_create_sheet(): + wb = Workbook() + new_sheet = wb.create_sheet(0) + eq_(new_sheet, wb.worksheets[0]) + + +@raises(ReadOnlyWorkbookException) +def test_create_sheet_readonly(): + wb = Workbook() + wb._set_optimized_read() + wb.create_sheet() + + +def test_remove_sheet(): + wb = Workbook() + new_sheet = wb.create_sheet(0) + wb.remove_sheet(new_sheet) + assert new_sheet not in wb.worksheets + + +def test_get_sheet_by_name(): + wb = Workbook() + new_sheet = wb.create_sheet() + title = 'my sheet' + new_sheet.title = title + found_sheet = wb.get_sheet_by_name(title) + eq_(new_sheet, found_sheet) + + +def test_get_index(): + wb = Workbook() + new_sheet = wb.create_sheet(0) + sheet_index = wb.get_index(new_sheet) + eq_(sheet_index, 0) + + +def test_get_sheet_names(): + wb = Workbook() + names = ['Sheet', 'Sheet1', 'Sheet2', 'Sheet3', 'Sheet4', 'Sheet5'] + for count in range(5): + wb.create_sheet(0) + actual_names = wb.get_sheet_names() + eq_(sorted(actual_names), sorted(names)) + + +def test_get_named_ranges(): + wb = Workbook() + eq_(wb.get_named_ranges(), wb._named_ranges) + + +def test_add_named_range(): + wb = Workbook() + new_sheet = wb.create_sheet() + named_range = NamedRange('test_nr', [(new_sheet, 'A1')]) + wb.add_named_range(named_range) + named_ranges_list = wb.get_named_ranges() + assert named_range in named_ranges_list + + +def test_get_named_range(): + wb = Workbook() + new_sheet = wb.create_sheet() + named_range = NamedRange('test_nr', [(new_sheet, 'A1')]) + wb.add_named_range(named_range) + found_named_range = wb.get_named_range('test_nr') + eq_(named_range, found_named_range) + + +def test_remove_named_range(): + wb = Workbook() + new_sheet = wb.create_sheet() + named_range = NamedRange('test_nr', [(new_sheet, 'A1')]) + wb.add_named_range(named_range) + wb.remove_named_range(named_range) + named_ranges_list = wb.get_named_ranges() + assert named_range not in named_ranges_list + +@with_setup(setup = make_tmpdir, teardown = clean_tmpdir) +def test_add_local_named_range(): + wb = Workbook() + new_sheet = wb.create_sheet() + named_range = NamedRange('test_nr', [(new_sheet, 'A1')]) + named_range.local_only = True + wb.add_named_range(named_range) + dest_filename = osp.join(TMPDIR, 'local_named_range_book.xlsx') + wb.save(dest_filename) + + +@with_setup(setup = make_tmpdir, teardown = clean_tmpdir) +def test_write_regular_date(): + + today = datetime.datetime(2010, 1, 18, 14, 15, 20, 1600) + + book = Workbook() + sheet = book.get_active_sheet() + sheet.cell("A1").value = today + dest_filename = osp.join(TMPDIR, 'date_read_write_issue.xlsx') + book.save(dest_filename) + + test_book = load_workbook(dest_filename) + test_sheet = test_book.get_active_sheet() + + eq_(test_sheet.cell("A1").value, today) + diff --git a/tablib/packages/openpyxl/tests/test_worksheet.py b/tablib/packages/openpyxl/tests/test_worksheet.py new file mode 100644 index 0000000..1894f1d --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_worksheet.py @@ -0,0 +1,258 @@ +# file openpyxl/tests/test_worksheet.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# 3rd party imports +from nose.tools import eq_, raises, assert_raises + +# package imports +from openpyxl.workbook import Workbook +from openpyxl.worksheet import Worksheet, Relationship, flatten +from openpyxl.cell import Cell +from openpyxl.shared.exc import CellCoordinatesException, \ + SheetTitleException, InsufficientCoordinatesException, \ + NamedRangeException + + +class TestWorksheet(): + + @classmethod + def setup_class(cls): + cls.wb = Workbook() + + def test_new_worksheet(self): + ws = Worksheet(self.wb) + eq_(self.wb, ws._parent) + + def test_new_sheet_name(self): + self.wb.worksheets = [] + ws = Worksheet(self.wb, title = '') + eq_(repr(ws), '') + + def test_get_cell(self): + ws = Worksheet(self.wb) + cell = ws.cell('A1') + eq_(cell.get_coordinate(), 'A1') + + @raises(SheetTitleException) + def test_set_bad_title(self): + Worksheet(self.wb, 'X' * 50) + + def test_set_bad_title_character(self): + assert_raises(SheetTitleException, Worksheet, self.wb, '[') + assert_raises(SheetTitleException, Worksheet, self.wb, ']') + assert_raises(SheetTitleException, Worksheet, self.wb, '*') + assert_raises(SheetTitleException, Worksheet, self.wb, ':') + assert_raises(SheetTitleException, Worksheet, self.wb, '?') + assert_raises(SheetTitleException, Worksheet, self.wb, '/') + assert_raises(SheetTitleException, Worksheet, self.wb, '\\') + + def test_worksheet_dimension(self): + ws = Worksheet(self.wb) + eq_('A1:A1', ws.calculate_dimension()) + ws.cell('B12').value = 'AAA' + eq_('A1:B12', ws.calculate_dimension()) + + def test_worksheet_range(self): + ws = Worksheet(self.wb) + xlrange = ws.range('A1:C4') + assert isinstance(xlrange, tuple) + eq_(4, len(xlrange)) + eq_(3, len(xlrange[0])) + + def test_worksheet_named_range(self): + ws = Worksheet(self.wb) + self.wb.create_named_range('test_range', ws, 'C5') + xlrange = ws.range('test_range') + assert isinstance(xlrange, Cell) + eq_(5, xlrange.row) + + @raises(NamedRangeException) + def test_bad_named_range(self): + ws = Worksheet(self.wb) + ws.range('bad_range') + + @raises(NamedRangeException) + def test_named_range_wrong_sheet(self): + ws1 = Worksheet(self.wb) + ws2 = Worksheet(self.wb) + self.wb.create_named_range('wrong_sheet_range', ws1, 'C5') + ws2.range('wrong_sheet_range') + + def test_cell_offset(self): + ws = Worksheet(self.wb) + eq_('C17', ws.cell('B15').offset(2, 1).get_coordinate()) + + def test_range_offset(self): + ws = Worksheet(self.wb) + xlrange = ws.range('A1:C4', 1, 3) + assert isinstance(xlrange, tuple) + eq_(4, len(xlrange)) + eq_(3, len(xlrange[0])) + eq_('D2', xlrange[0][0].get_coordinate()) + + def test_cell_alternate_coordinates(self): + ws = Worksheet(self.wb) + cell = ws.cell(row = 8, column = 4) + eq_('E9', cell.get_coordinate()) + + @raises(InsufficientCoordinatesException) + def test_cell_insufficient_coordinates(self): + ws = Worksheet(self.wb) + cell = ws.cell(row = 8) + + def test_cell_range_name(self): + ws = Worksheet(self.wb) + self.wb.create_named_range('test_range_single', ws, 'B12') + assert_raises(CellCoordinatesException, ws.cell, 'test_range_single') + c_range_name = ws.range('test_range_single') + c_range_coord = ws.range('B12') + c_cell = ws.cell('B12') + eq_(c_range_coord, c_range_name) + eq_(c_range_coord, c_cell) + + def test_garbage_collect(self): + ws = Worksheet(self.wb) + ws.cell('A1').value = '' + ws.cell('B2').value = '0' + ws.cell('C4').value = 0 + ws.garbage_collect() + eq_(ws.get_cell_collection(), [ws.cell('B2'), ws.cell('C4')]) + + def test_hyperlink_relationships(self): + ws = Worksheet(self.wb) + eq_(len(ws.relationships), 0) + + ws.cell('A1').hyperlink = "http://test.com" + eq_(len(ws.relationships), 1) + eq_("rId1", ws.cell('A1').hyperlink_rel_id) + eq_("rId1", ws.relationships[0].id) + eq_("http://test.com", ws.relationships[0].target) + eq_("External", ws.relationships[0].target_mode) + + ws.cell('A2').hyperlink = "http://test2.com" + eq_(len(ws.relationships), 2) + eq_("rId2", ws.cell('A2').hyperlink_rel_id) + eq_("rId2", ws.relationships[1].id) + eq_("http://test2.com", ws.relationships[1].target) + eq_("External", ws.relationships[1].target_mode) + + @raises(ValueError) + def test_bad_relationship_type(self): + rel = Relationship('bad_type') + + def test_append_list(self): + ws = Worksheet(self.wb) + + ws.append(['This is A1', 'This is B1']) + + eq_('This is A1', ws.cell('A1').value) + eq_('This is B1', ws.cell('B1').value) + + def test_append_dict_letter(self): + ws = Worksheet(self.wb) + + ws.append({'A' : 'This is A1', 'C' : 'This is C1'}) + + eq_('This is A1', ws.cell('A1').value) + eq_('This is C1', ws.cell('C1').value) + + def test_append_dict_index(self): + ws = Worksheet(self.wb) + + ws.append({0 : 'This is A1', 2 : 'This is C1'}) + + eq_('This is A1', ws.cell('A1').value) + eq_('This is C1', ws.cell('C1').value) + + @raises(TypeError) + def test_bad_append(self): + ws = Worksheet(self.wb) + ws.append("test") + + def test_append_2d_list(self): + + ws = Worksheet(self.wb) + + ws.append(['This is A1', 'This is B1']) + ws.append(['This is A2', 'This is B2']) + + vals = ws.range('A1:B2') + + eq_((('This is A1', 'This is B1'), + ('This is A2', 'This is B2'),), flatten(vals)) + + def test_rows(self): + + ws = Worksheet(self.wb) + + ws.cell('A1').value = 'first' + ws.cell('C9').value = 'last' + + rows = ws.rows + + eq_(len(rows), 9) + + eq_(rows[0][0].value, 'first') + eq_(rows[-1][-1].value, 'last') + + def test_cols(self): + + ws = Worksheet(self.wb) + + ws.cell('A1').value = 'first' + ws.cell('C9').value = 'last' + + cols = ws.columns + + eq_(len(cols), 3) + + eq_(cols[0][0].value, 'first') + eq_(cols[-1][-1].value, 'last') + + def test_auto_filter(self): + ws = Worksheet(self.wb) + ws.auto_filter = ws.range('a1:f1') + assert ws.auto_filter == 'A1:F1' + + ws.auto_filter = '' + assert ws.auto_filter is None + + ws.auto_filter = 'c1:g9' + assert ws.auto_filter == 'C1:G9' + + def test_freeze(self): + ws = Worksheet(self.wb) + ws.freeze_panes = ws.cell('b2') + assert ws.freeze_panes == 'B2' + + ws.freeze_panes = '' + assert ws.freeze_panes is None + + ws.freeze_panes = 'c5' + assert ws.freeze_panes == 'C5' + + ws.freeze_panes = ws.cell('A1') + assert ws.freeze_panes is None + diff --git a/tablib/packages/openpyxl/tests/test_write.py b/tablib/packages/openpyxl/tests/test_write.py new file mode 100644 index 0000000..834e73c --- /dev/null +++ b/tablib/packages/openpyxl/tests/test_write.py @@ -0,0 +1,203 @@ +# file openpyxl/tests/test_write.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +# Python stdlib imports +from __future__ import with_statement +from StringIO import StringIO +import os.path + +# 3rd party imports +from nose.tools import eq_, with_setup, raises + +# package imports +from openpyxl.tests.helper import TMPDIR, DATADIR, \ + assert_equals_file_content, clean_tmpdir, make_tmpdir +from openpyxl.workbook import Workbook +from openpyxl.reader.excel import load_workbook +from openpyxl.writer.excel import save_workbook, save_virtual_workbook, \ + ExcelWriter +from openpyxl.writer.workbook import write_workbook, write_workbook_rels +from openpyxl.writer.worksheet import write_worksheet, write_worksheet_rels +from openpyxl.writer.strings import write_string_table +from openpyxl.writer.styles import StyleWriter + + +@with_setup(setup = make_tmpdir, teardown = clean_tmpdir) +def test_write_empty_workbook(): + wb = Workbook() + dest_filename = os.path.join(TMPDIR, 'empty_book.xlsx') + save_workbook(wb, dest_filename) + assert os.path.isfile(dest_filename) + + +def test_write_virtual_workbook(): + old_wb = Workbook() + saved_wb = save_virtual_workbook(old_wb) + new_wb = load_workbook(StringIO(saved_wb)) + assert new_wb + + +def test_write_workbook_rels(): + wb = Workbook() + content = write_workbook_rels(wb) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'workbook.xml.rels'), content) + + +def test_write_workbook(): + wb = Workbook() + content = write_workbook(wb) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'workbook.xml'), content) + + +def test_write_string_table(): + table = {'hello': 1, 'world': 2, 'nice': 3} + content = write_string_table(table) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sharedStrings.xml'), content) + + +def test_write_worksheet(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('F42').value = 'hello' + content = write_worksheet(ws, {'hello': 0}, {}) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1.xml'), content) + + +def test_write_hidden_worksheet(): + wb = Workbook() + ws = wb.create_sheet() + ws.sheet_state = ws.SHEETSTATE_HIDDEN + ws.cell('F42').value = 'hello' + content = write_worksheet(ws, {'hello': 0}, {}) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1.xml'), content) + + +def test_write_formula(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('F1').value = 10 + ws.cell('F2').value = 32 + ws.cell('F3').value = '=F1+F2' + content = write_worksheet(ws, {}, {}) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1_formula.xml'), content) + + +def test_write_style(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('F1').value = '13%' + style_id_by_hash = StyleWriter(wb).get_style_by_hash() + content = write_worksheet(ws, {}, style_id_by_hash) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1_style.xml'), content) + + +def test_write_height(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('F1').value = 10 + ws.row_dimensions[ws.cell('F1').row].height = 30 + content = write_worksheet(ws, {}, {}) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1_height.xml'), content) + + +def test_write_hyperlink(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('A1').value = "test" + ws.cell('A1').hyperlink = "http://test.com" + content = write_worksheet(ws, {'test': 0}, {}) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1_hyperlink.xml'), content) + + +def test_write_hyperlink_rels(): + wb = Workbook() + ws = wb.create_sheet() + eq_(0, len(ws.relationships)) + ws.cell('A1').value = "test" + ws.cell('A1').hyperlink = "http://test.com/" + eq_(1, len(ws.relationships)) + ws.cell('A2').value = "test" + ws.cell('A2').hyperlink = "http://test2.com/" + eq_(2, len(ws.relationships)) + content = write_worksheet_rels(ws, 1) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1_hyperlink.xml.rels'), content) + + +def test_hyperlink_value(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('A1').hyperlink = "http://test.com" + eq_("http://test.com", ws.cell('A1').value) + ws.cell('A1').value = "test" + eq_("test", ws.cell('A1').value) + +def test_write_auto_filter(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('F42').value = 'hello' + ws.auto_filter = 'A1:F1' + content = write_worksheet(ws, {'hello': 0}, {}) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1_auto_filter.xml'), content) + +def test_freeze_panes_horiz(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('F42').value = 'hello' + ws.freeze_panes = 'A4' + content = write_worksheet(ws, {'hello': 0}, {}) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1_freeze_panes_horiz.xml'), content) + +def test_freeze_panes_vert(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('F42').value = 'hello' + ws.freeze_panes = 'D1' + content = write_worksheet(ws, {'hello': 0}, {}) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1_freeze_panes_vert.xml'), content) + pass + +def test_freeze_panes_both(): + wb = Workbook() + ws = wb.create_sheet() + ws.cell('F42').value = 'hello' + ws.freeze_panes = 'D4' + content = write_worksheet(ws, {'hello': 0}, {}) + assert_equals_file_content(os.path.join(DATADIR, 'writer', 'expected', \ + 'sheet1_freeze_panes_both.xml'), content) + + diff --git a/tablib/packages/openpyxl/workbook.py b/tablib/packages/openpyxl/workbook.py new file mode 100644 index 0000000..10a4564 --- /dev/null +++ b/tablib/packages/openpyxl/workbook.py @@ -0,0 +1,186 @@ +# file openpyxl/workbook.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Workbook is the top-level container for all document information.""" + +__docformat__ = "restructuredtext en" + +# Python stdlib imports +import datetime +import os + +# package imports +from openpyxl.worksheet import Worksheet +from openpyxl.writer.dump_worksheet import DumpWorksheet, save_dump +from openpyxl.writer.strings import StringTableBuilder +from openpyxl.namedrange import NamedRange +from openpyxl.style import Style +from openpyxl.writer.excel import save_workbook +from openpyxl.shared.exc import ReadOnlyWorkbookException + + +class DocumentProperties(object): + """High-level properties of the document.""" + + def __init__(self): + self.creator = 'Unknown' + self.last_modified_by = self.creator + self.created = datetime.datetime.now() + self.modified = datetime.datetime.now() + self.title = 'Untitled' + self.subject = '' + self.description = '' + self.keywords = '' + self.category = '' + self.company = 'Microsoft Corporation' + + +class DocumentSecurity(object): + """Security information about the document.""" + + def __init__(self): + self.lock_revision = False + self.lock_structure = False + self.lock_windows = False + self.revision_password = '' + self.workbook_password = '' + + +class Workbook(object): + """Workbook is the container for all other parts of the document.""" + + def __init__(self, optimized_write = False): + self.worksheets = [] + self._active_sheet_index = 0 + self._named_ranges = [] + self.properties = DocumentProperties() + self.style = Style() + self.security = DocumentSecurity() + self.__optimized_write = optimized_write + self.__optimized_read = False + self.strings_table_builder = StringTableBuilder() + + if not optimized_write: + self.worksheets.append(Worksheet(self)) + + def _set_optimized_read(self): + self.__optimized_read = True + + def get_active_sheet(self): + """Returns the current active sheet.""" + return self.worksheets[self._active_sheet_index] + + def create_sheet(self, index = None): + """Create a worksheet (at an optional index). + + :param index: optional position at which the sheet will be inserted + :type index: int + + """ + + if self.__optimized_read: + raise ReadOnlyWorkbookException('Cannot create new sheet in a read-only workbook') + + if self.__optimized_write : + new_ws = DumpWorksheet(parent_workbook = self) + else: + new_ws = Worksheet(parent_workbook = self) + + self.add_sheet(worksheet = new_ws, index = index) + return new_ws + + def add_sheet(self, worksheet, index = None): + """Add an existing worksheet (at an optional index).""" + if index is None: + index = len(self.worksheets) + self.worksheets.insert(index, worksheet) + + def remove_sheet(self, worksheet): + """Remove a worksheet from this workbook.""" + self.worksheets.remove(worksheet) + + def get_sheet_by_name(self, name): + """Returns a worksheet by its name. + + Returns None if no worksheet has the name specified. + + :param name: the name of the worksheet to look for + :type name: string + + """ + requested_sheet = None + for sheet in self.worksheets: + if sheet.title == name: + requested_sheet = sheet + break + return requested_sheet + + def get_index(self, worksheet): + """Return the index of the worksheet.""" + return self.worksheets.index(worksheet) + + def get_sheet_names(self): + """Returns the list of the names of worksheets in the workbook. + + Names are returned in the worksheets order. + + :rtype: list of strings + + """ + return [s.title for s in self.worksheets] + + def create_named_range(self, name, worksheet, range): + """Create a new named_range on a worksheet""" + assert isinstance(worksheet, Worksheet) + named_range = NamedRange(name, [(worksheet, range)]) + self.add_named_range(named_range) + + def get_named_ranges(self): + """Return all named ranges""" + return self._named_ranges + + def add_named_range(self, named_range): + """Add an existing named_range to the list of named_ranges.""" + self._named_ranges.append(named_range) + + def get_named_range(self, name): + """Return the range specified by name.""" + requested_range = None + for named_range in self._named_ranges: + if named_range.name == name: + requested_range = named_range + break + return requested_range + + def remove_named_range(self, named_range): + """Remove a named_range from this workbook.""" + self._named_ranges.remove(named_range) + + def save(self, filename): + """ shortcut """ + if self.__optimized_write: + save_dump(self, filename) + else: + save_workbook(self, filename) diff --git a/tablib/packages/openpyxl/worksheet.py b/tablib/packages/openpyxl/worksheet.py new file mode 100644 index 0000000..bfc873c --- /dev/null +++ b/tablib/packages/openpyxl/worksheet.py @@ -0,0 +1,534 @@ +# file openpyxl/worksheet.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Worksheet is the 2nd-level container in Excel.""" + +# Python stdlib imports +import re + +# package imports +import openpyxl.cell +from openpyxl.cell import coordinate_from_string, \ + column_index_from_string, get_column_letter +from openpyxl.shared.exc import SheetTitleException, \ + InsufficientCoordinatesException, CellCoordinatesException, \ + NamedRangeException +from openpyxl.shared.password_hasher import hash_password +from openpyxl.style import Style, DEFAULTS as DEFAULTS_STYLE +from openpyxl.drawing import Drawing + +_DEFAULTS_STYLE_HASH = hash(DEFAULTS_STYLE) + +def flatten(results): + + rows = [] + + for row in results: + + cells = [] + + for cell in row: + + cells.append(cell.value) + + rows.append(tuple(cells)) + + return tuple(rows) + + +class Relationship(object): + """Represents many kinds of relationships.""" + # TODO: Use this object for workbook relationships as well as + # worksheet relationships + TYPES = { + 'hyperlink': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink', + 'drawing':'http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing', + #'worksheet': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet', + #'sharedStrings': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings', + #'styles': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles', + #'theme': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme', + } + + def __init__(self, rel_type): + if rel_type not in self.TYPES: + raise ValueError("Invalid relationship type %s" % rel_type) + self.type = self.TYPES[rel_type] + self.target = "" + self.target_mode = "" + self.id = "" + + +class PageSetup(object): + """Information about page layout for this sheet""" + pass + + +class HeaderFooter(object): + """Information about the header/footer for this sheet.""" + pass + + +class SheetView(object): + """Information about the visible portions of this sheet.""" + pass + + +class RowDimension(object): + """Information about the display properties of a row.""" + __slots__ = ('row_index', + 'height', + 'visible', + 'outline_level', + 'collapsed', + 'style_index',) + + def __init__(self, index = 0): + self.row_index = index + self.height = -1 + self.visible = True + self.outline_level = 0 + self.collapsed = False + self.style_index = None + + +class ColumnDimension(object): + """Information about the display properties of a column.""" + __slots__ = ('column_index', + 'width', + 'auto_size', + 'visible', + 'outline_level', + 'collapsed', + 'style_index',) + + def __init__(self, index = 'A'): + self.column_index = index + self.width = -1 + self.auto_size = False + self.visible = True + self.outline_level = 0 + self.collapsed = False + self.style_index = 0 + + +class PageMargins(object): + """Information about page margins for view/print layouts.""" + + def __init__(self): + self.left = self.right = 0.7 + self.top = self.bottom = 0.75 + self.header = self.footer = 0.3 + + +class SheetProtection(object): + """Information about protection of various aspects of a sheet.""" + + def __init__(self): + self.sheet = False + self.objects = False + self.scenarios = False + self.format_cells = False + self.format_columns = False + self.format_rows = False + self.insert_columns = False + self.insert_rows = False + self.insert_hyperlinks = False + self.delete_columns = False + self.delete_rows = False + self.select_locked_cells = False + self.sort = False + self.auto_filter = False + self.pivot_tables = False + self.select_unlocked_cells = False + self._password = '' + + def set_password(self, value = '', already_hashed = False): + """Set a password on this sheet.""" + if not already_hashed: + value = hash_password(value) + self._password = value + + def _set_raw_password(self, value): + """Set a password directly, forcing a hash step.""" + self.set_password(value, already_hashed = False) + + def _get_raw_password(self): + """Return the password value, regardless of hash.""" + return self._password + + password = property(_get_raw_password, _set_raw_password, + 'get/set the password (if already hashed, ' + 'use set_password() instead)') + + +class Worksheet(object): + """Represents a worksheet. + + Do not create worksheets yourself, + use :func:`openpyxl.workbook.Workbook.create_sheet` instead + + """ + BREAK_NONE = 0 + BREAK_ROW = 1 + BREAK_COLUMN = 2 + + SHEETSTATE_VISIBLE = 'visible' + SHEETSTATE_HIDDEN = 'hidden' + SHEETSTATE_VERYHIDDEN = 'veryHidden' + + def __init__(self, parent_workbook, title = 'Sheet'): + self._parent = parent_workbook + self._title = '' + if not title: + self.title = 'Sheet%d' % (1 + len(self._parent.worksheets)) + else: + self.title = title + self.row_dimensions = {} + self.column_dimensions = {} + self._cells = {} + self._styles = {} + self._charts = [] + self.relationships = [] + self.selected_cell = 'A1' + self.active_cell = 'A1' + self.sheet_state = self.SHEETSTATE_VISIBLE + self.page_setup = PageSetup() + self.page_margins = PageMargins() + self.header_footer = HeaderFooter() + self.sheet_view = SheetView() + self.protection = SheetProtection() + self.show_gridlines = True + self.print_gridlines = False + self.show_summary_below = True + self.show_summary_right = True + self.default_row_dimension = RowDimension() + self.default_column_dimension = ColumnDimension() + self._auto_filter = None + self._freeze_panes = None + + def __repr__(self): + return u'' % self.title + + def garbage_collect(self): + """Delete cells that are not storing a value.""" + delete_list = [coordinate for coordinate, cell in \ + self._cells.iteritems() if (cell.value in ('', None) and \ + hash(cell.style) == _DEFAULTS_STYLE_HASH)] + for coordinate in delete_list: + del self._cells[coordinate] + + def get_cell_collection(self): + """Return an unordered list of the cells in this worksheet.""" + return self._cells.values() + + def _set_title(self, value): + """Set a sheet title, ensuring it is valid.""" + bad_title_char_re = re.compile(r'[\\*?:/\[\]]') + if bad_title_char_re.search(value): + msg = 'Invalid character found in sheet title' + raise SheetTitleException(msg) + + # check if sheet_name already exists + # do this *before* length check + if self._parent.get_sheet_by_name(value): + # use name, but append with lowest possible integer + i = 1 + while self._parent.get_sheet_by_name('%s%d' % (value, i)): + i += 1 + value = '%s%d' % (value, i) + if len(value) > 31: + msg = 'Maximum 31 characters allowed in sheet title' + raise SheetTitleException(msg) + self._title = value + + def _get_title(self): + """Return the title for this sheet.""" + return self._title + + title = property(_get_title, _set_title, doc = + 'Get or set the title of the worksheet. ' + 'Limited to 31 characters, no special characters.') + + def _set_auto_filter(self, range): + # Normalize range to a str or None + if not range: + range = None + elif isinstance(range, str): + range = range.upper() + else: # Assume a range + range = range[0][0].address + ':' + range[-1][-1].address + self._auto_filter = range + + def _get_auto_filter(self): + return self._auto_filter + + auto_filter = property(_get_auto_filter, _set_auto_filter, doc = + 'get or set auto filtering on columns') + def _set_freeze_panes(self, topLeftCell): + if not topLeftCell: + topLeftCell = None + elif isinstance(topLeftCell, str): + topLeftCell = topLeftCell.upper() + else: # Assume a cell + topLeftCell = topLeftCell.address + if topLeftCell == 'A1': + topLeftCell = None + self._freeze_panes = topLeftCell + + def _get_freeze_panes(self): + return self._freeze_panes + + freeze_panes = property(_get_freeze_panes,_set_freeze_panes, doc = + "Get or set frozen panes") + + def cell(self, coordinate = None, row = None, column = None): + """Returns a cell object based on the given coordinates. + + Usage: cell(coodinate='A15') **or** cell(row=15, column=1) + + If `coordinates` are not given, then row *and* column must be given. + + Cells are kept in a dictionary which is empty at the worksheet + creation. Calling `cell` creates the cell in memory when they + are first accessed, to reduce memory usage. + + :param coordinate: coordinates of the cell (e.g. 'B12') + :type coordinate: string + + :param row: row index of the cell (e.g. 4) + :type row: int + + :param column: column index of the cell (e.g. 3) + :type column: int + + :raise: InsufficientCoordinatesException when coordinate or (row and column) are not given + + :rtype: :class:`openpyxl.cell.Cell` + + """ + if not coordinate: + if (row is None or column is None): + msg = "You have to provide a value either for " \ + "'coordinate' or for 'row' *and* 'column'" + raise InsufficientCoordinatesException(msg) + else: + coordinate = '%s%s' % (get_column_letter(column + 1), row + 1) + else: + coordinate = coordinate.replace('$', '') + + return self._get_cell(coordinate) + + def _get_cell(self, coordinate): + + if not coordinate in self._cells: + column, row = coordinate_from_string(coordinate) + new_cell = openpyxl.cell.Cell(self, column, row) + self._cells[coordinate] = new_cell + if column not in self.column_dimensions: + self.column_dimensions[column] = ColumnDimension(column) + if row not in self.row_dimensions: + self.row_dimensions[row] = RowDimension(row) + return self._cells[coordinate] + + def get_highest_row(self): + """Returns the maximum row index containing data + + :rtype: int + """ + if self.row_dimensions: + return max(self.row_dimensions.keys()) + else: + return 1 + + def get_highest_column(self): + """Get the largest value for column currently stored. + + :rtype: int + """ + if self.column_dimensions: + return max([column_index_from_string(column_index) + for column_index in self.column_dimensions]) + else: + return 1 + + def calculate_dimension(self): + """Return the minimum bounding range for all cells containing data.""" + return 'A1:%s%d' % (get_column_letter(self.get_highest_column()), + self.get_highest_row()) + + def range(self, range_string, row = 0, column = 0): + """Returns a 2D array of cells, with optional row and column offsets. + + :param range_string: cell range string or `named range` name + :type range_string: string + + :param row: number of rows to offset + :type row: int + + :param column: number of columns to offset + :type column: int + + :rtype: tuples of tuples of :class:`openpyxl.cell.Cell` + + """ + if ':' in range_string: + # R1C1 range + result = [] + min_range, max_range = range_string.split(':') + min_col, min_row = coordinate_from_string(min_range) + max_col, max_row = coordinate_from_string(max_range) + if column: + min_col = get_column_letter( + column_index_from_string(min_col) + column) + max_col = get_column_letter( + column_index_from_string(max_col) + column) + min_col = column_index_from_string(min_col) + max_col = column_index_from_string(max_col) + cache_cols = {} + for col in xrange(min_col, max_col + 1): + cache_cols[col] = get_column_letter(col) + rows = xrange(min_row + row, max_row + row + 1) + cols = xrange(min_col, max_col + 1) + for row in rows: + new_row = [] + for col in cols: + new_row.append(self.cell('%s%s' % (cache_cols[col], row))) + result.append(tuple(new_row)) + return tuple(result) + else: + try: + return self.cell(coordinate = range_string, row = row, + column = column) + except CellCoordinatesException: + pass + + # named range + named_range = self._parent.get_named_range(range_string) + if named_range is None: + msg = '%s is not a valid range name' % range_string + raise NamedRangeException(msg) + + result = [] + for destination in named_range.destinations: + + worksheet, cells_range = destination + + if worksheet is not self: + msg = 'Range %s is not defined on worksheet %s' % \ + (cells_range, self.title) + raise NamedRangeException(msg) + + content = self.range(cells_range) + + if isinstance(content, tuple): + for cells in content: + result.extend(cells) + else: + result.append(content) + + if len(result) == 1: + return result[0] + else: + return tuple(result) + + def get_style(self, coordinate): + """Return the style object for the specified cell.""" + if not coordinate in self._styles: + self._styles[coordinate] = Style() + return self._styles[coordinate] + + def create_relationship(self, rel_type): + """Add a relationship for this sheet.""" + rel = Relationship(rel_type) + self.relationships.append(rel) + rel_id = self.relationships.index(rel) + rel.id = 'rId' + str(rel_id + 1) + return self.relationships[rel_id] + + def add_chart(self, chart): + """ Add a chart to the sheet """ + + chart._sheet = self + self._charts.append(chart) + + def append(self, list_or_dict): + """Appends a group of values at the bottom of the current sheet. + + * If it's a list: all values are added in order, starting from the first column + * If it's a dict: values are assigned to the columns indicated by the keys (numbers or letters) + + :param list_or_dict: list or dict containing values to append + :type list_or_dict: list/tuple or dict + + Usage: + + * append(['This is A1', 'This is B1', 'This is C1']) + * **or** append({'A' : 'This is A1', 'C' : 'This is C1'}) + * **or** append({0 : 'This is A1', 2 : 'This is C1'}) + + :raise: TypeError when list_or_dict is neither a list/tuple nor a dict + + """ + + row_idx = len(self.row_dimensions) + + if isinstance(list_or_dict, (list, tuple)): + + for col_idx, content in enumerate(list_or_dict): + + self.cell(row = row_idx, column = col_idx).value = content + + elif isinstance(list_or_dict, dict): + + for col_idx, content in list_or_dict.iteritems(): + + if isinstance(col_idx, basestring): + col_idx = column_index_from_string(col_idx) - 1 + + self.cell(row = row_idx, column = col_idx).value = content + + else: + raise TypeError('list_or_dict must be a list or a dict') + + @property + def rows(self): + + return self.range(self.calculate_dimension()) + + @property + def columns(self): + + max_row = self.get_highest_row() + + cols = [] + + for col_idx in range(self.get_highest_column()): + col = get_column_letter(col_idx+1) + res = self.range('%s1:%s%d' % (col, col, max_row)) + cols.append(tuple([x[0] for x in res])) + + + return tuple(cols) + diff --git a/tablib/packages/openpyxl/writer/__init__.py b/tablib/packages/openpyxl/writer/__init__.py new file mode 100644 index 0000000..fff1f92 --- /dev/null +++ b/tablib/packages/openpyxl/writer/__init__.py @@ -0,0 +1,34 @@ +# file openpyxl/writer/__init__.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Imports for the openpyxl.writer namespace.""" + +# package imports +from openpyxl.writer import excel +from openpyxl.writer import strings +from openpyxl.writer import styles +from openpyxl.writer import theme +from openpyxl.writer import workbook +from openpyxl.writer import worksheet diff --git a/tablib/packages/openpyxl/writer/charts.py b/tablib/packages/openpyxl/writer/charts.py new file mode 100644 index 0000000..1d3dbd9 --- /dev/null +++ b/tablib/packages/openpyxl/writer/charts.py @@ -0,0 +1,261 @@ +# coding=UTF-8 +''' +Copyright (c) 2010 openpyxl + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +@license: http://www.opensource.org/licenses/mit-license.php +@author: Eric Gazoni +''' + +from openpyxl.shared.xmltools import Element, SubElement, get_document_content +from openpyxl.chart import Chart, ErrorBar + +class ChartWriter(object): + + def __init__(self, chart): + self.chart = chart + + def write(self): + """ write a chart """ + + root = Element('c:chartSpace', + {'xmlns:c':"http://schemas.openxmlformats.org/drawingml/2006/chart", + 'xmlns:a':"http://schemas.openxmlformats.org/drawingml/2006/main", + 'xmlns:r':"http://schemas.openxmlformats.org/officeDocument/2006/relationships"}) + + SubElement(root, 'c:lang', {'val':self.chart.lang}) + self._write_chart(root) + self._write_print_settings(root) + self._write_shapes(root) + + return get_document_content(root) + + def _write_chart(self, root): + + chart = self.chart + + ch = SubElement(root, 'c:chart') + self._write_title(ch) + plot_area = SubElement(ch, 'c:plotArea') + layout = SubElement(plot_area, 'c:layout') + mlayout = SubElement(layout, 'c:manualLayout') + SubElement(mlayout, 'c:layoutTarget', {'val':'inner'}) + SubElement(mlayout, 'c:xMode', {'val':'edge'}) + SubElement(mlayout, 'c:yMode', {'val':'edge'}) + SubElement(mlayout, 'c:x', {'val':str(chart._get_margin_left())}) + SubElement(mlayout, 'c:y', {'val':str(chart._get_margin_top())}) + SubElement(mlayout, 'c:w', {'val':str(chart.width)}) + SubElement(mlayout, 'c:h', {'val':str(chart.height)}) + + if chart.type == Chart.SCATTER_CHART: + subchart = SubElement(plot_area, 'c:scatterChart') + SubElement(subchart, 'c:scatterStyle', {'val':str('lineMarker')}) + else: + if chart.type == Chart.BAR_CHART: + subchart = SubElement(plot_area, 'c:barChart') + SubElement(subchart, 'c:barDir', {'val':'col'}) + else: + subchart = SubElement(plot_area, 'c:lineChart') + + SubElement(subchart, 'c:grouping', {'val':chart.grouping}) + + self._write_series(subchart) + + SubElement(subchart, 'c:marker', {'val':'1'}) + SubElement(subchart, 'c:axId', {'val':str(chart.x_axis.id)}) + SubElement(subchart, 'c:axId', {'val':str(chart.y_axis.id)}) + + if chart.type == Chart.SCATTER_CHART: + self._write_axis(plot_area, chart.x_axis, 'c:valAx') + else: + self._write_axis(plot_area, chart.x_axis, 'c:catAx') + self._write_axis(plot_area, chart.y_axis, 'c:valAx') + + self._write_legend(ch) + + SubElement(ch, 'c:plotVisOnly', {'val':'1'}) + + def _write_title(self, chart): + if self.chart.title != '': + title = SubElement(chart, 'c:title') + tx = SubElement(title, 'c:tx') + rich = SubElement(tx, 'c:rich') + SubElement(rich, 'a:bodyPr') + SubElement(rich, 'a:lstStyle') + p = SubElement(rich, 'a:p') + pPr = SubElement(p, 'a:pPr') + SubElement(pPr, 'a:defRPr') + r = SubElement(p, 'a:r') + SubElement(r, 'a:rPr', {'lang':self.chart.lang}) + t = SubElement(r, 'a:t').text = self.chart.title + SubElement(title, 'c:layout') + + def _write_axis(self, plot_area, axis, label): + + ax = SubElement(plot_area, label) + SubElement(ax, 'c:axId', {'val':str(axis.id)}) + + scaling = SubElement(ax, 'c:scaling') + SubElement(scaling, 'c:orientation', {'val':axis.orientation}) + if label == 'c:valAx': + SubElement(scaling, 'c:max', {'val':str(axis.max)}) + SubElement(scaling, 'c:min', {'val':str(axis.min)}) + + SubElement(ax, 'c:axPos', {'val':axis.position}) + if label == 'c:valAx': + SubElement(ax, 'c:majorGridlines') + SubElement(ax, 'c:numFmt', {'formatCode':"General", 'sourceLinked':'1'}) + SubElement(ax, 'c:tickLblPos', {'val':axis.tick_label_position}) + SubElement(ax, 'c:crossAx', {'val':str(axis.cross)}) + SubElement(ax, 'c:crosses', {'val':axis.crosses}) + if axis.auto: + SubElement(ax, 'c:auto', {'val':'1'}) + if axis.label_align: + SubElement(ax, 'c:lblAlgn', {'val':axis.label_align}) + if axis.label_offset: + SubElement(ax, 'c:lblOffset', {'val':str(axis.label_offset)}) + if label == 'c:valAx': + if self.chart.type == Chart.SCATTER_CHART: + SubElement(ax, 'c:crossBetween', {'val':'midCat'}) + else: + SubElement(ax, 'c:crossBetween', {'val':'between'}) + SubElement(ax, 'c:majorUnit', {'val':str(axis.unit)}) + + def _write_series(self, subchart): + + for i, serie in enumerate(self.chart._series): + ser = SubElement(subchart, 'c:ser') + SubElement(ser, 'c:idx', {'val':str(i)}) + SubElement(ser, 'c:order', {'val':str(i)}) + + if serie.legend: + tx = SubElement(ser, 'c:tx') + self._write_serial(tx, serie.legend) + + if serie.color: + sppr = SubElement(ser, 'c:spPr') + if self.chart.type == Chart.BAR_CHART: + # fill color + fillc = SubElement(sppr, 'a:solidFill') + SubElement(fillc, 'a:srgbClr', {'val':serie.color}) + # edge color + ln = SubElement(sppr, 'a:ln') + fill = SubElement(ln, 'a:solidFill') + SubElement(fill, 'a:srgbClr', {'val':serie.color}) + + if serie.error_bar: + self._write_error_bar(ser, serie) + + marker = SubElement(ser, 'c:marker') + SubElement(marker, 'c:symbol', {'val':serie.marker}) + + if serie.labels: + cat = SubElement(ser, 'c:cat') + self._write_serial(cat, serie.labels) + + if self.chart.type == Chart.SCATTER_CHART: + if serie.xvalues: + xval = SubElement(ser, 'c:xVal') + self._write_serial(xval, serie.xvalues) + + yval = SubElement(ser, 'c:yVal') + self._write_serial(yval, serie.values) + else: + val = SubElement(ser, 'c:val') + self._write_serial(val, serie.values) + + def _write_serial(self, node, serie, literal=False): + + cache = serie._get_cache() + if isinstance(cache[0], basestring): + typ = 'str' + else: + typ = 'num' + + if not literal: + if typ == 'num': + ref = SubElement(node, 'c:numRef') + else: + ref = SubElement(node, 'c:strRef') + SubElement(ref, 'c:f').text = serie._get_ref() + if typ == 'num': + data = SubElement(ref, 'c:numCache') + else: + data = SubElement(ref, 'c:strCache') + else: + data = SubElement(node, 'c:numLit') + + if typ == 'num': + SubElement(data, 'c:formatCode').text = 'General' + if literal: + values = (1,) + else: + values = cache + + SubElement(data, 'c:ptCount', {'val':str(len(values))}) + for j, val in enumerate(values): + point = SubElement(data, 'c:pt', {'idx':str(j)}) + SubElement(point, 'c:v').text = str(val) + + def _write_error_bar(self, node, serie): + + flag = {ErrorBar.PLUS_MINUS:'both', + ErrorBar.PLUS:'plus', + ErrorBar.MINUS:'minus'} + + eb = SubElement(node, 'c:errBars') + SubElement(eb, 'c:errBarType', {'val':flag[serie.error_bar.type]}) + SubElement(eb, 'c:errValType', {'val':'cust'}) + + plus = SubElement(eb, 'c:plus') + self._write_serial(plus, serie.error_bar.values, + literal=(serie.error_bar.type==ErrorBar.MINUS)) + + minus = SubElement(eb, 'c:minus') + self._write_serial(minus, serie.error_bar.values, + literal=(serie.error_bar.type==ErrorBar.PLUS)) + + def _write_legend(self, chart): + + legend = SubElement(chart, 'c:legend') + SubElement(legend, 'c:legendPos', {'val':self.chart.legend.position}) + SubElement(legend, 'c:layout') + + def _write_print_settings(self, root): + + settings = SubElement(root, 'c:printSettings') + SubElement(settings, 'c:headerFooter') + margins = dict([(k, str(v)) for (k,v) in self.chart.print_margins.iteritems()]) + SubElement(settings, 'c:pageMargins', margins) + SubElement(settings, 'c:pageSetup') + + def _write_shapes(self, root): + + if self.chart._shapes: + SubElement(root, 'c:userShapes', {'r:id':'rId1'}) + + def write_rels(self, drawing_id): + + root = Element('Relationships', {'xmlns' : 'http://schemas.openxmlformats.org/package/2006/relationships'}) + attrs = {'Id' : 'rId1', + 'Type' : 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/chartUserShapes', + 'Target' : '../drawings/drawing%s.xml' % drawing_id } + SubElement(root, 'Relationship', attrs) + return get_document_content(root) diff --git a/tablib/packages/openpyxl/writer/drawings.py b/tablib/packages/openpyxl/writer/drawings.py new file mode 100644 index 0000000..e6e5b30 --- /dev/null +++ b/tablib/packages/openpyxl/writer/drawings.py @@ -0,0 +1,192 @@ +# coding=UTF-8 +''' +Copyright (c) 2010 openpyxl + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +@license: http://www.opensource.org/licenses/mit-license.php +@author: Eric Gazoni +''' + +from openpyxl.shared.xmltools import Element, SubElement, get_document_content + + +class DrawingWriter(object): + """ one main drawing file per sheet """ + + def __init__(self, sheet): + self._sheet = sheet + + def write(self): + """ write drawings for one sheet in one file """ + + root = Element('xdr:wsDr', + {'xmlns:xdr' : "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing", + 'xmlns:a' : "http://schemas.openxmlformats.org/drawingml/2006/main"}) + + for i, chart in enumerate(self._sheet._charts): + + drawing = chart.drawing + +# anchor = SubElement(root, 'xdr:twoCellAnchor') +# (start_row, start_col), (end_row, end_col) = drawing.coordinates +# # anchor coordinates +# _from = SubElement(anchor, 'xdr:from') +# x = SubElement(_from, 'xdr:col').text = str(start_col) +# x = SubElement(_from, 'xdr:colOff').text = '0' +# x = SubElement(_from, 'xdr:row').text = str(start_row) +# x = SubElement(_from, 'xdr:rowOff').text = '0' + +# _to = SubElement(anchor, 'xdr:to') +# x = SubElement(_to, 'xdr:col').text = str(end_col) +# x = SubElement(_to, 'xdr:colOff').text = '0' +# x = SubElement(_to, 'xdr:row').text = str(end_row) +# x = SubElement(_to, 'xdr:rowOff').text = '0' + + # we only support absolute anchor atm (TODO: oneCellAnchor, twoCellAnchor + x, y, w, h = drawing.get_emu_dimensions() + anchor = SubElement(root, 'xdr:absoluteAnchor') + SubElement(anchor, 'xdr:pos', {'x':str(x), 'y':str(y)}) + SubElement(anchor, 'xdr:ext', {'cx':str(w), 'cy':str(h)}) + + # graph frame + frame = SubElement(anchor, 'xdr:graphicFrame', {'macro':''}) + + name = SubElement(frame, 'xdr:nvGraphicFramePr') + SubElement(name, 'xdr:cNvPr', {'id':'%s' % i, 'name':'Graphique %s' % i}) + SubElement(name, 'xdr:cNvGraphicFramePr') + + frm = SubElement(frame, 'xdr:xfrm') + # no transformation + SubElement(frm, 'a:off', {'x':'0', 'y':'0'}) + SubElement(frm, 'a:ext', {'cx':'0', 'cy':'0'}) + + graph = SubElement(frame, 'a:graphic') + data = SubElement(graph, 'a:graphicData', + {'uri':'http://schemas.openxmlformats.org/drawingml/2006/chart'}) + SubElement(data, 'c:chart', + { 'xmlns:c':'http://schemas.openxmlformats.org/drawingml/2006/chart', + 'xmlns:r':'http://schemas.openxmlformats.org/officeDocument/2006/relationships', + 'r:id':'rId%s' % (i + 1)}) + + SubElement(anchor, 'xdr:clientData') + + return get_document_content(root) + + def write_rels(self, chart_id): + + root = Element('Relationships', + {'xmlns' : 'http://schemas.openxmlformats.org/package/2006/relationships'}) + for i, chart in enumerate(self._sheet._charts): + attrs = {'Id' : 'rId%s' % (i + 1), + 'Type' : 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart', + 'Target' : '../charts/chart%s.xml' % (chart_id + i) } + SubElement(root, 'Relationship', attrs) + return get_document_content(root) + +class ShapeWriter(object): + """ one file per shape """ + + schema = "http://schemas.openxmlformats.org/drawingml/2006/main" + + def __init__(self, shapes): + + self._shapes = shapes + + def write(self, shape_id): + + root = Element('c:userShapes', {'xmlns:c' : 'http://schemas.openxmlformats.org/drawingml/2006/chart'}) + + for shape in self._shapes: + anchor = SubElement(root, 'cdr:relSizeAnchor', + {'xmlns:cdr' : "http://schemas.openxmlformats.org/drawingml/2006/chartDrawing"}) + + xstart, ystart, xend, yend = shape.get_coordinates() + + _from = SubElement(anchor, 'cdr:from') + SubElement(_from, 'cdr:x').text = str(xstart) + SubElement(_from, 'cdr:y').text = str(ystart) + + _to = SubElement(anchor, 'cdr:to') + SubElement(_to, 'cdr:x').text = str(xend) + SubElement(_to, 'cdr:y').text = str(yend) + + sp = SubElement(anchor, 'cdr:sp', {'macro':'', 'textlink':''}) + nvspr = SubElement(sp, 'cdr:nvSpPr') + SubElement(nvspr, 'cdr:cNvPr', {'id':str(shape_id), 'name':'shape %s' % shape_id}) + SubElement(nvspr, 'cdr:cNvSpPr') + + sppr = SubElement(sp, 'cdr:spPr') + frm = SubElement(sppr, 'a:xfrm', {'xmlns:a':self.schema}) + # no transformation + SubElement(frm, 'a:off', {'x':'0', 'y':'0'}) + SubElement(frm, 'a:ext', {'cx':'0', 'cy':'0'}) + + prstgeom = SubElement(sppr, 'a:prstGeom', {'xmlns:a':self.schema, 'prst':str(shape.style)}) + SubElement(prstgeom, 'a:avLst') + + fill = SubElement(sppr, 'a:solidFill', {'xmlns:a':self.schema}) + SubElement(fill, 'a:srgbClr', {'val':shape.color}) + + border = SubElement(sppr, 'a:ln', {'xmlns:a':self.schema, 'w':str(shape._border_width)}) + sf = SubElement(border, 'a:solidFill') + SubElement(sf, 'a:srgbClr', {'val':shape.border_color}) + + self._write_style(sp) + self._write_text(sp, shape) + + shape_id += 1 + + return get_document_content(root) + + def _write_text(self, node, shape): + """ write text in the shape """ + + tx_body = SubElement(node, 'cdr:txBody') + SubElement(tx_body, 'a:bodyPr', {'xmlns:a':self.schema, 'vertOverflow':'clip'}) + SubElement(tx_body, 'a:lstStyle', + {'xmlns:a':self.schema}) + p = SubElement(tx_body, 'a:p', {'xmlns:a':self.schema}) + if shape.text: + r = SubElement(p, 'a:r') + rpr = SubElement(r, 'a:rPr', {'lang':'en-US'}) + fill = SubElement(rpr, 'a:solidFill') + SubElement(fill, 'a:srgbClr', {'val':shape.text_color}) + + SubElement(r, 'a:t').text = shape.text + else: + SubElement(p, 'a:endParaRPr', {'lang':'en-US'}) + + def _write_style(self, node): + """ write style theme """ + + style = SubElement(node, 'cdr:style') + + ln_ref = SubElement(style, 'a:lnRef', {'xmlns:a':self.schema, 'idx':'2'}) + scheme_clr = SubElement(ln_ref, 'a:schemeClr', {'val':'accent1'}) + SubElement(scheme_clr, 'a:shade', {'val':'50000'}) + + fill_ref = SubElement(style, 'a:fillRef', {'xmlns:a':self.schema, 'idx':'1'}) + SubElement(fill_ref, 'a:schemeClr', {'val':'accent1'}) + + effect_ref = SubElement(style, 'a:effectRef', {'xmlns:a':self.schema, 'idx':'0'}) + SubElement(effect_ref, 'a:schemeClr', {'val':'accent1'}) + + font_ref = SubElement(style, 'a:fontRef', {'xmlns:a':self.schema, 'idx':'minor'}) + SubElement(font_ref, 'a:schemeClr', {'val':'lt1'}) diff --git a/tablib/packages/openpyxl/writer/dump_worksheet.py b/tablib/packages/openpyxl/writer/dump_worksheet.py new file mode 100644 index 0000000..da4ef56 --- /dev/null +++ b/tablib/packages/openpyxl/writer/dump_worksheet.py @@ -0,0 +1,256 @@ +# file openpyxl/writer/straight_worksheet.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Write worksheets to xml representations in an optimized way""" + +import datetime +import os + +from openpyxl.cell import column_index_from_string, get_column_letter, Cell +from openpyxl.worksheet import Worksheet +from openpyxl.shared.xmltools import XMLGenerator, get_document_content, \ + start_tag, end_tag, tag +from openpyxl.shared.date_time import SharedDate +from openpyxl.shared.ooxml import MAX_COLUMN, MAX_ROW +from tempfile import NamedTemporaryFile +from openpyxl.writer.excel import ExcelWriter +from openpyxl.writer.strings import write_string_table +from openpyxl.writer.styles import StyleWriter +from openpyxl.style import Style, NumberFormat + +from openpyxl.shared.ooxml import ARC_SHARED_STRINGS, ARC_CONTENT_TYPES, \ + ARC_ROOT_RELS, ARC_WORKBOOK_RELS, ARC_APP, ARC_CORE, ARC_THEME, \ + ARC_STYLE, ARC_WORKBOOK, \ + PACKAGE_WORKSHEETS, PACKAGE_DRAWINGS, PACKAGE_CHARTS + +STYLES = {'datetime' : {'type':Cell.TYPE_NUMERIC, + 'style':'1'}, + 'string':{'type':Cell.TYPE_STRING, + 'style':'0'}, + 'numeric':{'type':Cell.TYPE_NUMERIC, + 'style':'0'}, + 'formula':{'type':Cell.TYPE_FORMULA, + 'style':'0'}, + 'boolean':{'type':Cell.TYPE_BOOL, + 'style':'0'}, + } + +DATETIME_STYLE = Style() +DATETIME_STYLE.number_format.format_code = NumberFormat.FORMAT_DATE_YYYYMMDD2 +BOUNDING_BOX_PLACEHOLDER = 'A1:%s%d' % (get_column_letter(MAX_COLUMN), MAX_ROW) + +class DumpWorksheet(Worksheet): + + """ + .. warning:: + + You shouldn't initialize this yourself, use :class:`openpyxl.workbook.Workbook` constructor instead, + with `optimized_write = True`. + """ + + def __init__(self, parent_workbook): + + Worksheet.__init__(self, parent_workbook) + + self._max_col = 0 + self._max_row = 0 + self._parent = parent_workbook + self._fileobj_header = NamedTemporaryFile(mode='r+', prefix='openpyxl.', suffix='.header', delete=False) + self._fileobj_content = NamedTemporaryFile(mode='r+', prefix='openpyxl.', suffix='.content', delete=False) + self._fileobj = NamedTemporaryFile(mode='w', prefix='openpyxl.', delete=False) + self.doc = XMLGenerator(self._fileobj_content, 'utf-8') + self.header = XMLGenerator(self._fileobj_header, 'utf-8') + self.title = 'Sheet' + + self._shared_date = SharedDate() + self._string_builder = self._parent.strings_table_builder + + @property + def filename(self): + return self._fileobj.name + + def write_header(self): + + doc = self.header + + start_tag(doc, 'worksheet', + {'xml:space': 'preserve', + 'xmlns': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main', + 'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships'}) + start_tag(doc, 'sheetPr') + tag(doc, 'outlinePr', + {'summaryBelow': '1', + 'summaryRight': '1'}) + end_tag(doc, 'sheetPr') + tag(doc, 'dimension', {'ref': 'A1:%s' % (self.get_dimensions())}) + start_tag(doc, 'sheetViews') + start_tag(doc, 'sheetView', {'workbookViewId': '0'}) + tag(doc, 'selection', {'activeCell': 'A1', + 'sqref': 'A1'}) + end_tag(doc, 'sheetView') + end_tag(doc, 'sheetViews') + tag(doc, 'sheetFormatPr', {'defaultRowHeight': '15'}) + start_tag(doc, 'sheetData') + + def close(self): + + self._close_content() + self._close_header() + + self._write_fileobj(self._fileobj_header) + self._write_fileobj(self._fileobj_content) + + self._fileobj.close() + + def _write_fileobj(self, fobj): + + fobj.flush() + fobj.seek(0) + + while True: + chunk = fobj.read(4096) + if not chunk: + break + self._fileobj.write(chunk) + + fobj.close() + os.remove(fobj.name) + + self._fileobj.flush() + + def _close_header(self): + + doc = self.header + #doc.endDocument() + + def _close_content(self): + + doc = self.doc + end_tag(doc, 'sheetData') + + end_tag(doc, 'worksheet') + #doc.endDocument() + + def get_dimensions(self): + + if not self._max_col or not self._max_row: + return 'A1' + else: + return '%s%d' % (get_column_letter(self._max_col), (self._max_row)) + + def append(self, row): + + """ + :param row: iterable containing values to append + :type row: iterable + """ + + doc = self.doc + + self._max_row += 1 + span = len(row) + self._max_col = max(self._max_col, span) + + row_idx = self._max_row + + attrs = {'r': '%d' % row_idx, + 'spans': '1:%d' % span} + + start_tag(doc, 'row', attrs) + + for col_idx, cell in enumerate(row): + + if cell is None: + continue + + coordinate = '%s%d' % (get_column_letter(col_idx+1), row_idx) + attributes = {'r': coordinate} + + if isinstance(cell, bool): + dtype = 'boolean' + elif isinstance(cell, (int, float)): + dtype = 'numeric' + elif isinstance(cell, (datetime.datetime, datetime.date)): + dtype = 'datetime' + cell = self._shared_date.datetime_to_julian(cell) + attributes['s'] = STYLES[dtype]['style'] + elif cell and cell[0] == '=': + dtype = 'formula' + else: + dtype = 'string' + cell = self._string_builder.add(cell) + + attributes['t'] = STYLES[dtype]['type'] + + start_tag(doc, 'c', attributes) + + if dtype == 'formula': + tag(doc, 'f', body = '%s' % cell[1:]) + tag(doc, 'v') + else: + tag(doc, 'v', body = '%s' % cell) + + end_tag(doc, 'c') + + + end_tag(doc, 'row') + + +def save_dump(workbook, filename): + + writer = ExcelDumpWriter(workbook) + writer.save(filename) + return True + +class ExcelDumpWriter(ExcelWriter): + + def __init__(self, workbook): + + self.workbook = workbook + self.style_writer = StyleDumpWriter(workbook) + self.style_writer._style_list.append(DATETIME_STYLE) + + def _write_string_table(self, archive): + + shared_string_table = self.workbook.strings_table_builder.get_table() + archive.writestr(ARC_SHARED_STRINGS, + write_string_table(shared_string_table)) + + return shared_string_table + + def _write_worksheets(self, archive, shared_string_table, style_writer): + + for i, sheet in enumerate(self.workbook.worksheets): + sheet.write_header() + sheet.close() + archive.write(sheet.filename, PACKAGE_WORKSHEETS + '/sheet%d.xml' % (i + 1)) + os.remove(sheet.filename) + + +class StyleDumpWriter(StyleWriter): + + def _get_style_list(self, workbook): + return [] + diff --git a/tablib/packages/openpyxl/writer/excel.py b/tablib/packages/openpyxl/writer/excel.py new file mode 100644 index 0000000..192716e --- /dev/null +++ b/tablib/packages/openpyxl/writer/excel.py @@ -0,0 +1,156 @@ +# file openpyxl/writer/excel.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Write a .xlsx file.""" + +# Python stdlib imports +from zipfile import ZipFile, ZIP_DEFLATED +from StringIO import StringIO + +# package imports +from openpyxl.shared.ooxml import ARC_SHARED_STRINGS, ARC_CONTENT_TYPES, \ + ARC_ROOT_RELS, ARC_WORKBOOK_RELS, ARC_APP, ARC_CORE, ARC_THEME, \ + ARC_STYLE, ARC_WORKBOOK, \ + PACKAGE_WORKSHEETS, PACKAGE_DRAWINGS, PACKAGE_CHARTS +from openpyxl.writer.strings import create_string_table, write_string_table +from openpyxl.writer.workbook import write_content_types, write_root_rels, \ + write_workbook_rels, write_properties_app, write_properties_core, \ + write_workbook +from openpyxl.writer.theme import write_theme +from openpyxl.writer.styles import StyleWriter +from openpyxl.writer.drawings import DrawingWriter, ShapeWriter +from openpyxl.writer.charts import ChartWriter +from openpyxl.writer.worksheet import write_worksheet, write_worksheet_rels + + +class ExcelWriter(object): + """Write a workbook object to an Excel file.""" + + def __init__(self, workbook): + self.workbook = workbook + self.style_writer = StyleWriter(self.workbook) + + def write_data(self, archive): + """Write the various xml files into the zip archive.""" + # cleanup all worksheets + shared_string_table = self._write_string_table(archive) + + archive.writestr(ARC_CONTENT_TYPES, write_content_types(self.workbook)) + archive.writestr(ARC_ROOT_RELS, write_root_rels(self.workbook)) + archive.writestr(ARC_WORKBOOK_RELS, write_workbook_rels(self.workbook)) + archive.writestr(ARC_APP, write_properties_app(self.workbook)) + archive.writestr(ARC_CORE, + write_properties_core(self.workbook.properties)) + archive.writestr(ARC_THEME, write_theme()) + archive.writestr(ARC_STYLE, self.style_writer.write_table()) + archive.writestr(ARC_WORKBOOK, write_workbook(self.workbook)) + + self._write_worksheets(archive, shared_string_table, self.style_writer) + + def _write_string_table(self, archive): + + for ws in self.workbook.worksheets: + ws.garbage_collect() + shared_string_table = create_string_table(self.workbook) + archive.writestr(ARC_SHARED_STRINGS, + write_string_table(shared_string_table)) + + return shared_string_table + + def _write_worksheets(self, archive, shared_string_table, style_writer): + + drawing_id = 1 + chart_id = 1 + shape_id = 1 + + for i, sheet in enumerate(self.workbook.worksheets): + archive.writestr(PACKAGE_WORKSHEETS + '/sheet%d.xml' % (i + 1), + write_worksheet(sheet, shared_string_table, + style_writer.get_style_by_hash())) + if sheet._charts or sheet.relationships: + archive.writestr(PACKAGE_WORKSHEETS + + '/_rels/sheet%d.xml.rels' % (i + 1), + write_worksheet_rels(sheet, drawing_id)) + if sheet._charts: + dw = DrawingWriter(sheet) + archive.writestr(PACKAGE_DRAWINGS + '/drawing%d.xml' % drawing_id, + dw.write()) + archive.writestr(PACKAGE_DRAWINGS + '/_rels/drawing%d.xml.rels' % drawing_id, + dw.write_rels(chart_id)) + drawing_id += 1 + + for chart in sheet._charts: + cw = ChartWriter(chart) + archive.writestr(PACKAGE_CHARTS + '/chart%d.xml' % chart_id, + cw.write()) + + if chart._shapes: + archive.writestr(PACKAGE_CHARTS + '/_rels/chart%d.xml.rels' % chart_id, + cw.write_rels(drawing_id)) + sw = ShapeWriter(chart._shapes) + archive.writestr(PACKAGE_DRAWINGS + '/drawing%d.xml' % drawing_id, + sw.write(shape_id)) + shape_id += len(chart._shapes) + drawing_id += 1 + + chart_id += 1 + + + def save(self, filename): + """Write data into the archive.""" + archive = ZipFile(filename, 'w', ZIP_DEFLATED) + self.write_data(archive) + archive.close() + + +def save_workbook(workbook, filename): + """Save the given workbook on the filesystem under the name filename. + + :param workbook: the workbook to save + :type workbook: :class:`openpyxl.workbook.Workbook` + + :param filename: the path to which save the workbook + :type filename: string + + :rtype: bool + + """ + writer = ExcelWriter(workbook) + writer.save(filename) + return True + + +def save_virtual_workbook(workbook): + """Return an in-memory workbook, suitable for a Django response.""" + writer = ExcelWriter(workbook) + temp_buffer = StringIO() + try: + archive = ZipFile(temp_buffer, 'w', ZIP_DEFLATED) + writer.write_data(archive) + finally: + archive.close() + virtual_workbook = temp_buffer.getvalue() + temp_buffer.close() + return virtual_workbook diff --git a/tablib/packages/openpyxl/writer/strings.py b/tablib/packages/openpyxl/writer/strings.py new file mode 100644 index 0000000..245c48b --- /dev/null +++ b/tablib/packages/openpyxl/writer/strings.py @@ -0,0 +1,86 @@ +# file openpyxl/writer/strings.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Write the shared string table.""" + +# Python stdlib imports +from StringIO import StringIO + +# package imports +from openpyxl.shared.xmltools import start_tag, end_tag, tag, XMLGenerator + + +def create_string_table(workbook): + """Compile the string table for a workbook.""" + strings = set() + for sheet in workbook.worksheets: + for cell in sheet.get_cell_collection(): + if cell.data_type == cell.TYPE_STRING and cell._value is not None: + strings.add(cell.value) + return dict((key, i) for i, key in enumerate(strings)) + + +def write_string_table(string_table): + """Write the string table xml.""" + temp_buffer = StringIO() + doc = XMLGenerator(temp_buffer, 'utf-8') + start_tag(doc, 'sst', {'xmlns': + 'http://schemas.openxmlformats.org/spreadsheetml/2006/main', + 'uniqueCount': '%d' % len(string_table)}) + strings_to_write = sorted(string_table.iteritems(), + key=lambda pair: pair[1]) + for key in [pair[0] for pair in strings_to_write]: + start_tag(doc, 'si') + if key.strip() != key: + attr = {'xml:space': 'preserve'} + else: + attr = {} + tag(doc, 't', attr, key) + end_tag(doc, 'si') + end_tag(doc, 'sst') + string_table_xml = temp_buffer.getvalue() + temp_buffer.close() + return string_table_xml + +class StringTableBuilder(object): + + def __init__(self): + + self.counter = 0 + self.dct = {} + + def add(self, key): + + key = key.strip() + try: + return self.dct[key] + except KeyError: + res = self.dct[key] = self.counter + self.counter += 1 + return res + + def get_table(self): + + return self.dct diff --git a/tablib/packages/openpyxl/writer/styles.py b/tablib/packages/openpyxl/writer/styles.py new file mode 100644 index 0000000..7bf91dd --- /dev/null +++ b/tablib/packages/openpyxl/writer/styles.py @@ -0,0 +1,256 @@ +# file openpyxl/writer/styles.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Write the shared style table.""" + +# package imports +from openpyxl.shared.xmltools import Element, SubElement +from openpyxl.shared.xmltools import get_document_content +from openpyxl import style + +class StyleWriter(object): + + def __init__(self, workbook): + self._style_list = self._get_style_list(workbook) + self._root = Element('styleSheet', + {'xmlns':'http://schemas.openxmlformats.org/spreadsheetml/2006/main'}) + + def _get_style_list(self, workbook): + crc = {} + for worksheet in workbook.worksheets: + for style in worksheet._styles.values(): + crc[hash(style)] = style + self.style_table = dict([(style, i+1) \ + for i, style in enumerate(crc.values())]) + sorted_styles = sorted(self.style_table.iteritems(), \ + key = lambda pair:pair[1]) + return [s[0] for s in sorted_styles] + + def get_style_by_hash(self): + return dict([(hash(style), id) \ + for style, id in self.style_table.iteritems()]) + + def write_table(self): + number_format_table = self._write_number_formats() + fonts_table = self._write_fonts() + fills_table = self._write_fills() + borders_table = self._write_borders() + self._write_cell_style_xfs() + self._write_cell_xfs(number_format_table, fonts_table, fills_table, borders_table) + self._write_cell_style() + self._write_dxfs() + self._write_table_styles() + + return get_document_content(xml_node=self._root) + + def _write_fonts(self): + """ add fonts part to root + return {font.crc => index} + """ + + fonts = SubElement(self._root, 'fonts') + + # default + font_node = SubElement(fonts, 'font') + SubElement(font_node, 'sz', {'val':'11'}) + SubElement(font_node, 'color', {'theme':'1'}) + SubElement(font_node, 'name', {'val':'Calibri'}) + SubElement(font_node, 'family', {'val':'2'}) + SubElement(font_node, 'scheme', {'val':'minor'}) + + # others + table = {} + index = 1 + for st in self._style_list: + if hash(st.font) != hash(style.DEFAULTS.font) and hash(st.font) not in table: + table[hash(st.font)] = str(index) + font_node = SubElement(fonts, 'font') + SubElement(font_node, 'sz', {'val':str(st.font.size)}) + SubElement(font_node, 'color', {'rgb':str(st.font.color.index)}) + SubElement(font_node, 'name', {'val':st.font.name}) + SubElement(font_node, 'family', {'val':'2'}) + SubElement(font_node, 'scheme', {'val':'minor'}) + if st.font.bold: + SubElement(font_node, 'b') + if st.font.italic: + SubElement(font_node, 'i') + index += 1 + + fonts.attrib["count"] = str(index) + return table + + def _write_fills(self): + fills = SubElement(self._root, 'fills', {'count':'2'}) + fill = SubElement(fills, 'fill') + SubElement(fill, 'patternFill', {'patternType':'none'}) + fill = SubElement(fills, 'fill') + SubElement(fill, 'patternFill', {'patternType':'gray125'}) + + table = {} + index = 2 + for st in self._style_list: + if hash(st.fill) != hash(style.DEFAULTS.fill) and hash(st.fill) not in table: + table[hash(st.fill)] = str(index) + fill = SubElement(fills, 'fill') + if hash(st.fill.fill_type) != hash(style.DEFAULTS.fill.fill_type): + node = SubElement(fill,'patternFill', {'patternType':st.fill.fill_type}) + if hash(st.fill.start_color) != hash(style.DEFAULTS.fill.start_color): + + SubElement(node, 'fgColor', {'rgb':str(st.fill.start_color.index)}) + if hash(st.fill.end_color) != hash(style.DEFAULTS.fill.end_color): + SubElement(node, 'bgColor', {'rgb':str(st.fill.start_color.index)}) + index += 1 + + fills.attrib["count"] = str(index) + return table + + def _write_borders(self): + borders = SubElement(self._root, 'borders') + + # default + border = SubElement(borders, 'border') + SubElement(border, 'left') + SubElement(border, 'right') + SubElement(border, 'top') + SubElement(border, 'bottom') + SubElement(border, 'diagonal') + + # others + table = {} + index = 1 + for st in self._style_list: + if hash(st.borders) != hash(style.DEFAULTS.borders) and hash(st.borders) not in table: + table[hash(st.borders)] = str(index) + border = SubElement(borders, 'border') + # caution: respect this order + for side in ('left','right','top','bottom','diagonal'): + obj = getattr(st.borders, side) + node = SubElement(border, side, {'style':obj.border_style}) + SubElement(node, 'color', {'rgb':str(obj.color.index)}) + index += 1 + + borders.attrib["count"] = str(index) + return table + + def _write_cell_style_xfs(self): + cell_style_xfs = SubElement(self._root, 'cellStyleXfs', {'count':'1'}) + xf = SubElement(cell_style_xfs, 'xf', + {'numFmtId':"0", 'fontId':"0", 'fillId':"0", 'borderId':"0"}) + + def _write_cell_xfs(self, number_format_table, fonts_table, fills_table, borders_table): + """ write styles combinations based on ids found in tables """ + + # writing the cellXfs + cell_xfs = SubElement(self._root, 'cellXfs', + {'count':'%d' % (len(self._style_list) + 1)}) + + # default + def _get_default_vals(): + return dict(numFmtId='0', fontId='0', fillId='0', + xfId='0', borderId='0') + + SubElement(cell_xfs, 'xf', _get_default_vals()) + + for st in self._style_list: + vals = _get_default_vals() + + if hash(st.font) != hash(style.DEFAULTS.font): + vals['fontId'] = fonts_table[hash(st.font)] + vals['applyFont'] = '1' + + if hash(st.borders) != hash(style.DEFAULTS.borders): + vals['borderId'] = borders_table[hash(st.borders)] + vals['applyBorder'] = '1' + + if hash(st.fill) != hash(style.DEFAULTS.fill): + vals['fillId'] = fills_table[hash(st.fill)] + vals['applyFillId'] = '1' + + if st.number_format != style.DEFAULTS.number_format: + vals['numFmtId'] = '%d' % number_format_table[st.number_format] + vals['applyNumberFormat'] = '1' + + if hash(st.alignment) != hash(style.DEFAULTS.alignment): + vals['applyAlignment'] = '1' + + node = SubElement(cell_xfs, 'xf', vals) + + if hash(st.alignment) != hash(style.DEFAULTS.alignment): + alignments = {} + + for align_attr in ['horizontal','vertical']: + if hash(getattr(st.alignment, align_attr)) != hash(getattr(style.DEFAULTS.alignment, align_attr)): + alignments[align_attr] = getattr(st.alignment, align_attr) + + SubElement(node, 'alignment', alignments) + + + def _write_cell_style(self): + cell_styles = SubElement(self._root, 'cellStyles', {'count':'1'}) + cell_style = SubElement(cell_styles, 'cellStyle', + {'name':"Normal", 'xfId':"0", 'builtinId':"0"}) + + def _write_dxfs(self): + dxfs = SubElement(self._root, 'dxfs', {'count':'0'}) + + def _write_table_styles(self): + + table_styles = SubElement(self._root, 'tableStyles', + {'count':'0', 'defaultTableStyle':'TableStyleMedium9', + 'defaultPivotStyle':'PivotStyleLight16'}) + + def _write_number_formats(self): + + number_format_table = {} + + number_format_list = [] + exceptions_list = [] + num_fmt_id = 165 # start at a greatly higher value as any builtin can go + num_fmt_offset = 0 + + for style in self._style_list: + + if not style.number_format in number_format_list : + number_format_list.append(style.number_format) + + for number_format in number_format_list: + + if number_format.is_builtin(): + btin = number_format.builtin_format_id(number_format.format_code) + number_format_table[number_format] = btin + else: + number_format_table[number_format] = num_fmt_id + num_fmt_offset + num_fmt_offset += 1 + exceptions_list.append(number_format) + + num_fmts = SubElement(self._root, 'numFmts', + {'count':'%d' % len(exceptions_list)}) + + for number_format in exceptions_list : + SubElement(num_fmts, 'numFmt', + {'numFmtId':'%d' % number_format_table[number_format], + 'formatCode':'%s' % number_format.format_code}) + + return number_format_table diff --git a/tablib/packages/openpyxl/writer/theme.py b/tablib/packages/openpyxl/writer/theme.py new file mode 100644 index 0000000..4b1723b --- /dev/null +++ b/tablib/packages/openpyxl/writer/theme.py @@ -0,0 +1,202 @@ +# -*- coding: utf-8 -*- +# file openpyxl/writer/theme.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Write the theme xml based on a fixed string.""" + +# package imports +from openpyxl.shared.xmltools import fromstring, get_document_content + + +def write_theme(): + """Write the theme xml.""" + xml_node = fromstring( + '\n' + + '' + '' + + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '') + return get_document_content(xml_node) diff --git a/tablib/packages/openpyxl/writer/workbook.py b/tablib/packages/openpyxl/writer/workbook.py new file mode 100644 index 0000000..5d05b31 --- /dev/null +++ b/tablib/packages/openpyxl/writer/workbook.py @@ -0,0 +1,204 @@ +# file openpyxl/writer/workbook.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Write the workbook global settings to the archive.""" + +# package imports +from openpyxl.shared.xmltools import Element, SubElement +from openpyxl.cell import absolute_coordinate +from openpyxl.shared.xmltools import get_document_content +from openpyxl.shared.ooxml import NAMESPACES, ARC_CORE, ARC_WORKBOOK, \ + ARC_APP, ARC_THEME, ARC_STYLE, ARC_SHARED_STRINGS +from openpyxl.shared.date_time import datetime_to_W3CDTF + + +def write_properties_core(properties): + """Write the core properties to xml.""" + root = Element('cp:coreProperties', {'xmlns:cp': NAMESPACES['cp'], + 'xmlns:xsi': NAMESPACES['xsi'], 'xmlns:dc': NAMESPACES['dc'], + 'xmlns:dcterms': NAMESPACES['dcterms'], + 'xmlns:dcmitype': NAMESPACES['dcmitype'], }) + SubElement(root, 'dc:creator').text = properties.creator + SubElement(root, 'cp:lastModifiedBy').text = properties.last_modified_by + SubElement(root, 'dcterms:created', \ + {'xsi:type': 'dcterms:W3CDTF'}).text = \ + datetime_to_W3CDTF(properties.created) + SubElement(root, 'dcterms:modified', + {'xsi:type': 'dcterms:W3CDTF'}).text = \ + datetime_to_W3CDTF(properties.modified) + return get_document_content(root) + + +def write_content_types(workbook): + """Write the content-types xml.""" + root = Element('Types', {'xmlns': 'http://schemas.openxmlformats.org/package/2006/content-types'}) + SubElement(root, 'Override', {'PartName': '/' + ARC_THEME, 'ContentType': 'application/vnd.openxmlformats-officedocument.theme+xml'}) + SubElement(root, 'Override', {'PartName': '/' + ARC_STYLE, 'ContentType': 'application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml'}) + SubElement(root, 'Default', {'Extension': 'rels', 'ContentType': 'application/vnd.openxmlformats-package.relationships+xml'}) + SubElement(root, 'Default', {'Extension': 'xml', 'ContentType': 'application/xml'}) + SubElement(root, 'Override', {'PartName': '/' + ARC_WORKBOOK, 'ContentType': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml'}) + SubElement(root, 'Override', {'PartName': '/' + ARC_APP, 'ContentType': 'application/vnd.openxmlformats-officedocument.extended-properties+xml'}) + SubElement(root, 'Override', {'PartName': '/' + ARC_CORE, 'ContentType': 'application/vnd.openxmlformats-package.core-properties+xml'}) + SubElement(root, 'Override', {'PartName': '/' + ARC_SHARED_STRINGS, 'ContentType': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml'}) + + drawing_id = 1 + chart_id = 1 + + for sheet_id, sheet in enumerate(workbook.worksheets): + SubElement(root, 'Override', + {'PartName': '/xl/worksheets/sheet%d.xml' % (sheet_id + 1), + 'ContentType': 'application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml'}) + if sheet._charts: + SubElement(root, 'Override', + {'PartName' : '/xl/drawings/drawing%d.xml' % (sheet_id + 1), + 'ContentType' : 'application/vnd.openxmlformats-officedocument.drawing+xml'}) + drawing_id += 1 + + for chart in sheet._charts: + SubElement(root, 'Override', + {'PartName' : '/xl/charts/chart%d.xml' % chart_id, + 'ContentType' : 'application/vnd.openxmlformats-officedocument.drawingml.chart+xml'}) + chart_id += 1 + if chart._shapes: + SubElement(root, 'Override', + {'PartName' : '/xl/drawings/drawing%d.xml' % drawing_id, + 'ContentType' : 'application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml'}) + drawing_id += 1 + + return get_document_content(root) + + +def write_properties_app(workbook): + """Write the properties xml.""" + worksheets_count = len(workbook.worksheets) + root = Element('Properties', {'xmlns': 'http://schemas.openxmlformats.org/officeDocument/2006/extended-properties', + 'xmlns:vt': 'http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes'}) + SubElement(root, 'Application').text = 'Microsoft Excel' + SubElement(root, 'DocSecurity').text = '0' + SubElement(root, 'ScaleCrop').text = 'false' + SubElement(root, 'Company') + SubElement(root, 'LinksUpToDate').text = 'false' + SubElement(root, 'SharedDoc').text = 'false' + SubElement(root, 'HyperlinksChanged').text = 'false' + SubElement(root, 'AppVersion').text = '12.0000' + + # heading pairs part + heading_pairs = SubElement(root, 'HeadingPairs') + vector = SubElement(heading_pairs, 'vt:vector', + {'size': '2', 'baseType': 'variant'}) + variant = SubElement(vector, 'vt:variant') + SubElement(variant, 'vt:lpstr').text = 'Worksheets' + variant = SubElement(vector, 'vt:variant') + SubElement(variant, 'vt:i4').text = '%d' % worksheets_count + + # title of parts + title_of_parts = SubElement(root, 'TitlesOfParts') + vector = SubElement(title_of_parts, 'vt:vector', + {'size': '%d' % worksheets_count, 'baseType': 'lpstr'}) + for ws in workbook.worksheets: + SubElement(vector, 'vt:lpstr').text = '%s' % ws.title + return get_document_content(root) + + +def write_root_rels(workbook): + """Write the relationships xml.""" + root = Element('Relationships', {'xmlns': + 'http://schemas.openxmlformats.org/package/2006/relationships'}) + SubElement(root, 'Relationship', {'Id': 'rId1', 'Target': ARC_WORKBOOK, + 'Type': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument'}) + SubElement(root, 'Relationship', {'Id': 'rId2', 'Target': ARC_CORE, + 'Type': 'http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties'}) + SubElement(root, 'Relationship', {'Id': 'rId3', 'Target': ARC_APP, + 'Type': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties'}) + return get_document_content(root) + + +def write_workbook(workbook): + """Write the core workbook xml.""" + root = Element('workbook', {'xmlns': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main', + 'xml:space': 'preserve', 'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships'}) + SubElement(root, 'fileVersion', {'appName': 'xl', 'lastEdited': '4', + 'lowestEdited': '4', 'rupBuild': '4505'}) + SubElement(root, 'workbookPr', {'defaultThemeVersion': '124226', + 'codeName': 'ThisWorkbook'}) + book_views = SubElement(root, 'bookViews') + SubElement(book_views, 'workbookView', {'activeTab': '%d' % workbook.get_index(workbook.get_active_sheet()), + 'autoFilterDateGrouping': '1', 'firstSheet': '0', 'minimized': '0', + 'showHorizontalScroll': '1', 'showSheetTabs': '1', + 'showVerticalScroll': '1', 'tabRatio': '600', + 'visibility': 'visible'}) + # worksheets + sheets = SubElement(root, 'sheets') + for i, sheet in enumerate(workbook.worksheets): + sheet_node = SubElement(sheets, 'sheet', {'name': sheet.title, + 'sheetId': '%d' % (i + 1), 'r:id': 'rId%d' % (i + 1)}) + if not sheet.sheet_state == sheet.SHEETSTATE_VISIBLE: + sheet_node.set('state', sheet.sheet_state) + # named ranges + defined_names = SubElement(root, 'definedNames') + for named_range in workbook.get_named_ranges(): + name = SubElement(defined_names, 'definedName', + {'name': named_range.name}) + + # as there can be many cells in one range, generate the list of ranges + dest_cells = [] + cell_ids = [] + for worksheet, range_name in named_range.destinations: + cell_ids.append(workbook.get_index(worksheet)) + dest_cells.append("'%s'!%s" % (worksheet.title.replace("'", "''"), + absolute_coordinate(range_name))) + + # for local ranges, we must check all the cells belong to the same sheet + base_id = cell_ids[0] + if named_range.local_only and all([x == base_id for x in cell_ids]): + name.set('localSheetId', '%s' % base_id) + + # finally write the cells list + name.text = ','.join(dest_cells) + + SubElement(root, 'calcPr', {'calcId': '124519', 'calcMode': 'auto', + 'fullCalcOnLoad': '1'}) + return get_document_content(root) + + +def write_workbook_rels(workbook): + """Write the workbook relationships xml.""" + root = Element('Relationships', {'xmlns': + 'http://schemas.openxmlformats.org/package/2006/relationships'}) + for i in range(len(workbook.worksheets)): + SubElement(root, 'Relationship', {'Id': 'rId%d' % (i + 1), + 'Type': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet', + 'Target': 'worksheets/sheet%s.xml' % (i + 1)}) + rid = len(workbook.worksheets) + 1 + SubElement(root, 'Relationship', + {'Id': 'rId%d' % rid, 'Target': 'sharedStrings.xml', + 'Type': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings'}) + SubElement(root, 'Relationship', + {'Id': 'rId%d' % (rid + 1), 'Target': 'styles.xml', + 'Type': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles'}) + SubElement(root, 'Relationship', + {'Id': 'rId%d' % (rid + 2), 'Target': 'theme/theme1.xml', + 'Type': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme'}) + return get_document_content(root) diff --git a/tablib/packages/openpyxl/writer/worksheet.py b/tablib/packages/openpyxl/writer/worksheet.py new file mode 100644 index 0000000..ed85fcb --- /dev/null +++ b/tablib/packages/openpyxl/writer/worksheet.py @@ -0,0 +1,209 @@ +# file openpyxl/writer/worksheet.py + +# Copyright (c) 2010 openpyxl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +# @license: http://www.opensource.org/licenses/mit-license.php +# @author: Eric Gazoni + +"""Write worksheets to xml representations.""" + +# Python stdlib imports +from StringIO import StringIO # cStringIO doesn't handle unicode + +# package imports +from openpyxl.cell import coordinate_from_string, column_index_from_string +from openpyxl.shared.xmltools import Element, SubElement, XMLGenerator, \ + get_document_content, start_tag, end_tag, tag + + +def row_sort(cell): + """Translate column names for sorting.""" + return column_index_from_string(cell.column) + + +def write_worksheet(worksheet, string_table, style_table): + """Write a worksheet to an xml file.""" + xml_file = StringIO() + doc = XMLGenerator(xml_file, 'utf-8') + start_tag(doc, 'worksheet', + {'xml:space': 'preserve', + 'xmlns': 'http://schemas.openxmlformats.org/spreadsheetml/2006/main', + 'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships'}) + start_tag(doc, 'sheetPr') + tag(doc, 'outlinePr', + {'summaryBelow': '%d' % (worksheet.show_summary_below), + 'summaryRight': '%d' % (worksheet.show_summary_right)}) + end_tag(doc, 'sheetPr') + tag(doc, 'dimension', {'ref': '%s' % worksheet.calculate_dimension()}) + write_worksheet_sheetviews(doc, worksheet) + tag(doc, 'sheetFormatPr', {'defaultRowHeight': '15'}) + write_worksheet_cols(doc, worksheet) + write_worksheet_data(doc, worksheet, string_table, style_table) + if worksheet.auto_filter: + tag(doc, 'autoFilter', {'ref': worksheet.auto_filter}) + write_worksheet_hyperlinks(doc, worksheet) + if worksheet._charts: + tag(doc, 'drawing', {'r:id':'rId1'}) + end_tag(doc, 'worksheet') + doc.endDocument() + xml_string = xml_file.getvalue() + xml_file.close() + return xml_string + +def write_worksheet_sheetviews(doc, worksheet): + start_tag(doc, 'sheetViews') + start_tag(doc, 'sheetView', {'workbookViewId': '0'}) + selectionAttrs = {} + topLeftCell = worksheet.freeze_panes + if topLeftCell: + colName, row = coordinate_from_string(topLeftCell) + column = column_index_from_string(colName) + pane = 'topRight' + paneAttrs = {} + if column > 1: + paneAttrs['xSplit'] = str(column - 1) + if row > 1: + paneAttrs['ySplit'] = str(row - 1) + pane = 'bottomLeft' + if column > 1: + pane = 'bottomRight' + paneAttrs.update(dict(topLeftCell=topLeftCell, + activePane=pane, + state='frozen')) + tag(doc, 'pane', paneAttrs) + selectionAttrs['pane'] = pane + if row > 1 and column > 1: + tag(doc, 'selection', {'pane': 'topRight'}) + tag(doc, 'selection', {'pane': 'bottomLeft'}) + + selectionAttrs.update({'activeCell': worksheet.active_cell, + 'sqref': worksheet.selected_cell}) + + tag(doc, 'selection', selectionAttrs) + end_tag(doc, 'sheetView') + end_tag(doc, 'sheetViews') + + +def write_worksheet_cols(doc, worksheet): + """Write worksheet columns to xml.""" + if worksheet.column_dimensions: + start_tag(doc, 'cols') + for column_string, columndimension in \ + worksheet.column_dimensions.iteritems(): + col_index = column_index_from_string(column_string) + col_def = {} + col_def['collapsed'] = str(columndimension.style_index) + col_def['min'] = str(col_index) + col_def['max'] = str(col_index) + if columndimension.width != \ + worksheet.default_column_dimension.width: + col_def['customWidth'] = 'true' + if not columndimension.visible: + col_def['hidden'] = 'true' + if columndimension.outline_level > 0: + col_def['outlineLevel'] = str(columndimension.outline_level) + if columndimension.collapsed: + col_def['collapsed'] = 'true' + if columndimension.auto_size: + col_def['bestFit'] = 'true' + if columndimension.width > 0: + col_def['width'] = str(columndimension.width) + else: + col_def['width'] = '9.10' + tag(doc, 'col', col_def) + end_tag(doc, 'cols') + + +def write_worksheet_data(doc, worksheet, string_table, style_table): + """Write worksheet data to xml.""" + start_tag(doc, 'sheetData') + max_column = worksheet.get_highest_column() + style_id_by_hash = style_table + cells_by_row = {} + for cell in worksheet.get_cell_collection(): + cells_by_row.setdefault(cell.row, []).append(cell) + for row_idx in sorted(cells_by_row): + row_dimension = worksheet.row_dimensions[row_idx] + attrs = {'r': '%d' % row_idx, + 'spans': '1:%d' % max_column} + if row_dimension.height > 0: + attrs['ht'] = str(row_dimension.height) + attrs['customHeight'] = '1' + start_tag(doc, 'row', attrs) + row_cells = cells_by_row[row_idx] + sorted_cells = sorted(row_cells, key = row_sort) + for cell in sorted_cells: + value = cell._value + coordinate = cell.get_coordinate() + attributes = {'r': coordinate} + attributes['t'] = cell.data_type + if coordinate in worksheet._styles: + attributes['s'] = '%d' % style_id_by_hash[ + hash(worksheet._styles[coordinate])] + start_tag(doc, 'c', attributes) + if value is None: + tag(doc, 'v', body='') + elif cell.data_type == cell.TYPE_STRING: + tag(doc, 'v', body = '%s' % string_table[value]) + elif cell.data_type == cell.TYPE_FORMULA: + tag(doc, 'f', body = '%s' % value[1:]) + tag(doc, 'v') + elif cell.data_type == cell.TYPE_NUMERIC: + tag(doc, 'v', body = '%s' % value) + else: + tag(doc, 'v', body = '%s' % value) + end_tag(doc, 'c') + end_tag(doc, 'row') + end_tag(doc, 'sheetData') + + +def write_worksheet_hyperlinks(doc, worksheet): + """Write worksheet hyperlinks to xml.""" + write_hyperlinks = False + for cell in worksheet.get_cell_collection(): + if cell.hyperlink_rel_id is not None: + write_hyperlinks = True + break + if write_hyperlinks: + start_tag(doc, 'hyperlinks') + for cell in worksheet.get_cell_collection(): + if cell.hyperlink_rel_id is not None: + attrs = {'display': cell.hyperlink, + 'ref': cell.get_coordinate(), + 'r:id': cell.hyperlink_rel_id} + tag(doc, 'hyperlink', attrs) + end_tag(doc, 'hyperlinks') + + +def write_worksheet_rels(worksheet, idx): + """Write relationships for the worksheet to xml.""" + root = Element('Relationships', {'xmlns': 'http://schemas.openxmlformats.org/package/2006/relationships'}) + for rel in worksheet.relationships: + attrs = {'Id': rel.id, 'Type': rel.type, 'Target': rel.target} + if rel.target_mode: + attrs['TargetMode'] = rel.target_mode + SubElement(root, 'Relationship', attrs) + if worksheet._charts: + attrs = {'Id' : 'rId1', + 'Type' : 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing', + 'Target' : '../drawings/drawing%s.xml' % idx } + SubElement(root, 'Relationship', attrs) + return get_document_content(root) From 5350355fbe0aefe053d40fda03c0688a7b7eae3d Mon Sep 17 00:00:00 2001 From: Mark Rogers Date: Thu, 12 May 2011 15:59:57 -0500 Subject: [PATCH 3/3] a bunch of cleanup from my previous commit --- AUTHORS | 3 ++- setup.py | 1 + tablib/core.py | 9 ++++++++ tablib/core25.py | 13 +++++++++++ tablib/formats/_xlsx.py | 51 ++++++++++++++++++----------------------- test_tablib.py | 2 ++ 6 files changed, 49 insertions(+), 30 deletions(-) diff --git a/AUTHORS b/AUTHORS index 1ca2018..facbd2e 100644 --- a/AUTHORS +++ b/AUTHORS @@ -14,4 +14,5 @@ Patches and Suggestions - Josh Ourisman - Luca Beltrame - Benjamin Wohlwend -- Erik Youngren \ No newline at end of file +- Erik Youngren +- Mark Rogers \ No newline at end of file diff --git a/setup.py b/setup.py index bb7ef54..850f915 100644 --- a/setup.py +++ b/setup.py @@ -33,6 +33,7 @@ setup( 'tablib', 'tablib.formats', 'tablib.packages', 'tablib.packages.xlwt', + 'tablib.packages.openpyxl', 'tablib.packages.yaml', 'tablib.packages.unicodecsv' ], diff --git a/tablib/core.py b/tablib/core.py index 71f4f71..348b88f 100644 --- a/tablib/core.py +++ b/tablib/core.py @@ -392,6 +392,15 @@ class Dataset(object): @property def xlsx(): + """An Excel Spreadsheet representation of the :class:`Dataset` object, with :ref:`separators`. Cannot be set. + + .. admonition:: Binary Warning + + :class:`Dataset.xlsx` contains binary data, so make sure to write in binary mode:: + + with open('output.xlsx', 'wb') as f: + f.write(data.xlsx)' + """ pass diff --git a/tablib/core25.py b/tablib/core25.py index c8352a6..a48fbb9 100644 --- a/tablib/core25.py +++ b/tablib/core25.py @@ -392,6 +392,19 @@ class Dataset(object): """ pass + @property + def xlsx(): + """An Excel Spreadsheet representation of the :class:`Dataset` object, with :ref:`separators`. Cannot be set. + + .. admonition:: Binary Warning + + :class:`Dataset.xlsx` contains binary data, so make sure to write in binary mode:: + + with open('output.xlsx', 'wb') as f: + f.write(data.xlsx)' + """ + pass + @property def csv(): diff --git a/tablib/formats/_xlsx.py b/tablib/formats/_xlsx.py index 92e33f9..1a0713b 100644 --- a/tablib/formats/_xlsx.py +++ b/tablib/formats/_xlsx.py @@ -7,30 +7,20 @@ import sys if sys.version_info[0] > 2: - from io import BytesIO - import tablib.packages.xlwt3 as xlwt - + from io import BytesIO else: from cStringIO import StringIO as BytesIO - import tablib.packages.xlwt as xlwt from tablib.packages.openpyxl.workbook import Workbook from tablib.packages.openpyxl.writer.excel import ExcelWriter from tablib.packages.openpyxl.cell import get_column_letter - - title = 'xlsx' extentions = ('xlsx',) -# special styles -#wrap = xlwt.easyxf("alignment: wrap on") -#bold = xlwt.easyxf("font: bold on") - - def export_set(dataset): - """Returns XLS representation of Dataset.""" + """Returns XLSX representation of Dataset.""" wb = Workbook() ws = wb.worksheets[0] @@ -44,19 +34,19 @@ def export_set(dataset): def export_book(databook): - """Returns XLS representation of DataBook.""" + """Returns XLSX representation of DataBook.""" wb = Workbook() ew = ExcelWriter(workbook = wb) for i, dset in enumerate(databook._datasets): - ws = wb.add_sheet() + ws = wb.create_sheet() ws.title = dset.title if dset.title else 'Sheet%s' % (i) dset_sheet(dset, ws) stream = BytesIO() - ew.save(filename='test.xlsx') + ew.save(stream) return stream.getvalue() @@ -75,30 +65,33 @@ def dset_sheet(dataset, ws): # bold headers if (row_number == 1) and dataset.headers: - ws.cell('%s%s'%(col_idx, row_number)).value = '%s' % col - #ws.write(i, j, col, bold) - - # frozen header row - #ws.panes_frozen = True - #ws.horz_split_pos = 1 + ws.cell('%s%s'%(col_idx, row_number)).value = unicode( + '%s' % col, errors='ignore') + style = ws.get_style('%s%s' % (col_idx, row_number)) + style.font.bold = True + ws.freeze_panes = '%s%s' % (col_idx, row_number) # bold separators elif len(row) < dataset.width: - ws.cell('%s%s'%(col_idx, row_number)).value = '%s' % col - #ws.write(i, j, col, bold) + ws.cell('%s%s'%(col_idx, row_number)).value = unicode( + '%s' % col, errors='ignore') + style = ws.get_style('%s%s' % (col_idx, row_number)) + style.font.bold = True # wrap the rest else: try: if '\n' in col: - ws.cell('%s%s'%(col_idx, row_number)).value = '%s' % col - #ws.write(i, j, col, wrap) + ws.cell('%s%s'%(col_idx, row_number)).value = unicode( + '%s' % col, errors='ignore') + style = ws.get_style('%s%s' % (col_idx, row_number)) + style.alignment.wrap_text else: - ws.cell('%s%s'%(col_idx, row_number)).value = '%s' % col - #ws.write(i, j, col) + ws.cell('%s%s'%(col_idx, row_number)).value = unicode( + '%s' % col, errors='ignore') except TypeError: - ws.cell('%s%s'%(col_idx, row_number)).value = '%s' % col - #ws.write(i, j, col) + ws.cell('%s%s'%(col_idx, row_number)).value = unicode( + '%s' % col, errors='ignore') diff --git a/test_tablib.py b/test_tablib.py index 7791935..4346859 100755 --- a/test_tablib.py +++ b/test_tablib.py @@ -222,6 +222,7 @@ class TablibTestCase(unittest.TestCase): data.csv data.tsv data.xls + data.xlsx def test_book_export_no_exceptions(self): @@ -233,6 +234,7 @@ class TablibTestCase(unittest.TestCase): book.json book.yaml book.xls + book.xlsx def test_json_import_set(self):