xlsxlite 1.1.0__py3-none-any.whl

xlsxlite/test/base.py

@@ -0,0 +1,58 @@
+import os
+import pytest
+import shutil
+import unittest
+from datetime import datetime, timedelta
+
+
+@pytest.fixture
+def tests_dir():
+    os.mkdir("_tests")
+    yield
+    shutil.rmtree("_tests")
+
+
+class XLSXTest(unittest.TestCase):
+    def assertExcelRow(self, sheet, row_num, values, tz=None):
+        """
+        Asserts the cell values in the given worksheet row. Date values are converted using the provided timezone.
+        """
+        expected_values = []
+        for expected in values:
+            # if expected value is datetime, localize and remove microseconds
+            if isinstance(expected, datetime):
+                expected = expected.astimezone(tz).replace(microsecond=0, tzinfo=None)
+
+            expected_values.append(expected)
+
+        rows = tuple(sheet.rows)
+
+        actual_values = []
+        for cell in rows[row_num]:
+            actual = cell.value
+
+            if actual is None:
+                actual = ""
+
+            if isinstance(actual, datetime):
+                actual = actual
+
+            actual_values.append(actual)
+
+        for index, expected in enumerate(expected_values):
+            actual = actual_values[index]
+
+            if isinstance(expected, datetime):
+                close_enough = abs(expected - actual) < timedelta(seconds=1)
+                assert close_enough, f"Datetime value {expected} doesn't match {actual}"
+            else:
+                assert expected == actual
+
+    def assertExcelSheet(self, sheet, rows, tz=None):
+        """
+        Asserts the row values in the given worksheet
+        """
+        assert len(list(sheet.rows)) == len(rows)
+
+        for r, row in enumerate(rows):
+            self.assertExcelRow(sheet, r, row, tz)

xlsxlite/test/test_perf.py

@@ -0,0 +1,76 @@
+import pytest
+import random
+import string
+import xlsxwriter
+
+from openpyxl import Workbook
+from openpyxl.cell.cell import WriteOnlyCell
+from openpyxl.cell._writer import etree_write_cell
+from unittest.mock import patch
+from xlsxlite.writer import XLSXBook
+from .base import tests_dir  # noqa
+
+
+NUM_ROWS = 1000
+NUM_COLS = 10
+
+# generate some random strings to use as cell values
+DATA = ["".join(random.choices(string.ascii_uppercase + string.digits, k=16)) for d in range(1000)]
+
+
+@pytest.mark.usefixtures("tests_dir")
+def test_xlxslite():
+    book = XLSXBook()
+    sheet1 = book.add_sheet("Sheet1")
+
+    for r in range(NUM_ROWS):
+        row = [DATA[(r * c) % len(DATA)] for c in range(NUM_COLS)]
+
+        sheet1.append_row(*row)
+
+    book.finalize(to_file="_tests/test.xlsx")
+
+
+@pytest.mark.usefixtures("tests_dir")
+@patch("openpyxl.cell._writer.write_cell")
+def test_openpyxl_etree(mock_write_cell):
+    mock_write_cell.side_effect = etree_write_cell
+
+    book = Workbook(write_only=True)
+    sheet1 = book.create_sheet("Sheet1")
+
+    for r in range(NUM_ROWS):
+        row = [DATA[(r * c) % len(DATA)] for c in range(NUM_COLS)]
+
+        cells = [WriteOnlyCell(sheet1, value=v) for v in row]
+        sheet1.append(cells)
+
+    book.save("_tests/test.xlsx")
+
+
+@pytest.mark.usefixtures("tests_dir")
+def test_openpyxl_lxml():
+    book = Workbook(write_only=True)
+    sheet1 = book.create_sheet("Sheet1")
+
+    for r in range(NUM_ROWS):
+        row = [DATA[(r * c) % len(DATA)] for c in range(NUM_COLS)]
+
+        cells = [WriteOnlyCell(sheet1, value=v) for v in row]
+        sheet1.append(cells)
+
+    book.save("_tests/test.xlsx")
+
+
+@pytest.mark.usefixtures("tests_dir")
+def test_xlsxwriter():
+    book = xlsxwriter.Workbook("_tests/test.xlsx")
+    sheet1 = book.add_worksheet()
+
+    for r in range(NUM_ROWS):
+        row = [DATA[(r * c) % len(DATA)] for c in range(NUM_COLS)]
+
+        for c, val in enumerate(row):
+            sheet1.write(r, c, val)
+
+    book.close()

xlsxlite/test/test_utils.py

