agate-excel 0.4.2__py3-none-any.whl

agate_excel-0.4.2.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: agate-excel
+Version: 0.4.2
+Summary: agate-excel adds read support for Excel files (xls and xlsx) to agate.
+Home-page: https://agate-excel.readthedocs.org/
+Author: Christopher Groskopf
+Author-email: chrisgroskopf@gmail.com
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/x-rst
+License-File: COPYING
+License-File: AUTHORS.rst
+Requires-Dist: agate>=1.5.0
+Requires-Dist: olefile
+Requires-Dist: openpyxl>=2.3.0
+Requires-Dist: xlrd>=0.9.4
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+.. image:: https://github.com/wireservice/agate-excel/workflows/CI/badge.svg
+    :target: https://github.com/wireservice/agate-excel/actions
+    :alt: Build status
+
+.. image:: https://coveralls.io/repos/wireservice/agate-excel/badge.svg?branch=master
+    :target: https://coveralls.io/r/wireservice/agate-excel
+    :alt: Coverage status
+
+.. image:: https://img.shields.io/pypi/dm/agate-excel.svg
+    :target: https://pypi.python.org/pypi/agate-excel
+    :alt: PyPI downloads
+
+.. image:: https://img.shields.io/pypi/v/agate-excel.svg
+    :target: https://pypi.python.org/pypi/agate-excel
+    :alt: Version
+
+.. image:: https://img.shields.io/pypi/l/agate-excel.svg
+    :target: https://pypi.python.org/pypi/agate-excel
+    :alt: License
+
+.. image:: https://img.shields.io/pypi/pyversions/agate-excel.svg
+    :target: https://pypi.python.org/pypi/agate-excel
+    :alt: Support Python versions
+
+agate-excel adds read support for Excel files (xls and xlsx) to `agate <https://github.com/wireservice/agate>`_.
+
+Important links:
+
+* agate             https://agate.rtfd.org
+* Documentation:    https://agate-excel.rtfd.org
+* Repository:       https://github.com/wireservice/agate-excel
+* Issues:           https://github.com/wireservice/agate-excel/issues

agate_excel-0.4.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+agate_excel-0.4.2.dist-info/licenses/AUTHORS.rst,sha256=LxslP-WPSc4X-1SVMay7LpF1aV-1gMKkQhw7nQRcPR4,472
+agate_excel-0.4.2.dist-info/licenses/COPYING,sha256=bndZjP9C4DkH4eexbIqZb8tRUKF8VuzSsAyqpFWJ-pw,1099
+agateexcel/__init__.py,sha256=OLWNy-2mBZTFhB9kq-vszTIX5mhh9OrgktUmLqVhG60,57
+agateexcel/table_xls.py,sha256=txVc33fjx7kXqORmTWWZkS4bVBM7axt2zjbzzrWTerI,6394
+agateexcel/table_xlsx.py,sha256=PMTn5JnOHgZw3wTgPRCDvYXdtgmfiTn5ViJKcN9VzFg,4624
+agate_excel-0.4.2.dist-info/METADATA,sha256=ev200UMQTPqpSKN_RjXe1Yalk9Sp64rOLL6CjRufgq8,2899
+agate_excel-0.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+agate_excel-0.4.2.dist-info/top_level.txt,sha256=gDSv0yVz_5r9fBxWddsHzVojk1O11SfaayzkgOuFy_s,11
+agate_excel-0.4.2.dist-info/RECORD,,

agate_excel-0.4.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agate_excel-0.4.2.dist-info/licenses/AUTHORS.rst

@@ -0,0 +1,10 @@
+The following individuals have contributed code to agate-excel:
+
+* `Christopher Groskopf <https://github.com/onyxfish>`_
+* `Ben Welsh <https://github.com/palewire>`_
+* `James McKinney <https://github.com/jpmckinney>`_
+* `Peter M. Landwehr <https://github.com/pmlandwehr>`_
+* `Jani Mikkonen <https://github.com/rasjani>`_
+* `Tim Freund <https://github.com/timfreund>`_
+* `Loïc Corbasson <https://github.com/lcorbasson>`_
+* `Robert Schütz <https://github.com/dotlambda>`_