@@ -0,0 +1,15 @@
+from datetime import datetime
+
+import pytest
+import pytz
+
+from xlsxlite.utils import datetime_to_serial
+
+
+def test_datetime_to_serial():
+    assert datetime_to_serial(datetime(2013, 1, 1, 12, 0, 0)) == 41275.5
+    assert datetime_to_serial(datetime(2018, 6, 15, 11, 24, 30, 0)) == 43266.47534722222
+
+    # try with a non-naive datetime
+    with pytest.raises(ValueError):
+        datetime_to_serial(datetime(2018, 6, 15, 11, 24, 30, 0, pytz.UTC))

xlsxlite/test/test_writer.py

@@ -0,0 +1,88 @@
+from datetime import datetime, timedelta
+
+import pytest
+from openpyxl.reader.excel import load_workbook
+from unittest.mock import patch
+from xlsxlite.writer import XLSXBook
+
+from .base import XLSXTest, tests_dir  # noqa
+
+
+@pytest.mark.usefixtures("tests_dir")
+class BookTest(XLSXTest):
+    def test_empty(self):
+        book = XLSXBook()
+        book.finalize(to_file="_tests/empty.xlsx")
+
+        book = load_workbook(filename="_tests/empty.xlsx")
+        assert len(book.worksheets) == 1
+        assert book.worksheets[0].title == "Sheet1"
+
+    def test_simple(self):
+        book = XLSXBook()
+        sheet1 = book.add_sheet("People")
+        sheet1.append_row("Name", "Email")
+        sheet1.append_row("Jim", "jim@acme.com")
+        sheet1.append_row("Bob", "bob@acme.com")
+
+        book.add_sheet("Empty")
+
+        # insert a new sheet at a specific index
+        book.add_sheet("New first", index=0)
+
+        book.finalize(to_file="_tests/simple.xlsx")
+
+        book = load_workbook(filename="_tests/simple.xlsx")
+        assert len(book.worksheets) == 3
+
+        sheet1, sheet2, sheet3 = book.worksheets
+        assert sheet1.title == "New first"
+        assert sheet2.title == "People"
+        assert sheet3.title == "Empty"
+
+        self.assertExcelSheet(sheet1, [])
+        self.assertExcelSheet(sheet2, [("Name", "Email"), ("Jim", "jim@acme.com"), ("Bob", "bob@acme.com")])
+        self.assertExcelSheet(sheet3, [])
+
+    def test_cell_types(self):
+        d1 = datetime(2013, 1, 1, 12, 0, 0)
+
+        book = XLSXBook()
+        sheet1 = book.add_sheet("Test")
+        sheet1.append_row("str", True, False, 3, 1.23, d1)
+
+        # try to write a cell value with an unsupported type
+        with pytest.raises(ValueError):
+            sheet1.append_row(timedelta(days=1))
+
+        book.finalize(to_file="_tests/types.xlsx")
+
+        book = load_workbook(filename="_tests/types.xlsx")
+        self.assertExcelSheet(book.worksheets[0], [("str", True, False, 3, 1.23, d1)])
+
+    def test_escaping(self):
+        book = XLSXBook()
+        sheet1 = book.add_sheet("Test")
+        sheet1.append_row('< & > " ! =')
+        book.finalize(to_file="_tests/escaped.xlsx")
+
+        book = load_workbook(filename="_tests/escaped.xlsx")
+        self.assertExcelSheet(book.worksheets[0], [('< & > " ! =',)])
+
+    def test_sheet_limits(self):
+        book = XLSXBook()
+        sheet1 = book.add_sheet("Sheet1")
+
+        # try to add row with too many columns
+        column = ["x"] * 20000
+        with pytest.raises(ValueError):
+            sheet1.append_row(*column)
+
+        # try to add more rows than allowed
+        with patch("xlsxlite.writer.XLSXSheet.MAX_ROWS", 3):
+            sheet1.append_row("x")
+            sheet1.append_row("x")
+            sheet1.append_row("x")
+
+            with pytest.raises(ValueError):
+                sheet1.append_row("x")

xlsxlite/utils.py

@@ -0,0 +1,14 @@
+from datetime import datetime
+
+
+def datetime_to_serial(dt):
+    """
+    Converts the given datetime to the Excel serial format
+    """
+    if dt.tzinfo:
+        raise ValueError("Doesn't support datetimes with timezones")
+
+    temp = datetime(1899, 12, 30)
+    delta = dt - temp
+
+    return delta.days + (float(delta.seconds) + float(delta.microseconds) / 1E6) / (60 * 60 * 24)