agate_excel-0.4.2.dist-info/licenses/COPYING

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2017 Christopher Groskopf and contributors 
+
+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.

agate_excel-0.4.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+agateexcel

agateexcel/__init__.py

@@ -0,0 +1,2 @@
+import agateexcel.table_xls
+import agateexcel.table_xlsx

agateexcel/table_xls.py

@@ -0,0 +1,208 @@
+"""
+This module contains the XLS extension to :class:`Table <agate.table.Table>`.
+"""
+
+import datetime
+from collections import OrderedDict
+
+import agate
+import olefile
+import xlrd
+
+EXCEL_TO_AGATE_TYPE = {
+    xlrd.biffh.XL_CELL_EMPTY: agate.Boolean(),
+    xlrd.biffh.XL_CELL_TEXT: agate.Text(),
+    xlrd.biffh.XL_CELL_NUMBER: agate.Number(),
+    xlrd.biffh.XL_CELL_DATE: agate.DateTime(),
+    xlrd.biffh.XL_CELL_BOOLEAN: agate.Boolean(),
+    xlrd.biffh.XL_CELL_ERROR: agate.Text(),
+    xlrd.biffh.XL_CELL_BLANK: agate.Boolean(),
+}
+
+
+def from_xls(cls, path, sheet=None, skip_lines=0, header=True, encoding_override=None, row_limit=None, **kwargs):
+    """
+    Parse an XLS file.
+
+    :param path:
+        Path to an XLS file to load or a file-like object for one.
+    :param sheet:
+        The names or integer indices of the worksheets to load. If not specified
+        then the first sheet will be used.
+    :param skip_lines:
+        The number of rows to skip from the top of the sheet.
+    :param header:
+        If :code:`True`, the first row is assumed to contain column names.
+    :param row_limit:
+        Limit how many rows of data will be read.
+    """
+    if not isinstance(skip_lines, int):
+        raise ValueError('skip_lines argument must be an int')
+
+    def open_workbook(f):
+        try:
+            book = xlrd.open_workbook(file_contents=f.read(), encoding_override=encoding_override, on_demand=True)
+        except xlrd.compdoc.CompDocError:
+            # This is not a pure XLS file; we'll try to read it though.
+            # Let's try the Compound File Binary Format:
+            ole = olefile.OleFileIO(f)
+            if ole.exists('Workbook'):
+                d = ole.openstream('Workbook')
+                book = xlrd.open_workbook(file_contents=d.read(), on_demand=True)
+            else:
+                raise OSError('No Workbook stream found in OLE file')
+        return book
+
+    if hasattr(path, 'read'):
+        book = open_workbook(path)
+    else:
+        with open(path, 'rb') as f:
+            book = open_workbook(f)
+
+    try:
+        multiple = agate.utils.issequence(sheet)
+        if multiple:
+            sheets = sheet
+        else:
+            sheets = [sheet]
+
+        tables = OrderedDict()
+
+        for i, sheet in enumerate(sheets):
+            if isinstance(sheet, str):
+                sheet = book.sheet_by_name(sheet)
+            elif isinstance(sheet, int):
+                sheet = book.sheet_by_index(sheet)
+            else:
+                sheet = book.sheet_by_index(0)
+
+            if header:
+                offset = 1
+                column_names = []
+            else:
+                offset = 0
+                column_names = None
+
+            columns = []
+            column_types = []
+
+            for i in range(sheet.ncols):
+                if row_limit is None:
+                    values = sheet.col_values(i, skip_lines + offset)
+                    types = sheet.col_types(i, skip_lines + offset)
+                else:
+                    values = sheet.col_values(i, skip_lines + offset, skip_lines + offset + row_limit)
+                    types = sheet.col_types(i, skip_lines + offset, skip_lines + offset + row_limit)
+                excel_type = determine_excel_type(types)
+                agate_type = determine_agate_type(excel_type)
+
+                if excel_type == xlrd.biffh.XL_CELL_BOOLEAN:
+                    values = normalize_booleans(values)
+                elif excel_type == xlrd.biffh.XL_CELL_DATE:
+                    values, with_date, with_time = normalize_dates(values, book.datemode)
+                    if not with_date:
+                        agate_type = agate.TimeDelta()
+                    if not with_time:
+                        agate_type = agate.Date()
+
+                if header:
+                    name = str(sheet.cell_value(skip_lines, i)) or None
+                    column_names.append(name)
+
+                columns.append(values)
+                column_types.append(agate_type)
+
+            rows = []
+
+            if columns:
+                for i in range(len(columns[0])):
+                    rows.append([c[i] for c in columns])
+
+            if 'column_names' in kwargs:
+                if not header:
+                    column_names = kwargs['column_names']
+                del kwargs['column_names']
+
+            if 'column_types' in kwargs:
+                column_types = kwargs['column_types']
+                del kwargs['column_types']
+
+            tables[sheet.name] = agate.Table(rows, column_names, column_types, **kwargs)
+
+    finally:
+        book.release_resources()
+
+    if multiple:
+        return agate.MappedSequence(tables.values(), tables.keys())
+    return tables.popitem()[1]
+
+
+def determine_agate_type(excel_type):
+    try:
+        return EXCEL_TO_AGATE_TYPE[excel_type]
+    except KeyError:
+        return agate.Text()
+
+
+def determine_excel_type(types):
+    """
+    Determine the correct type for a column from a list of cell types.
+    """
+    types_set = set(types)
+    types_set.discard(xlrd.biffh.XL_CELL_EMPTY)
+
+    # Normalize mixed types to text
+    if len(types_set) > 1:
+        return xlrd.biffh.XL_CELL_TEXT
+
+    try:
+        return types_set.pop()
+    except KeyError:
+        return xlrd.biffh.XL_CELL_EMPTY
+
+
+def normalize_booleans(values):
+    normalized = []
+
+    for value in values:
+        if value is None or value == '':
+            normalized.append(None)
+        else:
+            normalized.append(bool(value))
+
+    return normalized
+
+
+def normalize_dates(values, datemode=0):
+    """
+    Normalize a column of date cells.
+    """
+    normalized = []
+    with_date = False
+    with_time = False
+
+    for v in values:
+        if not v:
+            normalized.append(None)
+            continue
+
+        v_tuple = xlrd.xldate.xldate_as_datetime(v, datemode).timetuple()
+
+        if v_tuple[3:6] == (0, 0, 0):
+            # Date only
+            normalized.append(datetime.date(*v_tuple[:3]))
+            with_date = True
+        elif v_tuple[:3] == (0, 0, 0):
+            # Time only
+            normalized.append(datetime.time(*v_tuple[3:6]))
+            with_time = True
+        else:
+            # Date and time
+            normalized.append(datetime.datetime(*v_tuple[:6]))
+            with_date = True
+            with_time = True
+
+    return (normalized, with_date, with_time)
+
+
+agate.Table.from_xls = classmethod(from_xls)