xlsxlite/writer.py

@@ -0,0 +1,278 @@
+import os
+import shutil
+import tempfile
+import xml.etree.ElementTree as ET
+import zipfile
+from datetime import datetime
+from xml.sax.saxutils import escape
+
+from .utils import datetime_to_serial
+
+XML_HEADER = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n"""
+
+WORKBOOK_HEADER = """<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">"""
+WORKSHEET_HEADER = """<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">"""
+
+MINIMAL_STYLESHEET = """<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+    <numFmts count="1">
+        <numFmt formatCode="yyyy-mm-dd h:mm:ss" numFmtId="164"/>
+    </numFmts>
+    <fonts count="1">
+        <font>
+            <name val="Calibri"/>
+            <family val="2"/>
+            <color theme="1"/>
+            <sz val="11"/>
+            <scheme val="minor"/>
+        </font>
+    </fonts>
+    <fills count="2">
+        <fill><patternFill/></fill>
+        <fill><patternFill patternType="gray125"/></fill>
+    </fills>
+    <borders count="1">
+        <border>
+            <left/>
+            <right/>
+            <top/>
+            <bottom/>
+            <diagonal/>
+        </border>
+    </borders>
+    <cellStyleXfs count="1">
+        <xf borderId="0" fillId="0" fontId="0" numFmtId="0"/>
+    </cellStyleXfs>
+    <cellXfs count="2">
+        <xf borderId="0" fillId="0" fontId="0" numFmtId="0" pivotButton="0" quotePrefix="0" xfId="0"/>
+        <xf borderId="0" fillId="0" fontId="0" numFmtId="164" pivotButton="0" quotePrefix="0" xfId="0"/>
+    </cellXfs>
+    <cellStyles count="1">
+        <cellStyle builtinId="0" hidden="0" name="Normal" xfId="0"/>
+    </cellStyles>
+</styleSheet>"""
+
+# use a nice big 1MB I/O buffer for the worksheet files
+WORKSHEET_IO_BUFFER = 1048576
+
+
+class XLSXSheet:
+    """
+    A worksheet within a XLSX workbook
+    """
+
+    MAX_ROWS = 1048576
+    MAX_COLS = 16384
+
+    def __init__(self, _id, name, path):
+        self.id = _id
+        self.name = name
+        self.path = path
+        self.relationshipId = f"rId{_id}"
+
+        self.num_rows = 0
+
+        self.file = open(path, "w", encoding="utf-8", buffering=WORKSHEET_IO_BUFFER)
+        self.file.write(XML_HEADER)
+        self.file.write(WORKSHEET_HEADER)
+        self.file.write("<sheetData>")
+
+    def append_row(self, *columns):
+        """
+        Appends a new row to this sheet
+        """
+        if len(columns) > self.MAX_COLS:
+            raise ValueError(f"rows can have a maximum of {self.MAX_COLS} columns")
+
+        if self.num_rows >= self.MAX_ROWS:
+            raise ValueError(f"sheet already has the maximum of {self.MAX_ROWS} rows")
+
+        row = "<row>"
+        for val in columns:
+            if isinstance(val, str):
+                row += f'<c t="inlineStr"><is><t>{escape(val)}</t></is></c>'
+            elif isinstance(val, bool):
+                row += f'<c t="b"><v>{int(val)}</v></c>'
+            elif isinstance(val, (int, float)):
+                row += f'<c t="n"><v>{str(val)}</v></c>'
+            elif isinstance(val, datetime):
+                row += f'<c t="n" s="1"><v>{datetime_to_serial(val)}</v></c>'
+            else:
+                raise ValueError(f"Unsupported type in column data: {type(val)}")
+
+        row += "</row>"
+
+        self.file.write(row)
+        self.num_rows += 1
+
+    def finalize(self):
+        """
+        Finalizes this sheet so that its XML file is valid
+        """
+        self.file.write("</sheetData></worksheet>")
+        self.file.close()
+
+
+class XLSXBook:
+    """
+    An XLSX workbook
+    """
+
+    def __init__(self):
+        self.base_dir = tempfile.mkdtemp()
+        self.app_dir = os.path.join(self.base_dir, "xl")
+        self.sheets = []
+
+        os.mkdir(self.app_dir)
+        os.mkdir(os.path.join(self.app_dir, "worksheets"))
+
+    def add_sheet(self, name, index=-1):
+        """
+        Adds a new worksheet to this workbook with the given name
+        """
+        _id = str(len(self.sheets) + 1)
+        path = os.path.join(self.app_dir, f"worksheets/sheet{_id}.xml")
+        sheet = XLSXSheet(_id, name, path)
+
+        if index < 0:
+            index = len(self.sheets)
+
+        self.sheets.insert(index, sheet)
+        return sheet
+
+    def _create_content_types(self):
+        types = ET.Element("Types", {"xmlns": "http://schemas.openxmlformats.org/package/2006/content-types"})
+        ET.SubElement(
+            types,
+            "Default",
+            {"Extension": "rels", "ContentType": "application/vnd.openxmlformats-package.relationships+xml"},
+        )
+        ET.SubElement(types, "Default", {"Extension": "xml", "ContentType": "application/xml"})
+        ET.SubElement(
+            types,
+            "Override",
+            {
+                "PartName": "/xl/styles.xml",
+                "ContentType": "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml",
+            },
+        )
+        ET.SubElement(
+            types,
+            "Override",
+            {
+                "PartName": "/xl/workbook.xml",
+                "ContentType": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
+            },
+        )
+
+        for sheet in self.sheets:
+            rel_path = sheet.path[len(self.base_dir) :]
+            ET.SubElement(
+                types,
+                "Override",
+                {
+                    "PartName": rel_path,
+                    "ContentType": "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml",
+                },
+            )
+
+        with open(os.path.join(self.base_dir, "[Content_Types].xml"), "w", encoding="utf-8") as f:
+            f.write(XML_HEADER)
+            f.write(ET.tostring(types, encoding="unicode"))
+
+    def _create_root_rels(self):
+        os.mkdir(os.path.join(self.base_dir, "_rels"))
+
+        relationships = ET.Element(
+            "Relationships", {"xmlns": "http://schemas.openxmlformats.org/package/2006/relationships"}
+        )
+        ET.SubElement(
+            relationships,
+            "Relationship",
+            {
+                "Id": "rId1",
+                "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+                "Target": "xl/workbook.xml",
+            },
+        )
+
+        with open(os.path.join(self.base_dir, "_rels/.rels"), "w", encoding="utf-8") as f:
+            f.write(XML_HEADER)
+            f.write(ET.tostring(relationships, encoding="unicode"))
+
+    def _create_app_rels(self):
+        os.mkdir(os.path.join(self.app_dir, "_rels"))
+
+        relationships = ET.Element(
+            "Relationships", {"xmlns": "http://schemas.openxmlformats.org/package/2006/relationships"}
+        )
+        for sheet in self.sheets:
+            rel_path = os.path.relpath(sheet.path, start=self.app_dir)
+
+            ET.SubElement(
+                relationships,
+                "Relationship",
+                {
+                    "Id": sheet.relationshipId,
+                    "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet",
+                    "Target": rel_path,
+                },
+            )
+
+        ET.SubElement(
+            relationships,
+            "Relationship",
+            {
+                "Id": "rIdStyles",
+                "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
+                "Target": "styles.xml",
+            },
+        )
+
+        with open(os.path.join(self.app_dir, "_rels/workbook.xml.rels"), "w", encoding="utf-8") as f:
+            f.write(XML_HEADER)
+            f.write(ET.tostring(relationships, encoding="unicode"))
+
+    def _create_styles(self):
+        with open(os.path.join(self.app_dir, "styles.xml"), "w", encoding="utf-8") as f:
+            f.write(XML_HEADER)
+            f.write(MINIMAL_STYLESHEET)
+
+    def _create_workbook(self):
+        sheets = ET.Element("sheets")
+        for sheet in self.sheets:
+            ET.SubElement(sheets, "sheet", {"name": sheet.name, "sheetId": sheet.id, "r:id": sheet.relationshipId})
+
+        with open(os.path.join(self.base_dir, "xl/workbook.xml"), "w", encoding="utf-8") as f:
+            f.write(XML_HEADER)
+            f.write(WORKBOOK_HEADER)
+            f.write(ET.tostring(sheets, encoding="unicode"))
+            f.write("</workbook>")
+
+    def _archive_dir(self, to_file):
+        archive = zipfile.ZipFile(to_file, "w", zipfile.ZIP_DEFLATED)
+
+        for root, dirs, files in os.walk(self.base_dir):
+            for file in files:
+                rel_path = os.path.relpath(os.path.join(root, file), start=self.base_dir)
+                archive.write(os.path.join(root, file), arcname=rel_path)
+
+        archive.close()
+
+    def finalize(self, to_file, remove_dir=True):
+        # must have at least one sheet
+        if not self.sheets:
+            self.add_sheet("Sheet1")
+
+        self._create_content_types()
+        self._create_root_rels()
+        self._create_app_rels()
+        self._create_styles()
+        self._create_workbook()
+
+        for sheet in self.sheets:
+            sheet.finalize()
+
+        self._archive_dir(to_file)
+
+        if remove_dir:
+            shutil.rmtree(self.base_dir)