agateexcel/table_xlsx.py

@@ -0,0 +1,154 @@
+"""
+This module contains the XLSX extension to :class:`Table <agate.table.Table>`.
+"""
+
+import datetime
+from collections import OrderedDict
+
+import agate
+import openpyxl
+
+NULL_TIME = datetime.time(0, 0, 0)
+
+
+def from_xlsx(cls, path, sheet=None, skip_lines=0, header=True, read_only=True,
+              reset_dimensions=None, row_limit=None, **kwargs):
+    """
+    Parse an XLSX file.
+
+    :param path:
+        Path to an XLSX file to load or a file-like object for one.
+    :param sheet:
+        The names or integer indices of the worksheets to load. If not specified
+        then the "active" sheet will be used.
+    :param skip_lines:
+        The number of rows to skip from the top of the sheet.
+    :param header:
+        If :code:`True`, the first row is assumed to contain column names.
+    :param read_only:
+        If :code:`True`, the XLSX file is opened in read-only mode, to reduce
+        memory consumption.
+    :param reset_dimensions:
+        If :code:`True`, do not trust the dimensions in the file's properties,
+        and recalculate them based on the data in the file.
+    :param row_limit:
+        Limit how many rows of data will be read.
+    """
+    if not isinstance(skip_lines, int):
+        raise ValueError('skip_lines argument must be an int')
+
+    if hasattr(path, 'read'):
+        f = path
+    else:
+        f = open(path, 'rb')
+
+    book = openpyxl.load_workbook(f, read_only=read_only, data_only=True)
+
+    multiple = agate.utils.issequence(sheet)
+    if multiple:
+        sheets = sheet
+    else:
+        sheets = [sheet]
+
+    tables = OrderedDict()
+
+    for i, sheet in enumerate(sheets):
+        if isinstance(sheet, str):
+            try:
+                sheet = book[sheet]
+            except KeyError:
+                f.close()
+                raise
+        elif isinstance(sheet, int):
+            try:
+                sheet = book.worksheets[sheet]
+            except IndexError:
+                f.close()
+                raise
+        else:
+            sheet = book.active
+
+        column_names = None
+        offset = 0
+        rows = []
+
+        if (
+            read_only
+            and (reset_dimensions or (reset_dimensions is None and sheet.max_column == 1 and sheet.max_row == 1))
+        ):
+            try:
+                sheet.reset_dimensions()
+                sheet.calculate_dimension(force=True)
+            # https://foss.heptapod.net/openpyxl/openpyxl/-/issues/2111
+            except UnboundLocalError:
+                pass
+
+        if header:
+            sheet_header = sheet.iter_rows(min_row=1 + skip_lines, max_row=1 + skip_lines)
+            column_names = [None if c.value is None else str(c.value) for row in sheet_header for c in row]
+            offset = 1
+
+        if row_limit is None:
+            sheet_rows = sheet.iter_rows(min_row=1 + skip_lines + offset)
+        else:
+            sheet_rows = sheet.iter_rows(min_row=1 + skip_lines + offset, max_row=1 + skip_lines + offset + row_limit)
+
+        for i, row in enumerate(sheet_rows):
+            values = []
+
+            for c in row:
+                value = c.value
+
+                if value.__class__ is datetime.datetime:
+                    # Handle default XLSX date as 00:00 time
+                    if value.date() == datetime.date(1904, 1, 1) and not has_date_elements(c):
+                        value = value.time()
+
+                        value = normalize_datetime(value)
+                    elif value.time() == NULL_TIME:
+                        value = value.date()
+                    else:
+                        value = normalize_datetime(value)
+
+                values.append(value)
+
+            rows.append(values)
+
+        if 'column_names' in kwargs:
+            if not header:
+                column_names = kwargs['column_names']
+            del kwargs['column_names']
+
+        tables[sheet.title] = agate.Table(rows, column_names, **kwargs)
+
+    f.close()
+
+    if multiple:
+        return agate.MappedSequence(tables.values(), tables.keys())
+    return tables.popitem()[1]
+
+
+def normalize_datetime(dt):
+    if dt.microsecond == 0:
+        return dt
+
+    ms = dt.microsecond
+
+    if ms < 1000:
+        return dt.replace(microsecond=0)
+    if ms > 999000:
+        return dt.replace(microsecond=0) + datetime.timedelta(seconds=1)
+
+    return dt
+
+
+def has_date_elements(cell):
+    """
+    Try to use formatting to determine if a cell contains only time info.
+
+    See: http://office.microsoft.com/en-us/excel-help/number-format-codes-HP005198679.aspx
+    """
+    return 'd' in cell.number_format or 'y' in cell.number_format
+
+
+agate.Table.from_xlsx = classmethod(from_xlsx)