xlsxlite-1.1.0.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: xlsxlite
+Version: 1.1.0
+Summary: Lightweight XLSX writer with emphasis on minimizing memory usage.
+Project-URL: repository, http://github.com/nyaruka/xlsxlite
+Author-email: TextIt <code@textit.com>
+License: MIT
+License-File: LICENSE
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# XLSXLite
+
+[![Build Status](https://github.com/nyaruka/xlsxlite/workflows/CI/badge.svg)](https://github.com/nyaruka/xlsxlite/actions?query=workflow%3ACI)
+[![Coverage Status](https://codecov.io/gh/nyaruka/xlsxlite/branch/main/graph/badge.svg)](https://codecov.io/gh/nyaruka/xlsxlite)
+[![PyPI Release](https://img.shields.io/pypi/v/xlsxlite.svg)](https://pypi.python.org/pypi/xlsxlite/)
+
+This is a lightweight XLSX writer with emphasis on minimizing memory usage. It's also really fast.
+
+```python
+from xlsxlite.writer import XLSXBook
+book = XLSXBook()
+sheet1 = book.add_sheet("People")
+sheet1.append_row("Name", "Email", "Age")
+sheet1.append_row("Jim", "jim@acme.com", 45)
+book.finalize(to_file="simple.xlsx")
+```
+
+## Benchmarks
+
+The [benchmarking test](https://github.com/nyaruka/xlsxlite/blob/main/xlsxlite/test/test_perf.py) writes
+rows with 10 cells of random string data to a single sheet workbook. The table below gives the times in seconds (lower is better)
+to write a spreadsheet with the given number of rows, and includes [xlxswriter](https://xlsxwriter.readthedocs.io/) and
+[openpyxl](https://openpyxl.readthedocs.io/) for comparison.
+
+Implementation  | 100,000 rows | 1,000,000 rows
+----------------|--------------|---------------
+openpyxl        | 43.5         | 469.1
+openpyxl + lxml | 21.1         | 226.3
+xlsxwriter      | 17.2         | 186.2
+xlsxlite        | 1.9          | 19.2
+
+## Limitations
+
+This library is for projects which need to generate large spreadsheets, quickly, for the purposes of data exchange, and
+so it intentionally only supports a tiny subset of SpreadsheetML specification:
+
+ * No styling or themes
+ * Only strings, numbers, booleans and dates are supported cell types
+
+If you need to do anything fancier then take a look at [xlxswriter](https://xlsxwriter.readthedocs.io/) and
+[openpyxl](https://openpyxl.readthedocs.io/).
+
+## Development
+
+To run all tests:
+
+```
+uv run pytest xlsxlite -s
+```

xlsxlite-1.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+xlsxlite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xlsxlite/utils.py,sha256=5S36PdU-FnCQ3lY9BkCE4whMMxonYrRweuEflxHacC0,378
+xlsxlite/writer.py,sha256=1TjFfBBH-DB3TknNWwVmGdWfUGChIleIEF3UNKBwHik,9345
+xlsxlite/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xlsxlite/test/base.py,sha256=eLVJSX2Y6hdSMhV6HTOe8rGXa6QGzQ-FKUOkNRkk9F4,1708
+xlsxlite/test/test_perf.py,sha256=T7n7CYzISpictXCj5euSA7A1RnuZu60F2-j6wQ71yq0,1965
+xlsxlite/test/test_utils.py,sha256=0dTObD-BXcfOM8-eUjFDayQBLXgplg8jo6237dvu6Xs,447
+xlsxlite/test/test_writer.py,sha256=L4SWbnNkarIL4dV3Prs7VgN3u983E5htaNIh7ZXv46Q,2857
+xlsxlite-1.1.0.dist-info/METADATA,sha256=3s4Apo56b4rHD7U_0-cFFEXzDHWoBOD_S61X8NikSkE,2446
+xlsxlite-1.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+xlsxlite-1.1.0.dist-info/licenses/LICENSE,sha256=noCRz7EAyVA_li4teSPmicKInOy2mgCDR6u4ftxfVgo,1078
+xlsxlite-1.1.0.dist-info/RECORD,,

xlsxlite-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

xlsxlite-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020-2022 TextIt
+
+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.