Expose 'read_only' parameter for 'import_set' and 'import_book' (#483)

* Upload coverage from GHA

* Fix PytestConfigWarning: Unknown config option: python_paths

.coveragerc

@@ -0,0 +1,10 @@
+# .coveragerc to control coverage.py
+
+[report]
+# Regexes for lines to exclude from consideration
+exclude_lines =
+    # Have to re-enable the standard pragma:
+    pragma: no cover
+
+    # Don't complain if non-runnable code isn't run:
+    if __name__ == .__main__.:

.github/CONTRIBUTING.md

@@ -0,0 +1,10 @@
+[![Jazzband](https://jazzband.co/static/img/jazzband.svg)](https://jazzband.co/)
+
+This is a [Jazzband](https://jazzband.co/) project. By contributing you agree to abide
+by the [Contributor Code of Conduct](https://jazzband.co/about/conduct) and follow the
+[guidelines](https://jazzband.co/about/guidelines).
+
+If you'd like to contribute, simply fork 
+[the repository](https://github.com/jazzband/tablib), commit your changes to a feature
+branch, and send a pull request to `master`. Make sure you add yourself to
+[AUTHORS](https://github.com/jazzband/tablib/blob/master/AUTHORS).

.github/workflows/docs-lint.yml

@@ -0,0 +1,46 @@
+name: Docs and lint
+
+on: [push, pull_request]
+
+env:
+  FORCE_COLOR: 1
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        env:
+        - TOXENV: docs
+        - TOXENV: lint
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.9
+
+      - name: Get pip cache dir
+        id: pip-cache
+        run: |
+          echo "::set-output name=dir::$(pip cache dir)"
+
+      - name: Cache
+        uses: actions/cache@v2
+        with:
+          path: ${{ steps.pip-cache.outputs.dir }}
+          key:
+            ${{ matrix.os }}-${{ matrix.python-version }}-v1-${{ hashFiles('**/setup.py') }}
+          restore-keys: |
+            ${{ matrix.os }}-${{ matrix.python-version }}-v1-
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install --upgrade tox
+
+      - name: Tox
+        run: tox
+        env: ${{ matrix.env }}

.github/workflows/release.yml

@@ -0,0 +1,56 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - master
+  release:
+    types:
+      - published
+
+jobs:
+  build:
+    if: github.repository == 'jazzband/tablib'
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+
+      - name: Get pip cache dir
+        id: pip-cache
+        run: |
+          echo "::set-output name=dir::$(pip cache dir)"
+
+      - name: Cache
+        uses: actions/cache@v2
+        with:
+          path: ${{ steps.pip-cache.outputs.dir }}
+          key: release-${{ hashFiles('**/setup.py') }}
+          restore-keys: |
+            release-
+
+      - name: Install dependencies
+        run: |
+          python -m pip install -U pip
+          python -m pip install -U setuptools twine wheel
+
+      - name: Build package
+        run: |
+          python setup.py --version
+          python setup.py sdist --format=gztar bdist_wheel
+          twine check dist/*
+
+      - name: Upload packages to Jazzband
+        if: github.event.action == 'published'
+        uses: pypa/gh-action-pypi-publish@master
+        with:
+          user: jazzband
+          password: ${{ secrets.JAZZBAND_RELEASE_KEY }}
+          repository_url: https://jazzband.co/projects/tablib/upload

.github/workflows/test.yml

@@ -0,0 +1,53 @@
+name: Test
+
+on: [push, pull_request]
+
+env:
+  FORCE_COLOR: 1
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: [3.6, 3.7, 3.8, 3.9]
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Get pip cache dir
+      id: pip-cache
+      run: |
+        echo "::set-output name=dir::$(pip cache dir)"
+
+    - name: Cache
+      uses: actions/cache@v2
+      with:
+        path: ${{ steps.pip-cache.outputs.dir }}
+        key:
+          ${{ matrix.os }}-${{ matrix.python-version }}-v1-${{ hashFiles('**/setup.py') }}
+        restore-keys: |
+          ${{ matrix.os }}-${{ matrix.python-version }}-v1-
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install --upgrade tox
+        python -m pip install  -e .
+
+    - name: Tox tests
+      shell: bash
+      run: |
+        tox -e py
+
+    - name: Upload coverage
+      uses: codecov/codecov-action@v1
+      with:
+        name: ${{ matrix.os }} Python ${{ matrix.python-version }}

.gitignore

@@ -22,4 +22,22 @@ coverage.xml
 nosetests.xml
 junit-py25.xml
 junit-py26.xml
-junit-py27.xml
+junit-py27.xml
+
+# tox noise
+.tox
+
+# pyenv noise
+.python-version
+tablib.egg-info/*
+
+# Coverage
+.coverage
+htmlcov
+
+# setuptools noise
+.eggs
+*.egg-info
+
+# generated by setuptools-scm
+/src/tablib/_version.py

.pre-commit-config.yaml

@@ -0,0 +1,25 @@
+repos:
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v2.7.3
+    hooks:
+      - id: pyupgrade
+        args: ["--py36-plus"]
+
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.6.4
+    hooks:
+      - id: isort
+        additional_dependencies: [toml]
+
+  - repo: https://github.com/pre-commit/pygrep-hooks
+    rev: v1.7.0
+    hooks:
+      - id: python-check-blanket-noqa
+      - id: rst-backticks
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.3.0
+    hooks:
+      - id: check-merge-conflict
+      - id: check-toml
+      - id: check-yaml

AUTHORS

@@ -1,16 +1,32 @@
-Tablib is written and maintained by Kenneth Reitz and
-various contributors:
+Tablib was originally written by Kenneth Reitz and is now maintained
+by the Jazzband GitHub team.
 
-Development Lead
-````````````````
+Here is a list of passed and present much-appreciated contributors:
 
-- Kenneth Reitz <me@kennethreitz.com>
-
-
-Patches and Suggestions
-```````````````````````
-
-- Luke Lee
-- Josh Ourisman
-- Luca Beltrame
-- Benjamin Wohlwend
+    Alex Gaynor
+    Andrii Soldatenko
+    Benjamin Wohlwend
+    Bruno Soares
+    Claude Paroz
+    Daniel Santos
+    Erik Youngren
+    Hugo van Kemenade
+    Iuri de Silvio
+    Jakub Janoszek
+    James Douglass
+    Joel Friedly
+    Josh Ourisman
+    Kenneth Reitz
+    Luca Beltrame
+    Luke Lee
+    Marc Abramowitz
+    Marco Dallagiacoma
+    Mark Rogers
+    Mark Walling
+    Mathias Loesch
+    Mike Waldner
+    Peyman Salehi
+    Rabin Nankhwa
+    Tommy Anthony
+    Tsuyoshi Hombashi
+    Tushar Makkar

HACKING

@@ -1,14 +0,0 @@
-Where possible, please follow PEP8 with regard to coding style. Sometimes the line 
-length restriction is too hard to follow, so don't bend over backwards there.
-
-Triple-quotes should always be """, single quotes are ' unless using "
-would result in less escaping within the string.
-
-All modules, functions, and methods should be well documented reStructuredText for 
-Sphinx AutoDoc.
-
-All functionality should be available in pure Python. Optional C (via Cython)
-implementations may be written for performance reasons, but should never
-replace the Python implementation.
-
-Lastly, don't take yourself too seriously :)

HISTORY.md

@@ -0,0 +1,341 @@
+# History
+
+## Unreleased
+
+### Breaking changes
+
+- Dropped Python 3.5 support
+
+### Improvements
+
+- Added Python 3.9 support
+- Added read_only option to xlsx file reader (#482).
+
+### Bugfixes
+
+- Prevented crash in rst export with only-space strings (#469).
+
+## 2.0.0 (2020-05-16)
+
+### Breaking changes
+
+- The `Row.lpush/rpush` logic was reversed. `lpush` was appending while `rpush`
+  and `append` were prepending. This was fixed (reversed behavior). If you
+  counted on the broken behavior, please update your code (#453).
+
+### Bugfixes
+
+- Fixed minimal openpyxl dependency version to 2.6.0 (#457).
+- Dates from xls files are now read as Python datetime objects (#373).
+- Allow import of "ragged" xlsx files (#465).
+
+### Improvements
+
+- When importing an xlsx file, Tablib will now read cell values instead of formulas (#462).
+
+## 1.1.0 (2020-02-13)
+
+### Deprecations
+
+- Upcoming breaking change in Tablib 2.0.0: the `Row.lpush/rpush` logic is reversed.
+  `lpush` is appending while `rpush` and `append` are prepending. The broken behavior
+  will remain in Tablib 1.x and will be fixed (reversed) in Tablib 2.0.0 (#453). If you
+  count on the broken behavior, please update your code when you upgrade to Tablib 2.x.
+
+### Improvements
+
+- Tablib is now able to import CSV content where not all rows have the same
+  length. Missing columns on any line receive the empty string (#226).
+
+## 1.0.0 (2020-01-13)
+
+### Breaking changes
+
+- Dropped Python 2 support
+- Dependencies are now all optional. To install `tablib` as before with all
+  possible supported formats, run `pip install tablib[all]`
+
+### Improvements
+
+- Formats can now be dynamically registered through the
+  `tablib.formats.registry.refister` API (#256).
+- Tablib methods expecting data input (`detect_format`, `import_set`,
+  `Dataset.load`, `Databook.load`) now accepts file-like objects in addition
+  to raw strings and bytestrings (#440).
+
+### Bugfixes
+
+- Fixed a crash when exporting an empty string with the ReST format (#368)
+- Error cells from imported .xls files contain now the error string (#202)
+
+## 0.14.0 (2019-10-19)
+
+### Deprecations
+
+- The 0.14.x series will be the last to support Python 2
+
+### Breaking changes
+
+- Dropped Python 3.4 support
+
+### Improvements
+
+- Added Python 3.7 and 3.8 support
+- The project is now maintained by the Jazzband team, https://jazzband.co
+- Improved format autodetection and added autodetection for the odf format.
+- Added search to all documentation pages
+- Open xlsx workbooks in read-only mode (#316)
+- Unpin requirements
+- Only install backports.csv on Python 2
+
+### Bugfixes
+
+- Fixed `DataBook().load` parameter ordering (first stream, then format).
+- Fixed a regression for xlsx exports where non-string values were forced to
+  strings (#314)
+- Fixed xlsx format detection (which was often detected as `xls` format)
+
+## 0.13.0 (2019-03-08)
+
+- Added reStructuredText output capability (#336)
+- Added Jira output capability
+- Stopped calling openpyxl deprecated methods (accessing cells, removing sheets)
+  (openpyxl minimal version is now 2.4.0)
+- Fixed a circular dependency issue in JSON output (#332)
+- Fixed Unicode error for the CSV export on Python 2 (#215)
+- Removed usage of optional `ujson` (#311)
+- Dropped Python 3.3 support
+
+## 0.12.1 (2017-09-01)
+
+- Favor `Dataset.export(<format>)` over `Dataset.<format>` syntax in docs
+- Make Panda dependency optional
+
+## 0.12.0 (2017-08-27)
+
+- Add initial Panda DataFrame support
+- Dropped Python 2.6 support
+
+## 0.11.5 (2017-06-13)
+
+- Use `yaml.safe_load` for importing yaml.
+
+## 0.11.4 (2017-01-23)
+
+- Use built-in `json` package if available
+- Support Python 3.5+ in classifiers
+
+### Bugfixes
+
+- Fixed textual representation for Dataset with no headers
+- Handle decimal types
+
+## 0.11.3 (2016-02-16)
+
+- Release fix.
+
+## 0.11.2 (2016-02-16)
+
+### Bugfixes
+
+- Fix export only formats.
+- Fix for xlsx output.
+
+## 0.11.1 (2016-02-07)
+
+### Bugfixes
+
+- Fixed packaging error on Python 3.
+
+
+## 0.11.0 (2016-02-07)
+
+### New Formats!
+
+- Added LaTeX table export format (`Dataset.latex`).
+- Support for dBase (DBF) files (`Dataset.dbf`).
+
+### Improvements
+
+- New import/export interface (`Dataset.export()`, `Dataset.load()`).
+- CSV custom delimiter support (`Dataset.export('csv', delimiter='$')`).
+- Adding ability to remove duplicates to all rows in a dataset (`Dataset.remove_duplicates()`).
+- Added a mechanism to avoid `datetime.datetime` issues when serializing data.
+- New `detect_format()` function (mostly for internal use).
+- Update the vendored unicodecsv to fix `None` handling.
+- Only freeze the headers row, not the headers columns (xls).
+
+### Breaking Changes
+
+- `detect()` function removed.
+
+### Bugfixes
+
+- Fix XLSX import.
+- Bugfix for `Dataset.transpose().transpose()`.
+
+
+## 0.10.0 (2014-05-27)
+
+* Unicode Column Headers
+* ALL the bugfixes!
+
+## 0.9.11 (2011-06-30)
+
+* Bugfixes
+
+## 0.9.10 (2011-06-22)
+
+* Bugfixes
+
+## 0.9.9 (2011-06-21)
+
+* Dataset API Changes
+* `stack_rows` => `stack`, `stack_columns` => `stack_cols`
+* column operations have their own methods now (`append_col`, `insert_col`)
+* List-style `pop()`
+* Redis-style `rpush`, `lpush`, `rpop`, `lpop`, `rpush_col`, and `lpush_col`
+
+## 0.9.8 (2011-05-22)
+
+* OpenDocument Spreadsheet support (.ods)
+* Full Unicode TSV support
+
+
+## 0.9.7 (2011-05-12)
+
+* Full XLSX Support!
+* Pickling Bugfix
+* Compat Module
+
+
+## 0.9.6 (2011-05-12)
+
+* `seperators` renamed to `separators`
+* Full unicode CSV support
+
+
+## 0.9.5 (2011-03-24)
+
+* Python 3.1, Python 3.2 Support (same code base!)
+* Formatter callback support
+* Various bug fixes
+
+
+
+## 0.9.4 (2011-02-18)
+
+* Python 2.5 Support!
+* Tox Testing for 2.5, 2.6, 2.7
+* AnyJSON Integrated
+* OrderedDict support
+* Caved to community pressure (spaces)
+
+
+## 0.9.3 (2011-01-31)
+
+* Databook duplication leak fix.
+* HTML Table output.
+* Added column sorting.
+
+
+## 0.9.2 (2010-11-17)
+
+* Transpose method added to Datasets.
+* New frozen top row in Excel output.
+* Pickling support for Datasets and Rows.
+* Support for row/column stacking.
+
+
+## 0.9.1 (2010-11-04)
+
+* Minor reference shadowing bugfix.
+
+
+## 0.9.0 (2010-11-04)
+
+* Massive documentation update!
+* Tablib.org!
+* Row tagging and Dataset filtering!
+* Column insert/delete support
+* Column append API change (header required)
+* Internal Changes (Row object and use thereof)
+
+
+## 0.8.5 (2010-10-06)
+
+* New import system. All dependencies attempt to load from site-packages,
+  then fallback on tenderized modules.
+
+
+## 0.8.4 (2010-10-04)
+
+* Updated XLS output: Only wrap if '\\n' in cell.
+
+
+## 0.8.3 (2010-10-04)
+
+* Ability to append new column passing a callable
+  as the value that will be applied to every row.
+
+
+## 0.8.2 (2010-10-04)
+
+* Added alignment wrapping to written cells.
+* Added separator support to XLS.
+
+
+## 0.8.1 (2010-09-28)
+
+* Packaging Fix
+
+
+## 0.8.0 (2010-09-25)
+
+* New format plugin system!
+* Imports! ELEGANT Imports!
+* Tests. Lots of tests.
+
+
+## 0.7.1 (2010-09-20)
+
+* Reverting methods back to properties.
+* Windows bug compensated in documentation.
+
+
+## 0.7.0 (2010-09-20)
+
+* Renamed DataBook Databook for consistency.
+* Export properties changed to methods (XLS filename / StringIO bug).
+* Optional Dataset.xls(path='filename') support (for writing on windows).
+* Added utf-8 on the worksheet level.
+
+
+## 0.6.4 (2010-09-19)
+
+* Updated unicode export for XLS.
+* More exhaustive unit tests.
+
+
+## 0.6.3 (2010-09-14)
+
+* Added Dataset.append() support for columns.
+
+
+## 0.6.2 (2010-09-13)
+
+* Fixed Dataset.append() error on empty dataset.
+* Updated Dataset.headers property w/ validation.
+* Added Testing Fixtures.
+
+## 0.6.1 (2010-09-12)
+
+* Packaging hotfixes.
+
+
+## 0.6.0 (2010-09-11)
+
+* Public Release.
+* Export Support for XLS, JSON, YAML, and CSV.
+* DataBook Export for XLS, JSON, and YAML.
+* Python Dict Property Support.

HISTORY.rst

@@ -1,145 +0,0 @@
-History
--------
-
-0.9.5 (2011-03-24)
-++++++++++++++++++
-
-* Python 3.1, Python 3.2 Support (same code base!)
-* Formatter callback support
-* Various bug fixes
-
-
-
-0.9.4 (2011-02-18)
-++++++++++++++++++
-
-* Python 2.5 Support!
-* Tox Testing for 2.5, 2.6, 2.7
-* AnyJSON Integrated
-* OrderedDict support
-* Caved to community pressure (spaces)
-
-
-0.9.3 (2011-01-31)
-++++++++++++++++++
-
-* Databook duplication leak fix.
-* HTML Table output.
-* Added column sorting.
-
-
-0.9.2 (2010-11-17)
-++++++++++++++++++
-
-* Transpose method added to Datasets.
-* New frozen top row in Excel output.
-* Pickling support for Datasets and Rows.
-* Support for row/column stacking.
-
-
-0.9.1 (2010-11-04)
-++++++++++++++++++
-
-* Minor reference shadowing bugfix.
-
-
-0.9.0 (2010-11-04)
-++++++++++++++++++
-
-* Massive documentation update!
-* Tablib.org!
-* Row tagging and Dataset filtering!
-* Column insert/delete support
-* Column append API change (header required)
-* Internal Changes (Row object and use thereof)
-
-
-0.8.5 (2010-10-06)
-++++++++++++++++++
-
-* New import system. All dependencies attempt to load from site-packages,
-  then fallback on tenderized modules.
-
-
-0.8.4 (2010-10-04)
-++++++++++++++++++
-
-* Updated XLS output: Only wrap if '\\n' in cell.
-
-
-0.8.3 (2010-10-04)
-++++++++++++++++++
-
-* Ability to append new column passing a callable 
-  as the value that will be applied to every row.
-
-
-0.8.2 (2010-10-04)
-++++++++++++++++++
-
-* Added alignment wrapping to written cells.
-* Added separator support to XLS.
-
-
-0.8.1 (2010-09-28)
-++++++++++++++++++
-
-* Packaging Fix
-
-
-0.8.0 (2010-09-25)
-++++++++++++++++++
-
-* New format plugin system!
-* Imports! ELEGANT Imports!
-* Tests. Lots of tests.
-
-
-0.7.1 (2010-09-20)
-++++++++++++++++++
-
-* Reverting methods back to properties. 
-* Windows bug compensated in documentation.
-
-
-0.7.0 (2010-09-20)
-++++++++++++++++++
-
-* Renamed DataBook Databook for consistency.
-* Export properties changed to methods (XLS filename / StringIO bug).
-* Optional Dataset.xls(path='filename') support (for writing on windows).
-* Added utf-8 on the worksheet level.
-
-
-0.6.4 (2010-09-19)
-++++++++++++++++++
-
-* Updated unicode export for XLS.
-* More exhaustive unit tests.
-
-
-0.6.3 (2010-09-14)
-++++++++++++++++++
-* Added Dataset.append() support for columns.
-
-
-0.6.2 (2010-09-13)
-++++++++++++++++++
-* Fixed Dataset.append() error on empty dataset.
-* Updated Dataset.headers property w/ validation.
-* Added Testing Fixtures.
-
-0.6.1 (2010-09-12)
-++++++++++++++++++
-
-* Packaging hotfixes.
-
-
-0.6.0 (2010-09-11)
-++++++++++++++++++
-
-* Public Release.
-* Export Support for XLS, JSON, YAML, and CSV.
-* DataBook Export for XLS, JSON, and YAML.
-* Python Dict Property Support.
-

LICENSE

@@ -1,4 +1,5 @@
-Copyright (c) 2011 Kenneth Reitz.
+Copyright 2016 Kenneth Reitz
+Copyright 2019 Jazzband
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -16,4 +17,4 @@ 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.
+THE SOFTWARE.

MANIFEST.in

@@ -1 +0,0 @@
-include HISTORY.rst README.rst LICENSE AUTHORS 

NOTICE

@@ -1,178 +0,0 @@
-Tablib includes some vendorized python libraries: ordereddict, pyyaml,
-simplejson, and xlwt.
-
-Markup License
-==============
-
-Markup is in the public domain.
-
-
-
-OrderedDict License
-===================
-
-Copyright (c) 2009 Raymond Hettinger
-
-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.
-
-
-
-PyYAML License
-==============
-
-Copyright (c) 2006 Kirill Simonov
-
-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.
-
-
-
-AnyJSON License
-==================
-
-This software is licensed under the ``New BSD License``:
-
-Copyright (c) 2009, by the authors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-Neither the name of the authors nor the names of its contributors may be used
-to endorse or promote products derived from this software without specific
-prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
-BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-
-
-
-XLWT License
-============
-
-Portions copyright © 2007, Stephen John Machin, Lingfo Pty Ltd
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice,
-this list of conditions and the following disclaimer. 
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-this list of conditions and the following disclaimer in the documentation
-and/or other materials provided with the distribution. 
-
-3. None of the names of Stephen John Machin, Lingfo Pty Ltd and any
-contributors may be used to endorse or promote products derived from this
-software without specific prior written permission. 
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
-BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGE.
-"""
-
-"""
-  Copyright (C) 2005 Roman V. Kiseliov
-  All rights reserved.
- 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions
-  are met:
- 
-  1. Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
- 
-  2. Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in
-     the documentation and/or other materials provided with the
-     distribution.
- 
-  3. All advertising materials mentioning features or use of this
-     software must display the following acknowledgment:
-     "This product includes software developed by
-      Roman V. Kiseliov <roman@kiseliov.ru>."
- 
-  4. Redistributions of any form whatsoever must retain the following
-     acknowledgment:
-     "This product includes software developed by
-      Roman V. Kiseliov <roman@kiseliov.ru>."
- 
-  THIS SOFTWARE IS PROVIDED BY Roman V. Kiseliov ``AS IS'' AND ANY
-  EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL Roman V. Kiseliov OR
-  ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-  OF THE POSSIBILITY OF SUCH DAMAGE.
-
-Roman V. Kiseliov
-Russia
-Kursk
-Libknecht St., 4
-
-+7(0712)56-09-83
-
-<roman@kiseliov.ru>
-Subject: pyExcelerator

README.md

@@ -0,0 +1,44 @@
+# Tablib: format-agnostic tabular dataset library
+
+[![Jazzband](https://jazzband.co/static/img/badge.svg)](https://jazzband.co/)
+[![PyPI version](https://img.shields.io/pypi/v/tablib.svg)](https://pypi.org/project/tablib/)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/tablib.svg)](https://pypi.org/project/tablib/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/tablib.svg)](https://pypistats.org/packages/tablib)
+[![GitHub Actions status](https://github.com/jazzband/tablib/workflows/Test/badge.svg)](https://github.com/jazzband/tablib/actions)
+[![codecov](https://codecov.io/gh/jazzband/tablib/branch/master/graph/badge.svg)](https://codecov.io/gh/jazzband/tablib)
+[![GitHub](https://img.shields.io/github/license/jazzband/tablib.svg)](LICENSE)
+
+    _____         ______  ___________ ______
+    __  /_______ ____  /_ ___  /___(_)___  /_
+    _  __/_  __ `/__  __ \__  / __  / __  __ \
+    / /_  / /_/ / _  /_/ /_  /  _  /  _  /_/ /
+    \__/  \__,_/  /_.___/ /_/   /_/   /_.___/
+
+
+Tablib is a format-agnostic tabular dataset library, written in Python.
+
+Output formats supported:
+
+- Excel (Sets + Books)
+- JSON (Sets + Books)
+- YAML (Sets + Books)
+- Pandas DataFrames (Sets)
+- HTML (Sets)
+- Jira (Sets)
+- TSV (Sets)
+- ODS (Sets)
+- CSV (Sets)
+- DBF (Sets)
+
+Note that tablib *purposefully* excludes XML support. It always will. (Note: This is a
+joke. Pull requests are welcome.)
+
+Tablib documentation is graciously hosted on https://tablib.readthedocs.io
+
+It is also available in the ``docs`` directory of the source distribution.
+
+Make sure to check out [Tablib on PyPI](https://pypi.org/project/tablib/)!
+
+## Contribute
+
+Please see the [contributing guide](https://github.com/jazzband/tablib/blob/master/.github/CONTRIBUTING.md).

README.rst

@@ -1,148 +0,0 @@
-Tablib: format-agnostic tabular dataset library
-===============================================
-
-::
-
-	_____         ______  ___________ ______  
-	__  /_______ ____  /_ ___  /___(_)___  /_ 
-	_  __/_  __ `/__  __ \__  / __  / __  __ \
-	/ /_  / /_/ / _  /_/ /_  /  _  /  _  /_/ /
-	\__/  \__,_/  /_.___/ /_/   /_/   /_.___/
-
-
-
-Tablib is a format-agnostic tabular dataset library, written in Python. 
-
-Output formats supported:
-
-- Excel (Sets + Books)
-- JSON (Sets + Books)
-- YAML (Sets + Books)
-- HTML (Sets)
-- TSV (Sets)
-- CSV (Sets)
-
-Note that tablib *purposefully* excludes XML support. It always will. (Note: This is a joke. Pull requests are welcome.)
-
-Overview
---------
-
-`tablib.Dataset()`
-	A Dataset is a table of tabular data. It may or may not have a header row. They can be build and manipulated as raw Python datatypes (Lists of tuples|dictionaries). Datasets can be imported from JSON, YAML, and CSV; they can be exported to Excel (XLS), JSON, YAML, and CSV.
-	
-`tablib.Databook()`
-	A Databook is a set of Datasets. The most common form of a Databook is an Excel file with multiple spreadsheets. Databooks can be imported from JSON and YAML; they can be exported to Excel (XLS), JSON, and YAML.
-
-Usage
------
-
-    
-Populate fresh data files: ::
-    
-    headers = ('first_name', 'last_name')
-
-    data = [
-        ('John', 'Adams'),
-        ('George', 'Washington')
-    ]
-    
-    data = tablib.Dataset(*data, headers=headers)
-
-
-Intelligently add new rows: ::
-
-    >>> data.append(('Henry', 'Ford'))
-
-Intelligently add new columns: ::
-
-    >>> data.append(col=(90, 67, 83), header='age')
-    
-Slice rows:  ::
-
-    >>> print data[:2]
-    [('John', 'Adams', 90), ('George', 'Washington', 67)]
-    
-
-Slice columns by header: ::
-
-    >>> print data['first_name']
-    ['John', 'George', 'Henry']
-
-Easily delete rows: ::
-
-    >>> del data[1]
-
-Exports
--------
-
-Drumroll please...........
-
-JSON! 
-+++++
-::
-
-	>>> print data.json
-	[
-	  {
-	    "last_name": "Adams",
-	    "age": 90,
-	    "first_name": "John"
-	  },
-	  {
-	    "last_name": "Ford",
-	    "age": 83,
-	    "first_name": "Henry"
-	  }
-	]
-	
-
-YAML! 
-+++++
-::
-
-	>>> print data.yaml
-	- {age: 90, first_name: John, last_name: Adams}
-	- {age: 83, first_name: Henry, last_name: Ford}
-	
-CSV... 
-++++++
-::
-
-	>>> print data.csv
-	first_name,last_name,age 
-	John,Adams,90 
-	Henry,Ford,83 
-	
-EXCEL! 
-++++++
-::
-
-	>>> open('people.xls', 'wb').write(data.xls)
-
-It's that easy.
-
-
-Installation
-------------
-
-To install tablib, simply: ::
-
-	$ pip install tablib
-	
-Or, if you absolutely must: ::
-
-	$ easy_install tablib
-   
-Contribute
-----------
-
-If you'd like to contribute, simply fork `the repository`_, commit your changes to the **develop** branch (or branch off of it), and send a pull request. Make sure you add yourself to AUTHORS_.
-
-
-Roadmap
--------
-- Python 2.4, 3.0, 3.1, 3.2 Support
-- Tablib.ext namespace
-
-.. _`the repository`: http://github.com/kennethreitz/tablib
-.. _AUTHORS: http://github.com/kennethreitz/tablib/blob/master/AUTHORS

RELEASING.md

@@ -0,0 +1,29 @@
+# Release checklist
+
+Jazzband guidelines: https://jazzband.co/about/releases
+
+* [ ] Get master to the appropriate code release state.
+      [GitHub Actions](https://github.com/jazzband/tablib/actions)
+      should pass on master.
+      [![GitHub Actions status](https://github.com/jazzband/tablib/workflows/Test/badge.svg)](https://github.com/jazzband/tablib/actions)
+
+* [ ] Check [HISTORY.md](https://github.com/jazzband/tablib/blob/master/HISTORY.md),
+      update version number and release date
+
+* [ ] Tag with version number and push tag, for example:
+```bash
+git tag -a v0.14.0 -m v0.14.0
+git push --tags
+```
+
+* [ ] Once GitHub Actions has built and uploaded distributions, check files at
+      [Jazzband](https://jazzband.co/projects/tablib) and release to
+      [PyPI](https://pypi.org/pypi/tablib)
+
+* [ ] Check installation:
+```bash
+pip uninstall -y tablib && pip install -U tablib
+```
+
+* [ ] Create new GitHub release: https://github.com/jazzband/tablib/releases/new
+  * Tag: Pick existing tag "v0.14.0"

TODO.rst

@@ -1,13 +0,0 @@
-* Add seperator support to HTML out
-* Hooks System
-  - pre/post-append
-  - pre/post-import
-  - pre/post-export
-* Big Data
-* Backwards-compatible OrderedDict support
-* Write more exhausive unit-tests.
-* Write stress tests.
-* Make CSV write customizable.
-* Integrate django-tablib
-* Mention django-tablib in Documention
-* Dataset title usage in documentation (#17)

docs/_templates/sidebarintro.html

@@ -0,0 +1,12 @@
+<h3><a href="https://tablib.readthedocs.io">About Tablib</a></h3>
+<p>
+  Tablib is an MIT Licensed format-agnostic tabular dataset library, written in Python. It allows you to import, export, and manipulate tabular data sets. Advanced features include, segregation, dynamic columns, tags & filtering, and seamless format import & export.
+</p>
+<h3>Useful Links</h3>
+<ul>
+  <li><a href="https://tablib.readthedocs.io">The Tablib Website</a></li>
+  <li><a href="https://pypi.org/project/tablib">Tablib @ PyPI</a></li>
+  <li><a href="https://github.com/jazzband/tablib">Tablib @ GitHub</a></li>
+  <li><a href="https://github.com/jazzband/tablib/issues">Issue Tracker</a></li>
+  <li><a href="https://github.com/jazzband/tablib/blob/master/HISTORY.md">Changelog</a></li>
+</ul>

docs/_templates/sidebarlogo.html

@@ -0,0 +1,4 @@
+<h3><a href="https://tablib.readthedocs.io">About Tablib</a></h3>
+<p>
+  Tablib is an MIT Licensed format-agnostic tabular dataset library, written in Python. It allows you to import, export, and manipulate tabular data sets. Advanced features include, segregation, dynamic columns, tags & filtering, and seamless format import & export.
+</p>

docs/_themes/.gitignore

@@ -1,3 +0,0 @@
-*.pyc
-*.pyo
-.DS_Store

docs/_themes/LICENSE

@@ -1,45 +0,0 @@
-Modifications: 
-
-Copyright (c) 2011 Kenneth Reitz.
-
-
-Original Project: 
-
-Copyright (c) 2010 by Armin Ronacher.
-
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms of the theme, with or
-without modification, are permitted provided that the following conditions
-are met:
-
-* Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the following
-  disclaimer in the documentation and/or other materials provided
-  with the distribution.
-
-* The names of the contributors may not be used to endorse or
-  promote products derived from this software without specific
-  prior written permission.
-
-We kindly ask you to only use these themes in an unmodified manner just
-for Flask and Flask-related products, not for unrelated projects.  If you
-like the visual style and want to use it for your own projects, please
-consider making some larger changes to the themes (such as changing
-font faces, sizes, colors or margins).
-
-THIS THEME IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS THEME, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.

docs/_themes/README.rst

@@ -1,25 +0,0 @@
-krTheme Sphinx Style
-====================
-
-This repository contains sphinx styles Kenneth Reitz uses in most of 
-his projects. It is a drivative of Mitsuhiko's themes for Flask and Flask related
-projects.  To use this style in your Sphinx documentation, follow
-this guide:
-
-1. put this folder as _themes into your docs folder.  Alternatively
-   you can also use git submodules to check out the contents there.
-
-2. add this to your conf.py: ::
-
-	sys.path.append(os.path.abspath('_themes'))
-	html_theme_path = ['_themes']
-	html_theme = 'flask'
-
-The following themes exist:
-
-**kr**
-	the standard flask documentation theme for large projects
-
-**kr_small**
-	small one-page theme.  Intended to be used by very small addon libraries.
-

docs/_themes/flask_theme_support.py

@@ -1,86 +0,0 @@
-# flasky extensions.  flasky pygments style based on tango style
-from pygments.style import Style
-from pygments.token import Keyword, Name, Comment, String, Error, \
-     Number, Operator, Generic, Whitespace, Punctuation, Other, Literal
-
-
-class FlaskyStyle(Style):
-    background_color = "#f8f8f8"
-    default_style = ""
-
-    styles = {
-        # No corresponding class for the following:
-        #Text:                     "", # class:  ''
-        Whitespace:                "underline #f8f8f8",      # class: 'w'
-        Error:                     "#a40000 border:#ef2929", # class: 'err'
-        Other:                     "#000000",                # class 'x'
-
-        Comment:                   "italic #8f5902", # class: 'c'
-        Comment.Preproc:           "noitalic",       # class: 'cp'
-
-        Keyword:                   "bold #004461",   # class: 'k'
-        Keyword.Constant:          "bold #004461",   # class: 'kc'
-        Keyword.Declaration:       "bold #004461",   # class: 'kd'
-        Keyword.Namespace:         "bold #004461",   # class: 'kn'
-        Keyword.Pseudo:            "bold #004461",   # class: 'kp'
-        Keyword.Reserved:          "bold #004461",   # class: 'kr'
-        Keyword.Type:              "bold #004461",   # class: 'kt'
-
-        Operator:                  "#582800",   # class: 'o'
-        Operator.Word:             "bold #004461",   # class: 'ow' - like keywords
-
-        Punctuation:               "bold #000000",   # class: 'p'
-
-        # because special names such as Name.Class, Name.Function, etc.
-        # are not recognized as such later in the parsing, we choose them
-        # to look the same as ordinary variables.
-        Name:                      "#000000",        # class: 'n'
-        Name.Attribute:            "#c4a000",        # class: 'na' - to be revised
-        Name.Builtin:              "#004461",        # class: 'nb'
-        Name.Builtin.Pseudo:       "#3465a4",        # class: 'bp'
-        Name.Class:                "#000000",        # class: 'nc' - to be revised
-        Name.Constant:             "#000000",        # class: 'no' - to be revised
-        Name.Decorator:            "#888",           # class: 'nd' - to be revised
-        Name.Entity:               "#ce5c00",        # class: 'ni'
-        Name.Exception:            "bold #cc0000",   # class: 'ne'
-        Name.Function:             "#000000",        # class: 'nf'
-        Name.Property:             "#000000",        # class: 'py'
-        Name.Label:                "#f57900",        # class: 'nl'
-        Name.Namespace:            "#000000",        # class: 'nn' - to be revised
-        Name.Other:                "#000000",        # class: 'nx'
-        Name.Tag:                  "bold #004461",   # class: 'nt' - like a keyword
-        Name.Variable:             "#000000",        # class: 'nv' - to be revised
-        Name.Variable.Class:       "#000000",        # class: 'vc' - to be revised
-        Name.Variable.Global:      "#000000",        # class: 'vg' - to be revised
-        Name.Variable.Instance:    "#000000",        # class: 'vi' - to be revised
-
-        Number:                    "#990000",        # class: 'm'
-
-        Literal:                   "#000000",        # class: 'l'
-        Literal.Date:              "#000000",        # class: 'ld'
-
-        String:                    "#4e9a06",        # class: 's'
-        String.Backtick:           "#4e9a06",        # class: 'sb'
-        String.Char:               "#4e9a06",        # class: 'sc'
-        String.Doc:                "italic #8f5902", # class: 'sd' - like a comment
-        String.Double:             "#4e9a06",        # class: 's2'
-        String.Escape:             "#4e9a06",        # class: 'se'
-        String.Heredoc:            "#4e9a06",        # class: 'sh'
-        String.Interpol:           "#4e9a06",        # class: 'si'
-        String.Other:              "#4e9a06",        # class: 'sx'
-        String.Regex:              "#4e9a06",        # class: 'sr'
-        String.Single:             "#4e9a06",        # class: 's1'
-        String.Symbol:             "#4e9a06",        # class: 'ss'
-
-        Generic:                   "#000000",        # class: 'g'
-        Generic.Deleted:           "#a40000",        # class: 'gd'
-        Generic.Emph:              "italic #000000", # class: 'ge'
-        Generic.Error:             "#ef2929",        # class: 'gr'
-        Generic.Heading:           "bold #000080",   # class: 'gh'
-        Generic.Inserted:          "#00A000",        # class: 'gi'
-        Generic.Output:            "#888",           # class: 'go'
-        Generic.Prompt:            "#745334",        # class: 'gp'
-        Generic.Strong:            "bold #000000",   # class: 'gs'
-        Generic.Subheading:        "bold #800080",   # class: 'gu'
-        Generic.Traceback:         "bold #a40000",   # class: 'gt'
-    }

docs/_themes/kr/layout.html

@@ -1,16 +0,0 @@
-{%- extends "basic/layout.html" %}
-{%- block extrahead %}
-  {{ super() }}
-  {% if theme_touch_icon %}
-  <link rel="apple-touch-icon" href="{{ pathto('_static/' ~ theme_touch_icon, 1) }}" />
-  {% endif %}
-  <link media="only screen and (max-device-width: 480px)" href="{{
-    pathto('_static/small_flask.css', 1) }}" type= "text/css" rel="stylesheet" />
-{% endblock %}
-{%- block relbar2 %}{% endblock %}
-{%- block footer %}
-    <div class="footer">
-      &copy; Copyright {{ copyright }}.
-      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a>.
-    </div>
-{%- endblock %}

docs/_themes/kr/relations.html

@@ -1,19 +0,0 @@
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="{{ pathto(master_doc) }}">Documentation overview</a><ul>
-  {%- for parent in parents %}
-  <li><a href="{{ parent.link|e }}">{{ parent.title }}</a><ul>
-  {%- endfor %}
-    {%- if prev %}
-      <li>Previous: <a href="{{ prev.link|e }}" title="{{ _('previous chapter')
-        }}">{{ prev.title }}</a></li>
-    {%- endif %}
-    {%- if next %}
-      <li>Next: <a href="{{ next.link|e }}" title="{{ _('next chapter')
-        }}">{{ next.title }}</a></li>
-    {%- endif %}
-  {%- for parent in parents %}
-  </ul></li>
-  {%- endfor %}
-  </ul></li>
-</ul>

docs/_themes/kr/static/flasky.css_t

@@ -1,387 +0,0 @@
-/*
- * flasky.css_t
- * ~~~~~~~~~~~~
- *
- * :copyright: Copyright 2010 by Armin Ronacher. Modifications by Kenneth Reitz.
- * :license: Flask Design License, see LICENSE for details.
- */
-
-{% set page_width = '940px' %}
-{% set sidebar_width = '220px' %}
- 
-@import url("basic.css");
- 
-/* -- page layout ----------------------------------------------------------- */
- 
-body {
-    font-family: 'goudy old style', 'minion pro', 'bell mt', Georgia, 'Hiragino Mincho Pro';
-    font-size: 17px;
-    background-color: white;
-    color: #000;
-    margin: 0;
-    padding: 0;
-}
-
-div.document {
-    width: {{ page_width }};
-    margin: 30px auto 0 auto;
-}
-
-div.documentwrapper {
-    float: left;
-    width: 100%;
-}
-
-div.bodywrapper {
-    margin: 0 0 0 {{ sidebar_width }};
-}
-
-div.sphinxsidebar {
-    width: {{ sidebar_width }};
-}
-
-hr {
-    border: 1px solid #B1B4B6;
-}
- 
-div.body {
-    background-color: #ffffff;
-    color: #3E4349;
-    padding: 0 30px 0 30px;
-}
-
-img.floatingflask {
-    padding: 0 0 10px 10px;
-    float: right;
-}
- 
-div.footer {
-    width: {{ page_width }};
-    margin: 20px auto 30px auto;
-    font-size: 14px;
-    color: #888;
-    text-align: right;
-}
-
-div.footer a {
-    color: #888;
-}
-
-div.related {
-    display: none;
-}
- 
-div.sphinxsidebar a {
-    color: #444;
-    text-decoration: none;
-    border-bottom: 1px dotted #999;
-}
-
-div.sphinxsidebar a:hover {
-    border-bottom: 1px solid #999;
-}
- 
-div.sphinxsidebar {
-    font-size: 14px;
-    line-height: 1.5;
-}
-
-div.sphinxsidebarwrapper {
-    padding: 18px 10px;
-}
-
-div.sphinxsidebarwrapper p.logo {
-    padding: 0 0 20px 0;
-    margin: 0;
-    text-align: center;
-}
- 
-div.sphinxsidebar h3,
-div.sphinxsidebar h4 {
-    font-family: 'Garamond', 'Georgia', serif;
-    color: #444;
-    font-size: 24px;
-    font-weight: normal;
-    margin: 0 0 5px 0;
-    padding: 0;
-}
-
-div.sphinxsidebar h4 {
-    font-size: 20px;
-}
- 
-div.sphinxsidebar h3 a {
-    color: #444;
-}
-
-div.sphinxsidebar p.logo a,
-div.sphinxsidebar h3 a,
-div.sphinxsidebar p.logo a:hover,
-div.sphinxsidebar h3 a:hover {
-    border: none;
-}
- 
-div.sphinxsidebar p {
-    color: #555;
-    margin: 10px 0;
-}
-
-div.sphinxsidebar ul {
-    margin: 10px 0;
-    padding: 0;
-    color: #000;
-}
- 
-div.sphinxsidebar input {
-    border: 1px solid #ccc;
-    font-family: 'Georgia', serif;
-    font-size: 1em;
-}
- 
-/* -- body styles ----------------------------------------------------------- */
- 
-a {
-    color: #004B6B;
-    text-decoration: underline;
-}
- 
-a:hover {
-    color: #6D4100;
-    text-decoration: underline;
-}
- 
-div.body h1,
-div.body h2,
-div.body h3,
-div.body h4,
-div.body h5,
-div.body h6 {
-    font-family: 'Garamond', 'Georgia', serif;
-    font-weight: normal;
-    margin: 30px 0px 10px 0px;
-    padding: 0;
-}
- 
-div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; }
-div.body h2 { font-size: 180%; }
-div.body h3 { font-size: 150%; }
-div.body h4 { font-size: 130%; }
-div.body h5 { font-size: 100%; }
-div.body h6 { font-size: 100%; }
- 
-a.headerlink {
-    color: #ddd;
-    padding: 0 4px;
-    text-decoration: none;
-}
- 
-a.headerlink:hover {
-    color: #444;
-    background: #eaeaea;
-}
- 
-div.body p, div.body dd, div.body li {
-    line-height: 1.4em;
-}
-
-div.admonition {
-    background: #fafafa;
-    margin: 20px -30px;
-    padding: 10px 30px;
-    border-top: 1px solid #ccc;
-    border-bottom: 1px solid #ccc;
-}
-
-div.admonition tt.xref, div.admonition a tt {
-    border-bottom: 1px solid #fafafa;
-}
-
-dd div.admonition {
-    margin-left: -60px;
-    padding-left: 60px;
-}
-
-div.admonition p.admonition-title {
-    font-family: 'Garamond', 'Georgia', serif;
-    font-weight: normal;
-    font-size: 24px;
-    margin: 0 0 10px 0;
-    padding: 0;
-    line-height: 1;
-}
-
-div.admonition p.last {
-    margin-bottom: 0;
-}
-
-div.highlight {
-    background-color: white;
-}
-
-dt:target, .highlight {
-    background: #FAF3E8;
-}
-
-div.note {
-    background-color: #eee;
-    border: 1px solid #ccc;
-}
- 
-div.seealso {
-    background-color: #ffc;
-    border: 1px solid #ff6;
-}
- 
-div.topic {
-    background-color: #eee;
-}
- 
-p.admonition-title {
-    display: inline;
-}
- 
-p.admonition-title:after {
-    content: ":";
-}
-
-pre, tt {
-    font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
-    font-size: 0.9em;
-}
-
-img.screenshot {
-}
-
-tt.descname, tt.descclassname {
-    font-size: 0.95em;
-}
-
-tt.descname {
-    padding-right: 0.08em;
-}
-
-img.screenshot {
-    -moz-box-shadow: 2px 2px 4px #eee;
-    -webkit-box-shadow: 2px 2px 4px #eee;
-    box-shadow: 2px 2px 4px #eee;
-}
-
-table.docutils {
-    border: 1px solid #888;
-    -moz-box-shadow: 2px 2px 4px #eee;
-    -webkit-box-shadow: 2px 2px 4px #eee;
-    box-shadow: 2px 2px 4px #eee;
-}
-
-table.docutils td, table.docutils th {
-    border: 1px solid #888;
-    padding: 0.25em 0.7em;
-}
-
-table.field-list, table.footnote {
-    border: none;
-    -moz-box-shadow: none;
-    -webkit-box-shadow: none;
-    box-shadow: none;
-}
-
-table.footnote {
-    margin: 15px 0;
-    width: 100%;
-    border: 1px solid #eee;
-    background: #fdfdfd;
-    font-size: 0.9em;
-}
-
-table.footnote + table.footnote {
-    margin-top: -15px;
-    border-top: none;
-}
-
-table.field-list th {
-    padding: 0 0.8em 0 0;
-}
-
-table.field-list td {
-    padding: 0;
-}
-
-table.footnote td.label {
-    width: 0px;
-    padding: 0.3em 0 0.3em 0.5em;
-}
-
-table.footnote td {
-    padding: 0.3em 0.5em;
-}
-
-dl {
-    margin: 0;
-    padding: 0;
-}
-
-dl dd {
-    margin-left: 30px;
-}
-
-blockquote {
-    margin: 0 0 0 30px;
-    padding: 0;
-}
-
-ul, ol {
-    margin: 10px 0 10px 30px;
-    padding: 0;
-}
- 
-pre {
-    background: #eee;
-    padding: 7px 30px;
-    margin: 15px -30px;
-    line-height: 1.3em;
-}
-
-dl pre, blockquote pre, li pre {
-    margin-left: -60px;
-    padding-left: 60px;
-}
-
-dl dl pre {
-    margin-left: -90px;
-    padding-left: 90px;
-}
- 
-tt {
-    background-color: #ecf0f3;
-    color: #222;
-    /* padding: 1px 2px; */
-}
-
-tt.xref, a tt {
-    background-color: #FBFBFB;
-    border-bottom: 1px solid white;
-}
-
-a.reference {
-    text-decoration: none;
-    border-bottom: 1px dotted #004B6B;
-}
-
-a.reference:hover {
-    border-bottom: 1px solid #6D4100;
-}
-
-a.footnote-reference {
-    text-decoration: none;
-    font-size: 0.7em;
-    vertical-align: top;
-    border-bottom: 1px dotted #004B6B;
-}
-
-a.footnote-reference:hover {
-    border-bottom: 1px solid #6D4100;
-}
-
-a:hover tt {
-    background: #EEE;
-}

docs/_themes/kr/static/small_flask.css

@@ -1,70 +0,0 @@
-/*
- * small_flask.css_t
- * ~~~~~~~~~~~~~~~~~
- *
- * :copyright: Copyright 2010 by Armin Ronacher.
- * :license: Flask Design License, see LICENSE for details.
- */
-
-body {
-    margin: 0;
-    padding: 20px 30px;
-}
-
-div.documentwrapper {
-    float: none;
-    background: white;
-}
-
-div.sphinxsidebar {
-    display: block;
-    float: none;
-    width: 102.5%;
-    margin: 50px -30px -20px -30px;
-    padding: 10px 20px;
-    background: #333;
-    color: white;
-}
-
-div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p,
-div.sphinxsidebar h3 a {
-    color: white;
-}
-
-div.sphinxsidebar a {
-    color: #aaa;
-}
-
-div.sphinxsidebar p.logo {
-    display: none;
-}
-
-div.document {
-    width: 100%;
-    margin: 0;
-}
-
-div.related {
-    display: block;
-    margin: 0;
-    padding: 10px 0 20px 0;
-}
-
-div.related ul,
-div.related ul li {
-    margin: 0;
-    padding: 0;
-}
-
-div.footer {
-    display: none;
-}
-
-div.bodywrapper {
-    margin: 0;
-}
-
-div.body {
-    min-height: 0;
-    padding: 0;
-}

docs/_themes/kr/theme.conf

@@ -1,7 +0,0 @@
-[theme]
-inherit = basic
-stylesheet = flasky.css
-pygments_style = flask_theme_support.FlaskyStyle
-
-[options]
-touch_icon = 

docs/_themes/kr_small/layout.html

@@ -1,22 +0,0 @@
-{% extends "basic/layout.html" %}
-{% block header %}
-  {{ super() }}
-  {% if pagename == 'index' %}
-  <div class=indexwrapper>
-  {% endif %}
-{% endblock %}
-{% block footer %}
-  {% if pagename == 'index' %}
-  </div>
-  {% endif %}
-{% endblock %}
-{# do not display relbars #}
-{% block relbar1 %}{% endblock %}
-{% block relbar2 %}
-  {% if theme_github_fork %}
-    <a href="http://github.com/{{ theme_github_fork }}"><img style="position: fixed; top: 0; right: 0; border: 0;"
-    src="http://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png" alt="Fork me on GitHub" /></a>
-  {% endif %}
-{% endblock %}
-{% block sidebar1 %}{% endblock %}
-{% block sidebar2 %}{% endblock %}

docs/_themes/kr_small/static/flasky.css_t

@@ -1,287 +0,0 @@
-/*
- * flasky.css_t
- * ~~~~~~~~~~~~
- *
- * Sphinx stylesheet -- flasky theme based on nature theme.
- *
- * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
- 
-@import url("basic.css");
- 
-/* -- page layout ----------------------------------------------------------- */
- 
-body {
-    font-family: 'Georgia', serif;
-    font-size: 17px;
-    color: #000;
-    background: white;
-    margin: 0;
-    padding: 0;
-}
-
-div.documentwrapper {
-    float: left;
-    width: 100%;
-}
-
-div.bodywrapper {
-    margin: 40px auto 0 auto;
-    width: 700px;
-}
-
-hr {
-    border: 1px solid #B1B4B6;
-}
- 
-div.body {
-    background-color: #ffffff;
-    color: #3E4349;
-    padding: 0 30px 30px 30px;
-}
-
-img.floatingflask {
-    padding: 0 0 10px 10px;
-    float: right;
-}
- 
-div.footer {
-    text-align: right;
-    color: #888;
-    padding: 10px;
-    font-size: 14px;
-    width: 650px;
-    margin: 0 auto 40px auto;
-}
- 
-div.footer a {
-    color: #888;
-    text-decoration: underline;
-}
- 
-div.related {
-    line-height: 32px;
-    color: #888;
-}
-
-div.related ul {
-    padding: 0 0 0 10px;
-}
- 
-div.related a {
-    color: #444;
-}
- 
-/* -- body styles ----------------------------------------------------------- */
- 
-a {
-    color: #004B6B;
-    text-decoration: underline;
-}
- 
-a:hover {
-    color: #6D4100;
-    text-decoration: underline;
-}
-
-div.body {
-    padding-bottom: 40px; /* saved for footer */
-}
- 
-div.body h1,
-div.body h2,
-div.body h3,
-div.body h4,
-div.body h5,
-div.body h6 {
-    font-family: 'Garamond', 'Georgia', serif;
-    font-weight: normal;
-    margin: 30px 0px 10px 0px;
-    padding: 0;
-}
-
-{% if theme_index_logo %}
-div.indexwrapper h1 {
-    text-indent: -999999px;
-    background: url({{ theme_index_logo }}) no-repeat center center;
-    height: {{ theme_index_logo_height }};
-}
-{% endif %}
- 
-div.body h2 { font-size: 180%; }
-div.body h3 { font-size: 150%; }
-div.body h4 { font-size: 130%; }
-div.body h5 { font-size: 100%; }
-div.body h6 { font-size: 100%; }
- 
-a.headerlink {
-    color: white;
-    padding: 0 4px;
-    text-decoration: none;
-}
- 
-a.headerlink:hover {
-    color: #444;
-    background: #eaeaea;
-}
- 
-div.body p, div.body dd, div.body li {
-    line-height: 1.4em;
-}
-
-div.admonition {
-    background: #fafafa;
-    margin: 20px -30px;
-    padding: 10px 30px;
-    border-top: 1px solid #ccc;
-    border-bottom: 1px solid #ccc;
-}
-
-div.admonition p.admonition-title {
-    font-family: 'Garamond', 'Georgia', serif;
-    font-weight: normal;
-    font-size: 24px;
-    margin: 0 0 10px 0;
-    padding: 0;
-    line-height: 1;
-}
-
-div.admonition p.last {
-    margin-bottom: 0;
-}
-
-div.highlight{
-    background-color: white;
-}
-
-dt:target, .highlight {
-    background: #FAF3E8;
-}
-
-div.note {
-    background-color: #eee;
-    border: 1px solid #ccc;
-}
- 
-div.seealso {
-    background-color: #ffc;
-    border: 1px solid #ff6;
-}
- 
-div.topic {
-    background-color: #eee;
-}
- 
-div.warning {
-    background-color: #ffe4e4;
-    border: 1px solid #f66;
-}
- 
-p.admonition-title {
-    display: inline;
-}
- 
-p.admonition-title:after {
-    content: ":";
-}
-
-pre, tt {
-    font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
-    font-size: 0.85em;
-}
-
-img.screenshot {
-}
-
-tt.descname, tt.descclassname {
-    font-size: 0.95em;
-}
-
-tt.descname {
-    padding-right: 0.08em;
-}
-
-img.screenshot {
-    -moz-box-shadow: 2px 2px 4px #eee;
-    -webkit-box-shadow: 2px 2px 4px #eee;
-    box-shadow: 2px 2px 4px #eee;
-}
-
-table.docutils {
-    border: 1px solid #888;
-    -moz-box-shadow: 2px 2px 4px #eee;
-    -webkit-box-shadow: 2px 2px 4px #eee;
-    box-shadow: 2px 2px 4px #eee;
-}
-
-table.docutils td, table.docutils th {
-    border: 1px solid #888;
-    padding: 0.25em 0.7em;
-}
-
-table.field-list, table.footnote {
-    border: none;
-    -moz-box-shadow: none;
-    -webkit-box-shadow: none;
-    box-shadow: none;
-}
-
-table.footnote {
-    margin: 15px 0;
-    width: 100%;
-    border: 1px solid #eee;
-}
-
-table.field-list th {
-    padding: 0 0.8em 0 0;
-}
-
-table.field-list td {
-    padding: 0;
-}
-
-table.footnote td {
-    padding: 0.5em;
-}
-
-dl {
-    margin: 0;
-    padding: 0;
-}
-
-dl dd {
-    margin-left: 30px;
-}
- 
-pre {
-    padding: 0;
-    margin: 15px -30px;
-    padding: 8px;
-    line-height: 1.3em;
-    padding: 7px 30px;
-    background: #eee;
-    border-radius: 2px;
-    -moz-border-radius: 2px;
-    -webkit-border-radius: 2px;
-}
-
-dl pre {
-    margin-left: -60px;
-    padding-left: 60px;
-}
-
-tt {
-    background-color: #ecf0f3;
-    color: #222;
-    /* padding: 1px 2px; */
-}
-
-tt.xref, a tt {
-    background-color: #FBFBFB;
-}
-
-a:hover tt {
-    background: #EEE;
-}

docs/_themes/kr_small/theme.conf

@@ -1,10 +0,0 @@
-[theme]
-inherit = basic
-stylesheet = flasky.css
-nosidebar = true
-pygments_style = flask_theme_support.FlaskyStyle
-
-[options]
-index_logo = ''
-index_logo_height = 120px
-github_fork = ''

docs/api.rst

@@ -36,7 +36,7 @@ Functions
 ---------
 
 
-.. autofunction:: detect
+.. autofunction:: detect_format
 
 .. autofunction:: import_set
 
@@ -61,4 +61,4 @@ Exceptions
     You're trying to add something that doesn't quite taste right.
 
 
-Now, go start some :ref:`Tablib Development <development>`.
+Now, go start some :ref:`Tablib Development <development>`.

docs/conf.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 # Tablib documentation build configuration file, created by
 # sphinx-quickstart on Tue Oct  5 15:25:21 2010.
@@ -10,22 +9,24 @@
 #
 # All configuration values have a default; values that are commented out
 # serve to show the default.
-
-import sys, os
+import tablib
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
-sys.path.insert(0, os.path.abspath('..'))
-import tablib
+# sys.path.insert(0, os.path.abspath('..'))
 # -- General configuration -----------------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
-#needs_sphinx = '1.0'
+# needs_sphinx = '1.0'
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.viewcode']
+extensions = [
+    'sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.coverage',
+    'sphinx.ext.viewcode', 'sphinx.ext.intersphinx'
+]
+intersphinx_mapping = {'python': ('https://docs.python.org/3', None)}
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -40,17 +41,18 @@ source_suffix = '.rst'
 master_doc = 'index'
 
 # General information about the project.
-project = u'Tablib'
-copyright = u'2011, Kenneth Reitz. Styles (modified) © Armin Ronacher'
+project = 'Tablib'
+copyright = '2019 Jazzband'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
-# The short X.Y version.
-version = '0.9.5'
 # The full version, including alpha/beta/rc tags.
-release = version
+release = tablib.__version__
+# The short X.Y version.
+version = '.'.join(tablib.__version__.split('.')[:2])
+# for example take major/minor
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -81,7 +83,7 @@ add_function_parentheses = True
 #show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'flask_theme_support.FlaskyStyle'
+# pygments_style = ''
 
 # A list of ignored prefixes for module index sorting.
 #modindex_common_prefix = []
@@ -91,7 +93,7 @@ pygments_style = 'flask_theme_support.FlaskyStyle'
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
-html_theme = 'default'
+html_theme = 'alabaster'
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
@@ -120,7 +122,7 @@ html_theme = 'default'
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['static']
+# html_static_path = ['static']
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
@@ -131,7 +133,11 @@ html_static_path = ['static']
 html_use_smartypants = True
 
 # Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
+html_sidebars = {
+    'index':    ['sidebarintro.html', 'sourcelink.html', 'searchbox.html'],
+    '**':       ['sidebarlogo.html', 'localtoc.html', 'relations.html',
+                 'sourcelink.html', 'searchbox.html']
+}
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
@@ -178,24 +184,18 @@ htmlhelp_basename = 'Tablibdoc'
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
 latex_documents = [
-  ('index', 'Tablib.tex', u'Tablib Documentation',
-   u'Kenneth Reitz', 'manual'),
+  ('index', 'Tablib.tex', 'Tablib Documentation',
+   'Jazzband', 'manual'),
 ]
 
 latex_use_modindex = False
 
 latex_elements = {
-    'fontpkg':      r'\usepackage{mathpazo}',
     'papersize':    'a4paper',
     'pointsize':    '12pt',
-    'preamble':     r'\usepackage{krstyle}'
 }
 latex_use_parts = True
 
-latex_additional_files = ['krstyle.sty']
-
-
-
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.
 #latex_logo = None
@@ -225,10 +225,6 @@ latex_additional_files = ['krstyle.sty']
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'tablib', u'Tablib Documentation',
-     [u'Kenneth Reitz'], 1)
+    ('index', 'tablib', 'Tablib Documentation',
+     ['Jazzband'], 1)
 ]
-
-sys.path.append(os.path.abspath('_themes'))
-html_theme_path = ['_themes']
-html_theme = 'kr'

docs/development.rst

@@ -5,14 +5,10 @@ Development
 
 Tablib is under active development, and contributors are welcome.
 
-If you have a feature request, suggestion, or bug report, please open a new issue on GitHub_. To submit patches, please send a pull request on GitHub_.
+If you have a feature request, suggestion, or bug report, please open a new
+issue on GitHub_. To submit patches, please send a pull request on GitHub_.
 
-If you'd like to contribute, there's plenty to do. Here's a short todo list.
-
-    .. include:: ../TODO.rst
-
-
-.. _GitHub: http://github.com/kennethreitz/tablib/
+.. _GitHub: https://github.com/jazzband/tablib/
 
 
 
@@ -42,41 +38,38 @@ Source Control
 --------------
 
 
-Tablib source is controlled with Git_, the lean, mean, distributed source control machine.
+Tablib source is controlled with Git_, the lean, mean, distributed source
+control machine.
 
-The repository is publicly accessable.
+The repository is publicly accessible.
 
-    ``git clone git://github.com/kennethreitz/tablib.git``
-    
-The project is hosted both on **GitHub** and **git.kennethreitz.com**.
-    
-    
-    GitHub: 
-        http://github.com/kennethreitz/tablib
-    "Mirror": 
-        http://git.kennethreitz.com/projects/tablib  
+.. code-block:: console
+
+    git clone git://github.com/jazzband/tablib.git
+
+The project is hosted on **GitHub**.
+
+    GitHub:
+        https://github.com/jazzband/tablib
 
 
 Git Branch Structure
 ++++++++++++++++++++
 
-Feature / Hotfix / Release branches follow a `Successful Git Branching Model`_ . Git-flow_ is a great tool for managing the repository. I highly recommend it.
+Feature / Hotfix / Release branches follow a `Successful Git Branching Model`_ .
+Git-flow_ is a great tool for managing the repository. I highly recommend it.
 
-``develop``
-    The "next release" branch. Likely unstable.
 ``master``
     Current production release (|version|) on PyPi.
-``gh-pages``
-    Current release of http://tablib.org.
 
 Each release is tagged.
 
-When submitting patches, please place your feature/change in its own branch prior to opening a pull reqeust on GitHub_.
+When submitting patches, please place your feature/change in its own branch prior to opening a pull request on GitHub_.
 
 
-.. _Git: http://git-scm.org
-.. _`Successful Git Branching Model`: http://nvie.com/posts/a-successful-git-branching-model/
-.. _git-flow: http://github.com/nvie/gitflow
+.. _Git: https://git-scm.org
+.. _`Successful Git Branching Model`: https://nvie.com/posts/a-successful-git-branching-model/
+.. _git-flow: https://github.com/nvie/gitflow
 
 
 .. _newformats:
@@ -87,57 +80,66 @@ Adding New Formats
 
 Tablib welcomes new format additions! Format suggestions include:
 
-* Tab Separated Values
 * MySQL Dump
-* HTML Table
 
 
 Coding by Convention
 ++++++++++++++++++++
 
-Tablib features a micro-framework for adding format support. The easiest way to understand it is to use it. So, let's define our own format, named *xxx*.
+Tablib features a micro-framework for adding format support.
+The easiest way to understand it is to use it.
+So, let's define our own format, named *xxx*.
 
-1. Write a new format interface.
+From version 1.0, Tablib formats are class-based and can be dynamically
+registered.
 
-    :class:`tablib.core` follows a simple pattern for automatically utilizing your format throughout Tablib. Function names are crucial.
-    
-    Example **tablib/formats/_xxx.py**: ::
+1. Write your custom format class::
 
+    class MyXXXFormatClass:
         title = 'xxx'
-    
-        def export_set(dset):
+
+        @classmethod
+        def export_set(cls, dset):
             ....
             # returns string representation of given dataset
-    
-        def export_book(dbook):
+
+        @classmethod
+        def export_book(cls, dbook):
             ....
             # returns string representation of given databook
-        
-        def import_set(dset, in_stream):
+
+        @classmethod
+        def import_set(cls, dset, in_stream):
             ...
             # populates given Dataset with given datastream
-    
-        def import_book(dbook, in_stream):
+
+        @classmethod
+        def import_book(cls, dbook, in_stream):
             ...
             # returns Databook instance
-    
-        def detect(stream):
+
+        @classmethod
+        def detect(cls, stream):
             ...
             # returns True if given stream is parsable as xxx
 
-.. admonition:: Excluding Support
+   .. admonition:: Excluding Support
 
+       If the format excludes support for an import/export mechanism (*e.g.* 
+       :class:`csv <tablib.Dataset.csv>` excludes 
+       :class:`Databook <tablib.Databook>` support),
+       simply don't define the respective class methods.
+       Appropriate errors will be raised.
 
-    If the format excludes support for an import/export mechanism (*eg.* :class:`csv <tablib.Dataset.csv>` excludes :class:`Databook <tablib.Databook>` support), simply don't define the respective functions. Appropriate errors will be raised.
+2. Register your class::
 
-2. 
+    from tablib.formats import registry
 
-    Add your new format module to the :class:`tablib.formats.avalable` tuple.
+    registry.register('xxx', MyXXXFormatClass())
 
-3.
-    Add a mock property to the :class:`Dataset <tablib.Dataset>` class with verbose `reStructured Text`_ docstring. This alleviates IDE confusion, and allows for pretty auto-generated Sphinx_ documentation.
-
-4. Write respective :ref:`tests <testing>`.
+3. From then on, you should be able to use your new custom format as if it were
+a built-in Tablib format, e.g. using ``dataset.export('xxx')`` will use the 
+``MyXXXFormatClass.export_set`` method.
 
 .. _testing:
 
@@ -145,49 +147,32 @@ Tablib features a micro-framework for adding format support. The easiest way to
 Testing Tablib
 --------------
 
-Testing is crucial to Tablib's stability. This stable project is used in production by many companies and developers, so it is important to be certain that every version released is fully operational. When developing a new feature for Tablib, be sure to write proper tests for it as well.
+Testing is crucial to Tablib's stability.
+This stable project is used in production by many companies and developers,
+so it is important to be certain that every version released is fully operational.
+When developing a new feature for Tablib, be sure to write proper tests for it as well.
 
-When developing a feature for Tablib, the easiest way to test your changes for potential issues is to simply run the test suite directly. ::
+When developing a feature for Tablib,
+the easiest way to test your changes for potential issues is to simply run the test suite directly.
 
-	$ ./test_tablib.py
+.. code-block:: console
 
-
-`Hudson CI`_, amongst other tools, supports Java's xUnit testing report format. Nose_ allows us to generate our own xUnit reports. 
-
-Installing nose is simple. ::
-
-	$ pip install nose
-
-Once installed, we can generate our xUnit report with a single command. ::
-
-	$ nosetests test_tablib.py --with-xunit
-
-This will generate a **nosetests.xml** file, which can then be analyzed.
-
-.. _Nose: http://somethingaboutorange.com/mrl/projects/nose/
-
-
-
-.. _hudson:
+    $ tox
 
 ----------------------
 Continuous Integration
 ----------------------
 
-Every commit made to the **develop** branch is automatically tested and inspected upon receipt with `Hudson CI`_. If you have access to the main repository and broke the build, you will receive an email accordingly. 
+Every pull request is automatically tested and inspected upon receipt with `GitHub Actions`_.
+If you broke the build, you will receive an email accordingly.
 
 Anyone may view the build status and history at any time.
 
-    http://ci.kennethreitz.com/
-
-
-If you are trustworthy and plan to contribute to tablib on a regular basis, please contact `Kenneth Reitz`_ to get an account on the Hudson Server. 
-
+    https://github.com/jazzband/tablib/actions
 
 Additional reports will also be included here in the future, including :pep:`8` checks and stress reports for extremely large datasets.
 
-.. _`Hudson CI`: http://hudson.dev.java.net
-.. _`Kenneth Reitz`: http://kennethreitz.com/contact-me/
+.. _`GitHub Actions`: https://github.com/jazzband/tablib/actions
 
 
 .. _docs:
@@ -196,51 +181,34 @@ Additional reports will also be included here in the future, including :pep:`8`
 Building the Docs
 -----------------
 
-Documentation is written in the powerful, flexible, and standard Python documentation format, `reStructured Text`_. 
-Documentation builds are powered by the powerful Pocoo project, Sphinx_. The :ref:`API Documentation <api>` is mostly documented inline throughout the module.
+Documentation is written in the powerful, flexible,
+and standard Python documentation format, `reStructured Text`_.
+Documentation builds are powered by the powerful Pocoo project, Sphinx_.
+The :ref:`API Documentation <api>` is mostly documented inline throughout the module.
 
-The Docs live in ``tablib/docs``. In order to build them, you will first need to install Sphinx. ::
+The Docs live in ``tablib/docs``.
+In order to build them, you will first need to install Sphinx.
 
-	$ pip install sphinx
-	
+.. code-block:: console
 
-Then, to build an HTML version of the docs, simply run the following from the **docs** directory: ::
-
-	$ make html	
-
-Your ``docs/_build/html`` directory will then contain an HTML representation of the documentation, ready for publication on most web servers.
-
-You can also generate the documentation in **ebpub**, **latex**, **json**, *&c* similarly.
-
-.. admonition:: GitHub Pages
-
-	To push the documentation up to `GitHub Pages`_, you will first need to run `sphinx-to-github`_ against your ``docs/_build/html`` directory. 
-	
-	GitHub Pages are powered by an HTML generation system called Jeckyl_, which is configured to ignore files and folders that begin with "``_``" (*ie.* **_static**).
-	
+    $ pip install sphinx
 
 
+Then, to build an HTML version of the docs, simply run the following from the ``docs`` directory:
 
+.. code-block:: console
 
+    $ make html
 
-	 and `sphinx-to-github`_. ::
+Your ``docs/_build/html`` directory will then contain an HTML representation of the documentation,
+ready for publication on most web servers.
 
-	Installing sphinx-to-github is simple. ::
-
-		$ pip install sphinx-to-github
-
-	Running it against the docs is even simpler. ::
-
-		$ sphinx-to-github _build/html
-	
-	Move the resulting files to the **gh-pages** branch of your repository, and push it up to GitHub. 
+You can also generate the documentation in **epub**, **latex**, **json**, *&c* similarly.
 
 .. _`reStructured Text`: http://docutils.sourceforge.net/rst.html
 .. _Sphinx: http://sphinx.pocoo.org
-.. _`GitHub Pages`: http://pages.github.com
-.. _Jeckyl: http://github.com/mojombo/jekyll
-.. _`sphinx-to-github`: http://github.com/michaeljones/sphinx-to-github
+.. _`GitHub Pages`: https://pages.github.com
 
 ----------
 
-Make sure to check out the :ref:`API Documentation <api>`.
+Make sure to check out the :ref:`API Documentation <api>`.

docs/formats.rst

@@ -0,0 +1,247 @@
+.. _formats:
+
+=======
+Formats
+=======
+
+Tablib supports a wide variety of different tabular formats, both for input and
+output. Moreover, you can :ref:`register your own formats <newformats>`.
+
+cli
+===
+
+The ``cli`` format is currently export-only. The exports produce a representation
+table suited to a terminal.
+
+When exporting to a CLI you can pass the table format  with the ``tablefmt``
+parameter, the supported formats are::
+
+    >>> import tabulate
+    >>> list(tabulate._table_formats)
+    ['simple', 'plain', 'grid', 'fancy_grid', 'github', 'pipe', 'orgtbl',
+     'jira', 'presto', 'psql', 'rst', 'mediawiki', 'moinmoin', 'youtrack',
+     'html', 'latex', 'latex_raw', 'latex_booktabs', 'tsv', 'textile']
+
+For example::
+
+    dataset.export("cli", tablefmt="github")
+    dataset.export("cli", tablefmt="grid")
+
+This format is optional, install Tablib with ``pip install "tablib[cli]"`` to
+make the format available.
+
+csv
+===
+
+When you import CSV data, you can specify if the first line of your data source
+is headers with the ``headers`` boolean parameter (defaults to ``True``)::
+
+    import tablib
+
+    tablib.import_set(your_data_stream, format='csv', headers=False)
+
+When exporting with the ``csv`` format, the top row will contain headers, if
+they have been set. Otherwise, the top row will contain the first row of the
+dataset.
+
+When importing a CSV data source or exporting a dataset as CSV, you can pass any
+parameter supported by the :py:func:`csv.reader` and :py:func:`csv.writer`
+functions. For example::
+
+    tablib.import_set(your_data_stream, format='csv', dialect='unix')
+
+    dataset.export('csv', delimiter=' ', quotechar='|')
+
+.. admonition:: Line endings
+
+     Exporting uses \\r\\n line endings by default so, make sure to include
+     ``newline=''`` otherwise you will get a blank line between each row
+     when you open the file in Excel::
+
+         with open('output.csv', 'w', newline='') as f:
+             f.write(dataset.export('csv'))
+
+     If you do not do this, and you export the file on Windows, your
+     CSV file will open in Excel with a blank line between each row.
+
+dbf
+===
+
+Import/export using the dBASE_ format.
+
+.. admonition:: Binary Warning
+
+    The ``dbf`` format contains binary data, so make sure to write in binary
+    mode::
+
+        with open('output.dbf', 'wb') as f:
+            f.write(dataset.export('dbf')
+
+.. _dBASE: https://en.wikipedia.org/wiki/DBase
+
+df (DataFrame)
+==============
+
+Import/export using the pandas_ DataFrame format. This format is optional,
+install Tablib with ``pip install "tablib[pandas]"`` to make the format available.
+
+.. _pandas: https://pandas.pydata.org/
+
+html
+====
+
+The ``html`` format is currently export-only. The exports produce an HTML page
+with the data in a ``<table>``. If headers have been set, they will be used as
+table headers.
+
+This format is optional, install Tablib with ``pip install "tablib[html]"`` to
+make the format available.
+
+jira
+====
+
+The ``jira`` format is currently export-only. Exports format the dataset
+according to the Jira table syntax::
+
+    ||heading 1||heading 2||heading 3||
+    |col A1|col A2|col A3|
+    |col B1|col B2|col B3|
+
+json
+====
+
+Import/export using the JSON_ format. If headers have been set, a JSON list of
+objects will be returned. If no headers have been set, a JSON list of lists
+(rows) will be returned instead.
+
+Import assumes (for now) that headers exist.
+
+.. _JSON: http://json.org/
+
+latex
+=====
+
+Import/export using the LaTeX_ format. This format is export-only.
+If a title has been set, it will be exported as the table caption.
+
+.. _LaTeX: https://www.latex-project.org/
+
+ods
+===
+
+Export data in OpenDocument Spreadsheet format. The ``ods`` format is currently
+export-only.
+
+This format is optional, install Tablib with ``pip install "tablib[ods]"`` to
+make the format available.
+
+.. admonition:: Binary Warning
+
+    :class:`Dataset.ods` contains binary data, so make sure to write in binary mode::
+
+        with open('output.ods', 'wb') as f:
+            f.write(data.ods)
+
+rst
+===
+
+Export data as a reStructuredText_ table representation of a dataset. The
+``rst`` format is export-only.
+
+Exporting returns a simple table if the text in the first column is never
+wrapped, otherwise returns a grid table::
+
+    >>> from tablib import Dataset
+    >>> bits = ((0, 0), (1, 0), (0, 1), (1, 1))
+    >>> data = Dataset()
+    >>> data.headers = ['A', 'B', 'A and B']
+    >>> for a, b in bits:
+    ...     data.append([bool(a), bool(b), bool(a * b)])
+    >>> table = data.export('rst')
+    >>> table.split('\\n') == [
+    ...     '=====  =====  =====',
+    ...     '  A      B    A and',
+    ...     '                B  ',
+    ...     '=====  =====  =====',
+    ...     'False  False  False',
+    ...     'True   False  False',
+    ...     'False  True   False',
+    ...     'True   True   True ',
+    ...     '=====  =====  =====',
+    ... ]
+    True
+
+.. _reStructuredText: http://docutils.sourceforge.net/rst.html
+
+tsv
+===
+
+A variant of the csv_ format with tabulators as fields separators.
+
+xls
+===
+
+Import/export data in Legacy Excel Spreadsheet representation.
+
+This format is optional, install Tablib with ``pip install "tablib[xls]"`` to
+make the format available.
+
+.. note::
+
+    XLS files are limited to a maximum of 65,000 rows. Use xlsx_ to avoid this
+    limitation.
+
+.. admonition:: Binary Warning
+
+    The ``xls`` file format is binary, so make sure to write in binary mode::
+
+        with open('output.xls', 'wb') as f:
+            f.write(data.export('xls'))
+
+xlsx
+====
+
+Import/export data in Excel 07+ Spreadsheet representation.
+
+This format is optional, install Tablib with ``pip install "tablib[xlsx]"`` to
+make the format available.
+
+The ``import_set()`` and ``import_book()`` methods accept keyword
+argument ``read_only``.  If its value is ``True`` (the default), the
+XLSX data source is read lazily.  Lazy reading generally reduces time
+and memory consumption, especially for large spreadsheets.  However,
+it relies on the XLSX data source declaring correct dimensions.  Some
+programs generate XLSX files with incorrect dimensions.  Such files
+may need to be loaded with this optimization turned off by passing
+``read_only=False``.
+
+.. note::
+
+    When reading an ``xlsx`` file containing formulas in its cells, Tablib will
+    read the cell values, not the cell formulas.
+
+.. versionchanged:: 2.0.0
+
+    Reads cell values instead of formulas.
+
+.. admonition:: Binary Warning
+
+    The ``xlsx`` file format is binary, so make sure to write in binary mode::
+
+        with open('output.xlsx', 'wb') as f:
+            f.write(data.export('xlsx'))
+
+yaml
+====
+
+Import/export data in the YAML_ format.
+When exporting, if headers have been set, a YAML list of objects will be
+returned. If no headers have been set, a YAML list of lists (rows) will be
+returned instead.
+
+Import assumes (for now) that headers exist.
+
+This format is optional, install Tablib with ``pip install "tablib[yaml]"`` to
+make the format available.
+
+.. _YAML: https://yaml.org

docs/index.rst

@@ -1,30 +1,82 @@
 .. Tablib documentation master file, created by
    sphinx-quickstart on Tue Oct  5 15:25:21 2010.
    You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
+   contain the root ``toctree`` directive.
 
-Tablib: Pythonic Tabular Datasets 
+Tablib: Pythonic Tabular Datasets
 =================================
 
-Release |version|.
+Release v\ |version|. (:ref:`Installation <install>`)
 
 .. Contents:
-.. 
+..
 .. .. toctree::
 ..    :maxdepth: 2
-.. 
+..
 
 .. Indices and tables
 .. ==================
-.. 
+..
 .. * :ref:`genindex`
 .. * :ref:`modindex`
 .. * :ref:`search`
 
 
-Tablib is an :ref:`MIT Licensed <mit>` format-agnostic tabular dataset library, written in Python. It allows you to import, export, and manipulate tabular data sets. Advanced features include, segregation, dynamic columns, tags & filtering, and seamless format import & export.
+Tablib is an `MIT Licensed <https://mit-license.org/>`_ format-agnostic tabular dataset library, written in Python.
+It allows you to import, export, and manipulate tabular data sets.
+Advanced features include segregation, dynamic columns, tags & filtering,
+and seamless format import & export.
+
+::
+
+   >>> data = tablib.Dataset(headers=['First Name', 'Last Name', 'Age'])
+   >>> for i in [('Kenneth', 'Reitz', 22), ('Bessie', 'Monke', 21)]:
+   ...     data.append(i)
+
+
+   >>> print(data.export('json'))
+   [{"Last Name": "Reitz", "First Name": "Kenneth", "Age": 22}, {"Last Name": "Monke", "First Name": "Bessie", "Age": 21}]
+
+   >>> print(data.export('yaml'))
+   - {Age: 22, First Name: Kenneth, Last Name: Reitz}
+   - {Age: 21, First Name: Bessie, Last Name: Monke}
+
+   >>> data.export('xlsx')
+   <redacted binary data>
+
+   >>> data.export('df')
+     First Name Last Name  Age
+   0    Kenneth     Reitz   22
+   1     Bessie     Monke   21
+
+
+Testimonials
+------------
+
+`National Geographic <https://www.nationalgeographic.com/>`_,
+`Digg, Inc <https://digg.com/>`_,
+`Northrop Grumman <https://www.northropgrumman.com/>`_,
+`Discovery Channel <https://dsc.discovery.com/>`_,
+and `The Sunlight Foundation <https://sunlightfoundation.com/>`_ use Tablib internally.
+
+
+
+**Greg Thorton**
+   Tablib by @kennethreitz saved my life.
+   I had to consolidate like 5 huge poorly maintained lists of domains and data.
+   It was a breeze!
+
+**Dave Coutts**
+   It's turning into one of my most used modules of 2010.
+   You really hit a sweet spot for managing tabular data with a minimal amount of code and effort.
+
+**Joshua Ourisman**
+   Tablib has made it so much easier to deal with the inevitable 'I want an Excel file!' requests from clients...
+
+**Brad Montgomery**
+    I think you nailed the "Python Zen" with tablib.
+    Thanks again for an awesome lib!
 
-I recommend you start with :ref:`Installation <install>`.
 
 User's Guide
 ------------
@@ -46,6 +98,11 @@ This part of the documentation, which is mostly prose, begins with some backgrou
 
    tutorial
 
+.. toctree::
+   :maxdepth: 2
+
+   formats
+
 .. toctree::
    :maxdepth: 2
 
@@ -61,4 +118,4 @@ method, this part of the documentation is for you.
 .. toctree::
    :maxdepth: 2
 
-   api
+   api

docs/install.rst

@@ -1,8 +1,9 @@
 .. _install:
+
 Installation
 ============
 
-This part of the documentation covers the installation of Tablib. The first step to using any software package is getting it properly installed. Please read this section carefully, or you may miss out on some nice  :ref:`speed enhancements <peed-extentions>`.
+This part of the documentation covers the installation of Tablib. The first step to using any software package is getting it properly installed.
 
 
 .. _installing:
@@ -11,68 +12,74 @@ This part of the documentation covers the installation of Tablib. The first step
 Installing Tablib
 -----------------
 
-To install Tablib, it only takes one simple command. ::
+Distribute & Pip
+----------------
 
-	$ pip install tablib
+Of course, the recommended way to install Tablib is with `pip <https://pip.pypa.io>`_:
 
-Or, if you must: ::
+.. code-block:: console
 
-	$ easy_install tablib
-	
-But, you really shouldn't do that. 
+    $ pip install tablib
 
+You can also choose to install more dependencies to have more import/export
+formats available:
+
+.. code-block:: console
+
+    $ pip install "tablib[xlsx]"
+
+Or all possible formats:
+
+.. code-block:: console
+
+    $ pip install "tablib[all]"
+
+which is equivalent to:
+
+.. code-block:: console
+
+    $ pip install "tablib[html, pandas, ods, xls, xlsx, yaml]"
 
 -------------------
 Download the Source
 -------------------
 
-You can also install tablib from source. The latest release (|version|) is available from GitHub.
+You can also install Tablib from source.
+The latest release (|version|) is available from GitHub.
 
 * tarball_
 * zipball_
 
 .. _
-Once you have a copy of the source, you can embed it in your Python package, or install it into your site-packages easily. ::
+
+Once you have a copy of the source,
+you can embed it in your Python package,
+or install it into your site-packages easily.
+
+.. code-block:: console
 
     $ python setup.py install
 
 
 To download the full source history from Git, see :ref:`Source Control <scm>`.
 
-.. _tarball: http://github.com/kennethreitz/tablib/tarball/master
-.. _zipball: http://github.com/kennethreitz/tablib/zipball/master
-
-
-.. _speed-extentions:
-Speed Extentions
-----------------
-
-.. versionadded:: 0.8.5
-
-Tablib is partially dependent on the **pyyaml**, **simplejson**, and **xlwt** modules. To reduce installation issues, fully integrated versions of all required libraries are included in Tablib. 
-
-However, if performance is important to you (and it should be), you can install  **pyyaml** with C extentions from PyPi. ::
-
-	$ pip install PyYAML
-
-If you're using Python 2.5, you should also install the **simplejson** module (pip will do this for you). If you're using Python 2.6+, the built-in **json** module is already optimized and in use. ::
-
-	$ pip install simplejson
-
+.. _tarball: https://github.com/jazzband/tablib/tarball/master
+.. _zipball: https://github.com/jazzband/tablib/zipball/master
 
 
 .. _updates:
+
 Staying Updated
 ---------------
 
-The latest version of Tablib will always be available here: 
+The latest version of Tablib will always be available here:
 
-* PyPi: http://pypi.python.org/pypi/tablib/
-* GitHub: http://github.com/kennethreitz/tablib/
+* PyPI: https://pypi.org/project/tablib/
+* GitHub: https://github.com/jazzband/tablib/
 
-When a new version is available, upgrading is simple. ::
+When a new version is available, upgrading is simple::
 
-	$ pip install tablib --upgrade
+    $ pip install tablib --upgrade
 
 
-Now, go get a :ref:`Quick Start <quickstart>`.
+Now, go get a :ref:`Quick Start <quickstart>`.

docs/intro.rst

@@ -3,16 +3,18 @@
 Introduction
 ============
 
-This part of the documentation covers all the interfaces of Tablib. 
-Tablib is a format-agnostic tabular dataset library, written in Python. It allows you to Pythonically import, export, and manipulate tabular data sets. Advanced features include, segregation, dynamic columns, tags / filtering, and seamless format import/export.
+This part of the documentation covers all the interfaces of Tablib.
+Tablib is a format-agnostic tabular dataset library, written in Python.
+It allows you to Pythonically import, export, and manipulate tabular data sets.
+Advanced features include segregation, dynamic columns, tags/filtering, and
+seamless format import/export.
 
 
-Philosphy
----------
+Philosophy
+----------
 
 Tablib was developed with a few :pep:`20` idioms in mind.
 
-
 #. Beautiful is better than ugly.
 #. Explicit is better than implicit.
 #. Simple is better than complex.
@@ -21,27 +23,14 @@ Tablib was developed with a few :pep:`20` idioms in mind.
 
 All contributions to Tablib should keep these important rules in mind.
 
-.. _mit:
-
-MIT License
------------
-
-A large number of open source projects you find today are `GPL Licensed`_. While the GPL has its time and place, it should most certainly not be your go-to license for your next open source project. 
-
-A project that is released as GPL cannot be used in any commercial product without the product itself also being offered as open source. The MIT and BSD licenses are great alternatives to the GPL that allow your open-source software to be used in proprietary, closed-source software. 
-
-Tablib is released under terms of `The MIT License`_.
-
-.. _`GPL Licensed`: http://www.opensource.org/licenses/gpl-license.php
-.. _`The MIT License`: http://www.opensource.org/licenses/mit-license.php
-
-
 .. _license:
 
 Tablib License
 --------------
 
-Copyright (c) 2011 Kenneth Reitz.
+Tablib is released under terms of `The MIT License`_.
+
+Copyright 2017 Kenneth Reitz
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -61,24 +50,14 @@ 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.
 
+.. _`The MIT License`: https://opensource.org/licenses/mit-license.php
 
 .. _pythonsupport:
 
 Pythons Supported
 -----------------
 
-At this time, the following Python platforms are officially supported: 
+Python 3.6+ is officially supported.
 
-* cPython 2.5
-* cPython 2.6
-* cPython 2.7
-* cPython 3.1
-* cPython 3.2
-* PyPy-c 1.4
+Now, go :ref:`install Tablib <install>`.
 
-Support for other Pythons will be rolled out soon.
-
-
-
-
-Now, go :ref:`Install Tablib <install>`.

docs/tutorial.rst

@@ -5,10 +5,10 @@ Quickstart
 ==========
 
 
-.. module:: tablib
-
-
-Eager to get started? This page gives a good introduction in how to get started with Tablib. This assumes you already have Tablib installed. If you do not, head over to the :ref:`Installation <install>` section.
+Eager to get started?
+This page gives a good introduction in how to get started with Tablib.
+This assumes you already have Tablib installed.
+If you do not, head over to the :ref:`Installation <install>` section.
 
 First, make sure that:
 
@@ -16,7 +16,7 @@ First, make sure that:
 * Tablib is :ref:`up-to-date <updates>`
 
 
-Lets gets started with some simple use cases and examples.
+Let's get started with some simple use cases and examples.
 
 
 
@@ -30,12 +30,13 @@ A :class:`Dataset <tablib.Dataset>` is nothing more than what its name implies
 Creating your own instance of the :class:`tablib.Dataset` object is simple. ::
 
     data = tablib.Dataset()
-    
+
 You can now start filling this :class:`Dataset <tablib.Dataset>` object with data.
 
 .. admonition:: Example Context
-     
-     From here on out, if you see ``data``, assume that it's a fresh :class:`Dataset <tablib.Dataset>` object.
+
+    From here on out, if you see ``data``, assume that it's a fresh
+    :class:`Dataset <tablib.Dataset>` object.
 
 
 
@@ -52,11 +53,11 @@ Let's say you want to collect a simple list of names. ::
     for name in names:
         # split name appropriately
         fname, lname = name.split()
-        
+
         # add names to Dataset
         data.append([fname, lname])
 
-You can get a nice, Pythonic view of the dataset at any time with :class:`Dataset.dict`.
+You can get a nice, Pythonic view of the dataset at any time with :class:`Dataset.dict`::
 
     >>> data.dict
     [('Kenneth', 'Reitz'), ('Bessie', 'Monke')]
@@ -68,35 +69,55 @@ Adding Headers
 --------------
 
 
-It's time enhance our :class:`Dataset` by giving our columns some titles. To do so, set :class:`Dataset.headers`. ::
+It's time to enhance our :class:`Dataset` by giving our columns some titles.
+To do so, set :class:`Dataset.headers`. ::
 
     data.headers = ['First Name', 'Last Name']
 
 Now our data looks a little different. ::
 
     >>> data.dict
-    [{'Last Name': 'Reitz', 'First Name': 'Kenneth'}, {'Last Name': 'Monke', 'First Name': 'Bessie'}]
-    
+    [{'Last Name': 'Reitz', 'First Name': 'Kenneth'},
+     {'Last Name': 'Monke', 'First Name': 'Bessie'}]
+
 
 
 
 --------------
-Adding Columns 
+Adding Columns
 --------------
 
 
 Now that we have a basic :class:`Dataset` in place, let's add a column of **ages** to it. ::
 
-    data.append(col=[22, 20], header='Age')
-    
+    data.append_col([22, 20], header='Age')
+
 Let's view the data now. ::
 
     >>> data.dict
-    [{'Last Name': 'Reitz', 'First Name': 'Kenneth', 'Age': 22}, {'Last Name': 'Monke', 'First Name': 'Bessie', 'Age': 20}]
+    [{'Last Name': 'Reitz', 'First Name': 'Kenneth', 'Age': 22},
+     {'Last Name': 'Monke', 'First Name': 'Bessie', 'Age': 20}]
 
 It's that easy.
 
 
+--------------
+Importing Data
+--------------
+Creating a :class:`tablib.Dataset` object by importing a pre-existing file is simple. ::
+
+    with open('data.csv', 'r') as fh:
+        imported_data = Dataset().load(fh)
+
+This detects what sort of data is being passed in, and uses an appropriate formatter to do the import. So you can import from a variety of different file types.
+
+.. admonition:: Source without headers
+
+    When the format is :class:`csv <Dataset.csv>`, :class:`tsv <Dataset.tsv>`, :class:`dbf <Dataset.dbf>`, :class:`xls <Dataset.xls>` or :class:`xlsx <Dataset.xlsx>`, and the data source does not have headers, the import should be done as follows ::
+
+    with open('data.csv', 'r') as fh:
+        imported_data = Dataset().load(fh, headers=False)
+
 --------------
 Exporting Data
 --------------
@@ -105,28 +126,36 @@ Tablib's killer feature is the ability to export your :class:`Dataset` objects i
 
 **Comma-Separated Values** ::
 
-    >>> data.csv
-    Last Name,First Name,Age 
-    Reitz,Kenneth,22 
+    >>> data.export('csv')
+    Last Name,First Name,Age
+    Reitz,Kenneth,22
     Monke,Bessie,20
 
 **JavaScript Object Notation** ::
 
-    >>> data.json
+    >>> data.export('json')
     [{"Last Name": "Reitz", "First Name": "Kenneth", "Age": 22}, {"Last Name": "Monke", "First Name": "Bessie", "Age": 20}]
 
 
 **YAML Ain't Markup Language** ::
 
-    >>> data.yaml
+    >>> data.export('yaml')
     - {Age: 22, First Name: Kenneth, Last Name: Reitz}
     - {Age: 20, First Name: Bessie, Last Name: Monke}
-    
+
 
 **Microsoft Excel** ::
 
-    >>> data.xls
-    <censored binary data>
+    >>> data.export('xls')
+    <redacted binary data>
+
+
+**Pandas DataFrame** ::
+
+    >>> data.export('df')
+      First Name Last Name  Age
+    0    Kenneth     Reitz   22
+    1     Bessie     Monke   21
 
 
 ------------------------
@@ -140,12 +169,20 @@ You can slice and dice your data, just like a standard Python list. ::
     ('Kenneth', 'Reitz', 22)
 
 
-If we had a set of data consisting of thousands of rows, it could be useful to get a list of values in a column.
+If we had a set of data consisting of thousands of rows,
+it could be useful to get a list of values in a column.
 To do so, we access the :class:`Dataset` as if it were a standard Python dictionary.  ::
 
     >>> data['First Name']
     ['Kenneth', 'Bessie']
 
+You can also access the column using its index. ::
+
+    >>> data.headers
+    ['Last Name', 'First Name', 'Age']
+    >>> data.get_col(1)
+    ['Kenneth', 'Bessie']
+
 Let's find the average age. ::
 
     >>> ages = data['Age']
@@ -158,11 +195,11 @@ Let's find the average age. ::
 Removing Rows & Columns
 -----------------------
 
-It's easier than you could imagine. ::
+It's easier than you could imagine. Delete a column::
 
     >>> del data['Col Name']
 
-::
+Delete a range of rows::
 
     >>> del data[0:12]
 
@@ -171,8 +208,7 @@ It's easier than you could imagine. ::
 Advanced Usage
 ==============
 
-
-This part of the documentation services to give you an idea that are otherwise hard to extract from the :ref:`API Documentation <api>`
+This part of the documentation services to give you an idea that are otherwise hard to extract from the :ref:`API Documentation <api>`.
 
 And now for something completely different.
 
@@ -185,21 +221,23 @@ Dynamic Columns
 
 .. versionadded:: 0.8.3
 
-Thanks to Josh Ourisman, Tablib now supports adding dynamic columns. A dynamic column is a single callable object (*ie.* a function).
+Thanks to Josh Ourisman, Tablib now supports adding dynamic columns.
+A dynamic column is a single callable object (*e.g.* a function).
 
-Let's add a dynamic column to our :class:`Dataset` object. In this example, we have a function that generates a random grade for our students. ::
+Let's add a dynamic column to our :class:`Dataset` object.
+In this example, we have a function that generates a random grade for our students. ::
 
     import random
-    
+
     def random_grade(row):
         """Returns a random integer for entry."""
         return (random.randint(60,100)/100.0)
-    
-    data.append(col=[random_grade], header='Grade')
+
+    data.append_col(random_grade, header='Grade')
 
 Let's have a look at our data. ::
 
-    >>> data.yaml
+    >>> data.export('yaml')
     - {Age: 22, First Name: Kenneth, Grade: 0.6, Last Name: Reitz}
     - {Age: 20, First Name: Bessie, Grade: 0.75, Last Name: Monke}
 
@@ -209,7 +247,8 @@ Let's remove that column.  ::
     >>> del data['Grade']
 
 
-When you add a dynamic column, the first argument that is passed in to the given callable is the current data row. You can use this to perform calculations against your data row. 
+When you add a dynamic column, the first argument that is passed in to the given callable is the current data row.
+You can use this to perform calculations against your data row.
 
 For example, we can use the data available in the row to guess the gender of a student. ::
 
@@ -217,9 +256,9 @@ For example, we can use the data available in the row to guess the gender of a s
         """Calculates gender of given student data row."""
         m_names = ('Kenneth', 'Mike', 'Yuri')
         f_names = ('Bessie', 'Samantha', 'Heather')
-        
+
         name = row[0]
-        
+
         if name in m_names:
             return 'Male'
         elif name in f_names:
@@ -229,7 +268,7 @@ For example, we can use the data available in the row to guess the gender of a s
 
 Adding this function to our dataset as a dynamic column would result in: ::
 
-    >>> data.yaml
+    >>> data.export('yaml')
     - {Age: 22, First Name: Kenneth, Gender: Male, Last Name: Reitz}
     - {Age: 20, First Name: Bessie, Gender: Female, Last Name: Monke}
 
@@ -243,9 +282,11 @@ Filtering Datasets with Tags
 .. versionadded:: 0.9.0
 
 
-When constructing a :class:`Dataset` object, you can add tags to rows by specifying the ``tags`` parameter. 
-This allows you to filter your :class:`Dataset` later. This can be useful so separate rows of data based on 
-arbitrary criteria (*e.g.* origin) that you don't want to include in your :class:`Dataset`.
+When constructing a :class:`Dataset` object,
+you can add tags to rows by specifying the ``tags`` parameter.
+This allows you to filter your :class:`Dataset` later.
+This can be useful to separate rows of data based on arbitrary criteria
+(*e.g.* origin) that you don't want to include in your :class:`Dataset`.
 
 Let's tag some students. ::
 
@@ -253,51 +294,72 @@ Let's tag some students. ::
 
     students.headers = ['first', 'last']
 
-    students.append(['Kenneth', 'Reitz'], tags=['male', 'technical'])
-    students.append(['Bessie', 'Monke'], tags=['female', 'creative'])
+    students.rpush(['Kenneth', 'Reitz'], tags=['male', 'technical'])
+    students.rpush(['Daniel', 'Dupont'], tags=['male', 'creative' ])
+    students.rpush(['Bessie', 'Monke'], tags=['female', 'creative'])
 
-Now that we have extra meta-data on our rows, we can use easily filter our :class:`Dataset`. Let's just see Male students. ::
+Now that we have extra meta-data on our rows, we can easily filter our :class:`Dataset`. Let's just see Female students. ::
 
+    >>> students.filter(['female']).yaml
+    - {first: Bessie, Last: Monke}
 
-    >>> data.filter(['male']).yaml
-    - {first: Kenneth, Last: Reitz}
+By default, when you pass a list of tags you get filter type or. :: 
+
+    >>> students.filter(['female', 'creative']).yaml
+    - {first: Daniel, Last: Dupont}
+    - {first: Bessie, Last: Monke}
+
+Using chaining you can get a filter type and. ::
+
+    >>> students.filter(['female']).filter(['creative']).yaml
+    - {first: Bessie, Last: Monke}
 
 It's that simple. The original :class:`Dataset` is untouched.
 
+Open an Excel Workbook and read first sheet
+-------------------------------------------
+
+Open an Excel 2007 and later workbook with a single sheet (or a workbook with multiple sheets but you just want the first sheet). ::
+
+    data = tablib.Dataset()
+    with open('my_excel_file.xlsx', 'rb') as fh:
+        data.load(fh, 'xlsx')
+    print(data)
 
 Excel Workbook With Multiple Sheets
------------------------------------- 
+------------------------------------
 
-When dealing with a large number of :class:`Datasets <Dataset>` in spreadsheet format, it's quite common to group multiple spreadsheets into a single Excel file, known as a Workbook. Tablib makes it extremely easy to build workbooks with the handy, :class:`Databook` class.
- 
+When dealing with a large number of :class:`Datasets <Dataset>` in spreadsheet format,
+it's quite common to group multiple spreadsheets into a single Excel file, known as a Workbook.
+Tablib makes it extremely easy to build workbooks with the handy :class:`Databook` class.
 
-Let's say we have 3 different :class:`Datasets <Dataset>`. All we have to do is add then to a :class:`Databook` object... ::
+Let's say we have 3 different :class:`Datasets <Dataset>`.
+All we have to do is add them to a :class:`Databook` object... ::
 
-    book = tablib.Databook([data1, data2, data3])
+    book = tablib.Databook((data1, data2, data3))
 
 ... and export to Excel just like :class:`Datasets <Dataset>`. ::
 
     with open('students.xls', 'wb') as f:
-        f.write(book.xls)
+        f.write(book.export('xls'))
 
-The resulting **students.xls** file will contain a separate spreadsheet for each :class:`Dataset` object in the :class:`Databook`.
+The resulting ``students.xls`` file will contain a separate spreadsheet for each :class:`Dataset` object in the :class:`Databook`.
 
 .. admonition:: Binary Warning
 
     Make sure to open the output file in binary mode.
 
 
-.. _seperators:
+.. _separators:
 
 ----------
-Seperators
+Separators
 ----------
 
 .. versionadded:: 0.8.2
 
-When, it's often useful to create a blank row containing information on the upcoming data. So, 
-
-
+When constructing a spreadsheet,
+it's often useful to create a blank row containing information on the upcoming data. So,
 
 ::
 
@@ -305,33 +367,33 @@ When, it's often useful to create a blank row containing information on the upco
         ('11/24/09', 'Math 101 Mid-term Exam', 56.),
         ('05/24/10', 'Math 101 Final Exam', 62.)
     ]
-    
+
     suzie_tests = [
         ('11/24/09', 'Math 101 Mid-term Exam', 56.),
         ('05/24/10', 'Math 101 Final Exam', 62.)
     ]
-    
+
     # Create new dataset
     tests = tablib.Dataset()
     tests.headers = ['Date', 'Test Name', 'Grade']
 
     # Daniel's Tests
-    tests.append_seperator('Daniel\'s Scores')
+    tests.append_separator('Daniel\'s Scores')
 
     for test_row in daniel_tests:
        tests.append(test_row)
 
     # Susie's Tests
-    tests.append_seperator('Susie\'s Scores')
+    tests.append_separator('Susie\'s Scores')
 
     for test_row in suzie_tests:
        tests.append(test_row)
 
     # Write spreadsheet to disk
     with open('grades.xls', 'wb') as f:
-        f.write(tests.xls)
+        f.write(tests.export('xls'))
 
-The resulting **tests.xls** will have the following layout: 
+The resulting **tests.xls** will have the following layout:
 
 
     Daniel's Scores:
@@ -347,7 +409,7 @@ The resulting **tests.xls** will have the following layout:
 .. admonition:: Format Support
 
     At this time, only :class:`Excel <Dataset.xls>` output supports separators.
-    
+
 ----
 
 Now, go check out the :ref:`API Documentation <api>` or begin :ref:`Tablib Development <development>`.

fabfile.py

@@ -1,17 +0,0 @@
-import os
-from fabric.api import *
-
-
-def scrub():
-    """ Death to the bytecode! """
-    local('rm -fr dist build')
-    local("find . -name \"*.pyc\" -exec rm '{}' ';'")
-
-def docs():
-    """Build docs."""
-    os.system('make dirhtml')
-    os.chdir('_build/dirhtml')
-    os.system('sphinxtogithub .')
-    os.system('git add -A')
-    os.system('git commit -m \'documentation update\'')
-    os.system('git push origin gh-pages')

pyproject.toml

@@ -0,0 +1,2 @@
+[tool.isort]
+profile = "black"

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+norecursedirs = .git .*
+addopts = -rsxX --showlocals --tb=native --cov=tablib --cov=tests --cov-report xml --cov-report term --cov-report html

reqs.txt

@@ -1,3 +0,0 @@
-xlwt
-simplejson
-PyYAML

setup.py

@@ -1,53 +1,52 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 
-import os
-import sys
-
-from distutils.core import setup
-
-
-def publish():
-    """Publish to PyPi"""
-    os.system("python setup.py sdist upload")
-
-if sys.argv[-1] == "publish":
-    publish()
-    sys.exit()
-
-required = []
-
-if sys.version_info[:2] < (2,6):
-    required.append('simplejson')
+from setuptools import find_packages, setup
 
 setup(
     name='tablib',
-    version='0.9.5',
+    use_scm_version={
+        'write_to': 'src/tablib/_version.py',
+    },
+    setup_requires=['setuptools_scm'],
     description='Format agnostic tabular data library (XLS, JSON, YAML, CSV)',
-    long_description=open('README.rst').read() + '\n\n' +
-                     open('HISTORY.rst').read(),
+    long_description=(
+        open('README.md').read() + '\n\n' + open('HISTORY.md').read()
+    ),
+    long_description_content_type="text/markdown",
     author='Kenneth Reitz',
-    author_email='me@kennethreitz.com',
-    url='http://tablib.org',
-    packages= [
-        'tablib', 'tablib.formats',
-        'tablib.packages',
-        'tablib.packages.xlwt',
-        'tablib.packages.yaml', 
-    ],
-    install_requires=required,
+    author_email='me@kennethreitz.org',
+    maintainer='Jazzband',
+    maintainer_email='roadies@jazzband.co',
+    url='https://tablib.readthedocs.io',
+    project_urls={
+        "Documentation": "https://tablib.readthedocs.io",
+        "Source": "https://github.com/jazzband/tablib",
+    },
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
     license='MIT',
-    classifiers=(
+    classifiers=[
         'Development Status :: 5 - Production/Stable',
         'Intended Audience :: Developers',
         'Natural Language :: English',
         'License :: OSI Approved :: MIT License',
         'Programming Language :: Python',
-        'Programming Language :: Python :: 2.5',
-        'Programming Language :: Python :: 2.6',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3.0',
-        'Programming Language :: Python :: 3.1',
-        'Programming Language :: Python :: 3.2',
-    ),
+        'Programming Language :: Python :: 3 :: Only',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+    ],
+    python_requires='>=3.6',
+    extras_require={
+        'all': ['markuppy', 'odfpy', 'openpyxl>=2.6.0', 'pandas', 'pyyaml', 'tabulate', 'xlrd', 'xlwt'],
+        'cli': ['tabulate'],
+        'html': ['markuppy'],
+        'ods': ['odfpy'],
+        'pandas': ['pandas'],
+        'xls': ['xlrd', 'xlwt'],
+        'xlsx': ['openpyxl>=2.6.0'],
+        'yaml': ['pyyaml'],
+    },
 )

src/tablib/__init__.py

@@ -0,0 +1,19 @@
+""" Tablib. """
+try:
+    # Generated by setuptools-scm.
+    from ._version import version as __version__
+except ImportError:
+    # Some broken installation.
+    __version__ = None
+
+
+from tablib.core import (  # noqa: F401
+    Databook,
+    Dataset,
+    InvalidDatasetType,
+    InvalidDimensions,
+    UnsupportedFormat,
+    detect_format,
+    import_book,
+    import_set,
+)

src/tablib/exceptions.py

@@ -0,0 +1,18 @@
+class InvalidDatasetType(Exception):
+    "Only Datasets can be added to a DataBook"
+
+
+class InvalidDimensions(Exception):
+    "Invalid size"
+
+
+class InvalidDatasetIndex(Exception):
+    "Outside of Dataset size"
+
+
+class HeadersNeeded(Exception):
+    "Header parameter must be given when appending a column in this Dataset."
+
+
+class UnsupportedFormat(NotImplementedError):
+    "Format is not supported"

src/tablib/formats/__init__.py

@@ -0,0 +1,135 @@
+""" Tablib - formats
+"""
+from collections import OrderedDict
+from functools import partialmethod
+from importlib import import_module
+from importlib.util import find_spec
+
+from tablib.exceptions import UnsupportedFormat
+from tablib.utils import normalize_input
+
+from ._csv import CSVFormat
+from ._json import JSONFormat
+from ._tsv import TSVFormat
+
+uninstalled_format_messages = {
+    "cli": {"package_name": "tabulate package", "extras_name": "cli"},
+    "df": {"package_name": "pandas package", "extras_name": "pandas"},
+    "html": {"package_name": "MarkupPy package", "extras_name": "html"},
+    "ods": {"package_name": "odfpy package", "extras_name": "ods"},
+    "xls": {"package_name": "xlrd and xlwt packages", "extras_name": "xls"},
+    "xlsx": {"package_name": "openpyxl package", "extras_name": "xlsx"},
+    "yaml": {"package_name": "pyyaml package", "extras_name": "yaml"},
+}
+
+
+def load_format_class(dotted_path):
+    try:
+        module_path, class_name = dotted_path.rsplit('.', 1)
+        return getattr(import_module(module_path), class_name)
+    except (ValueError, AttributeError) as err:
+        raise ImportError(f"Unable to load format class '{dotted_path}' ({err})")
+
+
+class FormatDescriptorBase:
+    def __init__(self, key, format_or_path):
+        self.key = key
+        self._format_path = None
+        if isinstance(format_or_path, str):
+            self._format = None
+            self._format_path = format_or_path
+        else:
+            self._format = format_or_path
+
+    def ensure_format_loaded(self):
+        if self._format is None:
+            self._format = load_format_class(self._format_path)
+
+
+class ImportExportBookDescriptor(FormatDescriptorBase):
+    def __get__(self, obj, cls, **kwargs):
+        self.ensure_format_loaded()
+        return self._format.export_book(obj, **kwargs)
+
+    def __set__(self, obj, val):
+        self.ensure_format_loaded()
+        return self._format.import_book(obj, normalize_input(val))
+
+
+class ImportExportSetDescriptor(FormatDescriptorBase):
+    def __get__(self, obj, cls, **kwargs):
+        self.ensure_format_loaded()
+        return self._format.export_set(obj, **kwargs)
+
+    def __set__(self, obj, val):
+        self.ensure_format_loaded()
+        return self._format.import_set(obj, normalize_input(val))
+
+
+class Registry:
+    _formats = OrderedDict()
+
+    def register(self, key, format_or_path):
+        from tablib.core import Databook, Dataset
+
+        # Create Databook.<format> read or read/write properties
+        setattr(Databook, key, ImportExportBookDescriptor(key, format_or_path))
+
+        # Create Dataset.<format> read or read/write properties,
+        # and Dataset.get_<format>/set_<format> methods.
+        setattr(Dataset, key, ImportExportSetDescriptor(key, format_or_path))
+        try:
+            setattr(Dataset, 'get_%s' % key, partialmethod(Dataset._get_in_format, key))
+            setattr(Dataset, 'set_%s' % key, partialmethod(Dataset._set_in_format, key))
+        except AttributeError:
+            setattr(Dataset, 'get_%s' % key, partialmethod(Dataset._get_in_format, key))
+
+        self._formats[key] = format_or_path
+
+    def register_builtins(self):
+        # Registration ordering matters for autodetection.
+        self.register('json', JSONFormat())
+        # xlsx before as xls (xlrd) can also read xlsx
+        if find_spec('openpyxl'):
+            self.register('xlsx', 'tablib.formats._xlsx.XLSXFormat')
+        if find_spec('xlrd') and find_spec('xlwt'):
+            self.register('xls', 'tablib.formats._xls.XLSFormat')
+        if find_spec('yaml'):
+            self.register('yaml', 'tablib.formats._yaml.YAMLFormat')
+        self.register('csv', CSVFormat())
+        self.register('tsv', TSVFormat())
+        if find_spec('odf'):
+            self.register('ods', 'tablib.formats._ods.ODSFormat')
+        self.register('dbf', 'tablib.formats._dbf.DBFFormat')
+        if find_spec('MarkupPy'):
+            self.register('html', 'tablib.formats._html.HTMLFormat')
+        self.register('jira', 'tablib.formats._jira.JIRAFormat')
+        self.register('latex', 'tablib.formats._latex.LATEXFormat')
+        if find_spec('pandas'):
+            self.register('df', 'tablib.formats._df.DataFrameFormat')
+        self.register('rst', 'tablib.formats._rst.ReSTFormat')
+        if find_spec('tabulate'):
+            self.register('cli', 'tablib.formats._cli.CLIFormat')
+
+    def formats(self):
+        for key, frm in self._formats.items():
+            if isinstance(frm, str):
+                self._formats[key] = load_format_class(frm)
+            yield self._formats[key]
+
+    def get_format(self, key):
+        if key not in self._formats:
+            if key in uninstalled_format_messages:
+                raise UnsupportedFormat(
+                    "The '{key}' format is not available. You may want to install the "
+                    "{package_name} (or `pip install \"tablib[{extras_name}]\"`).".format(
+                        **uninstalled_format_messages[key], key=key
+                    )
+                )
+            raise UnsupportedFormat("Tablib has no format '%s' or it is not registered." % key)
+        if isinstance(self._formats[key], str):
+            self._formats[key] = load_format_class(self._formats[key])
+        return self._formats[key]
+
+
+registry = Registry()

src/tablib/formats/_cli.py

@@ -0,0 +1,20 @@
+"""Tablib - Command-line Interface table export support.
+
+   Generates a representation for CLI from the dataset.
+   Wrapper for tabulate library.
+"""
+from tabulate import tabulate as Tabulate
+
+
+class CLIFormat:
+    """ Class responsible to export to CLI Format """
+    title = 'cli'
+    DEFAULT_FMT = 'plain'
+
+    @classmethod
+    def export_set(cls, dataset, **kwargs):
+        """Returns CLI representation of a Dataset."""
+        if dataset.headers:
+            kwargs.setdefault('headers', dataset.headers)
+        kwargs.setdefault('tablefmt', cls.DEFAULT_FMT)
+        return Tabulate(dataset, **kwargs)

src/tablib/formats/_csv.py

@@ -0,0 +1,60 @@
+""" Tablib - *SV Support.
+"""
+
+import csv
+from io import StringIO
+
+
+class CSVFormat:
+    title = 'csv'
+    extensions = ('csv',)
+
+    DEFAULT_DELIMITER = ','
+
+    @classmethod
+    def export_stream_set(cls, dataset, **kwargs):
+        """Returns CSV representation of Dataset as file-like."""
+        stream = StringIO()
+
+        kwargs.setdefault('delimiter', cls.DEFAULT_DELIMITER)
+
+        _csv = csv.writer(stream, **kwargs)
+
+        for row in dataset._package(dicts=False):
+            _csv.writerow(row)
+
+        stream.seek(0)
+        return stream
+
+    @classmethod
+    def export_set(cls, dataset, **kwargs):
+        """Returns CSV representation of Dataset."""
+        stream = cls.export_stream_set(dataset, **kwargs)
+        return stream.getvalue()
+
+    @classmethod
+    def import_set(cls, dset, in_stream, headers=True, **kwargs):
+        """Returns dataset from CSV stream."""
+
+        dset.wipe()
+
+        kwargs.setdefault('delimiter', cls.DEFAULT_DELIMITER)
+
+        rows = csv.reader(in_stream, **kwargs)
+        for i, row in enumerate(rows):
+
+            if (i == 0) and (headers):
+                dset.headers = row
+            elif row:
+                if i > 0 and len(row) < dset.width:
+                    row += [''] * (dset.width - len(row))
+                dset.append(row)
+
+    @classmethod
+    def detect(cls, stream, delimiter=None):
+        """Returns True if given stream is valid CSV."""
+        try:
+            csv.Sniffer().sniff(stream.read(1024), delimiters=delimiter or cls.DEFAULT_DELIMITER)
+            return True
+        except Exception:
+            return False

src/tablib/formats/_dbf.py

@@ -0,0 +1,66 @@
+""" Tablib - DBF Support.
+"""
+import io
+import os
+import tempfile
+
+from tablib.packages.dbfpy import dbf, dbfnew
+from tablib.packages.dbfpy import record as dbfrecord
+
+
+class DBFFormat:
+    title = 'dbf'
+    extensions = ('csv',)
+
+    DEFAULT_ENCODING = 'utf-8'
+
+    @classmethod
+    def export_set(cls, dataset):
+        """Returns DBF representation of a Dataset"""
+        new_dbf = dbfnew.dbf_new()
+        temp_file, temp_uri = tempfile.mkstemp()
+
+        # create the appropriate fields based on the contents of the first row
+        first_row = dataset[0]
+        for fieldname, field_value in zip(dataset.headers, first_row):
+            if type(field_value) in [int, float]:
+                new_dbf.add_field(fieldname, 'N', 10, 8)
+            else:
+                new_dbf.add_field(fieldname, 'C', 80)
+
+        new_dbf.write(temp_uri)
+
+        dbf_file = dbf.Dbf(temp_uri, readOnly=0)
+        for row in dataset:
+            record = dbfrecord.DbfRecord(dbf_file)
+            for fieldname, field_value in zip(dataset.headers, row):
+                record[fieldname] = field_value
+            record.store()
+
+        dbf_file.close()
+        dbf_stream = open(temp_uri, 'rb')
+        stream = io.BytesIO(dbf_stream.read())
+        dbf_stream.close()
+        os.close(temp_file)
+        os.remove(temp_uri)
+        return stream.getvalue()
+
+    @classmethod
+    def import_set(cls, dset, in_stream, headers=True):
+        """Returns a dataset from a DBF stream."""
+
+        dset.wipe()
+        _dbf = dbf.Dbf(in_stream)
+        dset.headers = _dbf.fieldNames
+        for record in range(_dbf.recordCount):
+            row = [_dbf[record][f] for f in _dbf.fieldNames]
+            dset.append(row)
+
+    @classmethod
+    def detect(cls, stream):
+        """Returns True if the given stream is valid DBF"""
+        try:
+            _dbf = dbf.Dbf(stream, readOnly=True)
+            return True
+        except Exception:
+            return False

src/tablib/formats/_df.py

@@ -0,0 +1,41 @@
+""" Tablib - DataFrame Support.
+"""
+
+try:
+    from pandas import DataFrame
+except ImportError:
+    DataFrame = None
+
+
+class DataFrameFormat:
+    title = 'df'
+    extensions = ('df',)
+
+    @classmethod
+    def detect(cls, stream):
+        """Returns True if given stream is a DataFrame."""
+        if DataFrame is None:
+            return False
+        elif isinstance(stream, DataFrame):
+            return True
+        try:
+            DataFrame(stream.read())
+            return True
+        except ValueError:
+            return False
+
+    @classmethod
+    def export_set(cls, dset, index=None):
+        """Returns DataFrame representation of DataBook."""
+        if DataFrame is None:
+            raise NotImplementedError(
+                'DataFrame Format requires `pandas` to be installed.'
+                ' Try `pip install "tablib[pandas]"`.')
+        dataframe = DataFrame(dset.dict, columns=dset.headers)
+        return dataframe
+
+    @classmethod
+    def import_set(cls, dset, in_stream):
+        """Returns dataset from DataFrame."""
+        dset.wipe()
+        dset.dict = in_stream.to_dict(orient='records')

src/tablib/formats/_html.py

@@ -0,0 +1,62 @@
+""" Tablib - HTML export support.
+"""
+
+import codecs
+from io import BytesIO
+
+from MarkupPy import markup
+
+
+class HTMLFormat:
+    BOOK_ENDINGS = 'h3'
+
+    title = 'html'
+    extensions = ('html', )
+
+    @classmethod
+    def export_set(cls, dataset):
+        """HTML representation of a Dataset."""
+
+        stream = BytesIO()
+
+        page = markup.page()
+        page.table.open()
+
+        if dataset.headers is not None:
+            new_header = [item if item is not None else '' for item in dataset.headers]
+
+            page.thead.open()
+            headers = markup.oneliner.th(new_header)
+            page.tr(headers)
+            page.thead.close()
+
+        for row in dataset:
+            new_row = [item if item is not None else '' for item in row]
+
+            html_row = markup.oneliner.td(new_row)
+            page.tr(html_row)
+
+        page.table.close()
+
+        # Allow unicode characters in output
+        wrapper = codecs.getwriter("utf8")(stream)
+        wrapper.writelines(str(page))
+
+        return stream.getvalue().decode('utf-8')
+
+    @classmethod
+    def export_book(cls, databook):
+        """HTML representation of a Databook."""
+
+        stream = BytesIO()
+
+        # Allow unicode characters in output
+        wrapper = codecs.getwriter("utf8")(stream)
+
+        for i, dset in enumerate(databook._datasets):
+            title = (dset.title if dset.title else 'Set %s' % (i))
+            wrapper.write(f'<{cls.BOOK_ENDINGS}>{title}</{cls.BOOK_ENDINGS}>\n')
+            wrapper.write(dset.html)
+            wrapper.write('\n')
+
+        return stream.getvalue().decode('utf-8')

src/tablib/formats/_jira.py

@@ -0,0 +1,40 @@
+"""Tablib - Jira table export support.
+
+   Generates a Jira table from the dataset.
+"""
+
+
+class JIRAFormat:
+    title = 'jira'
+
+    @classmethod
+    def export_set(cls, dataset):
+        """Formats the dataset according to the Jira table syntax:
+
+        ||heading 1||heading 2||heading 3||
+        |col A1|col A2|col A3|
+        |col B1|col B2|col B3|
+
+        :param dataset: dataset to serialize
+        :type dataset: tablib.core.Dataset
+        """
+
+        header = cls._get_header(dataset.headers) if dataset.headers else ''
+        body = cls._get_body(dataset)
+        return f'{header}\n{body}' if header else body
+
+    @classmethod
+    def _get_body(cls, dataset):
+        return '\n'.join([cls._serialize_row(row) for row in dataset])
+
+    @classmethod
+    def _get_header(cls, headers):
+        return cls._serialize_row(headers, delimiter='||')
+
+    @classmethod
+    def _serialize_row(cls, row, delimiter='|'):
+        return '{}{}{}'.format(
+            delimiter,
+            delimiter.join([str(item) if item else ' ' for item in row]),
+            delimiter
+        )

src/tablib/formats/_json.py

@@ -0,0 +1,58 @@
+""" Tablib - JSON Support
+"""
+import decimal
+import json
+from uuid import UUID
+
+import tablib
+
+
+def serialize_objects_handler(obj):
+    if isinstance(obj, (decimal.Decimal, UUID)):
+        return str(obj)
+    elif hasattr(obj, 'isoformat'):
+        return obj.isoformat()
+    else:
+        return obj
+
+
+class JSONFormat:
+    title = 'json'
+    extensions = ('json', 'jsn')
+
+    @classmethod
+    def export_set(cls, dataset):
+        """Returns JSON representation of Dataset."""
+        return json.dumps(dataset.dict, default=serialize_objects_handler)
+
+    @classmethod
+    def export_book(cls, databook):
+        """Returns JSON representation of Databook."""
+        return json.dumps(databook._package(), default=serialize_objects_handler)
+
+    @classmethod
+    def import_set(cls, dset, in_stream):
+        """Returns dataset from JSON stream."""
+
+        dset.wipe()
+        dset.dict = json.load(in_stream)
+
+    @classmethod
+    def import_book(cls, dbook, in_stream):
+        """Returns databook from JSON stream."""
+
+        dbook.wipe()
+        for sheet in json.load(in_stream):
+            data = tablib.Dataset()
+            data.title = sheet['title']
+            data.dict = sheet['data']
+            dbook.add_sheet(data)
+
+    @classmethod
+    def detect(cls, stream):
+        """Returns True if given stream is valid JSON."""
+        try:
+            json.load(stream)
+            return True
+        except (TypeError, ValueError):
+            return False

src/tablib/formats/_latex.py

@@ -0,0 +1,132 @@
+"""Tablib - LaTeX table export support.
+
+   Generates a LaTeX booktabs-style table from the dataset.
+"""
+import re
+
+
+class LATEXFormat:
+    title = 'latex'
+    extensions = ('tex',)
+
+    TABLE_TEMPLATE = """\
+%% Note: add \\usepackage{booktabs} to your preamble
+%%
+\\begin{table}[!htbp]
+  \\centering
+  %(CAPTION)s
+  \\begin{tabular}{%(COLSPEC)s}
+    \\toprule
+%(HEADER)s
+    %(MIDRULE)s
+%(BODY)s
+    \\bottomrule
+  \\end{tabular}
+\\end{table}
+"""
+
+    TEX_RESERVED_SYMBOLS_MAP = dict([
+        ('\\', '\\textbackslash{}'),
+        ('{', '\\{'),
+        ('}', '\\}'),
+        ('$', '\\$'),
+        ('&', '\\&'),
+        ('#', '\\#'),
+        ('^', '\\textasciicircum{}'),
+        ('_', '\\_'),
+        ('~', '\\textasciitilde{}'),
+        ('%', '\\%'),
+    ])
+
+    TEX_RESERVED_SYMBOLS_RE = re.compile(
+        '(%s)' % '|'.join(map(re.escape, TEX_RESERVED_SYMBOLS_MAP.keys())))
+
+    @classmethod
+    def export_set(cls, dataset):
+        """Returns LaTeX representation of dataset
+
+        :param dataset: dataset to serialize
+        :type dataset: tablib.core.Dataset
+        """
+
+        caption = '\\caption{%s}' % dataset.title if dataset.title else '%'
+        colspec = cls._colspec(dataset.width)
+        header = cls._serialize_row(dataset.headers) if dataset.headers else ''
+        midrule = cls._midrule(dataset.width)
+        body = '\n'.join([cls._serialize_row(row) for row in dataset])
+        return cls.TABLE_TEMPLATE % dict(CAPTION=caption, COLSPEC=colspec,
+                                     HEADER=header, MIDRULE=midrule, BODY=body)
+
+    @classmethod
+    def _colspec(cls, dataset_width):
+        """Generates the column specification for the LaTeX `tabular` environment
+        based on the dataset width.
+
+        The first column is justified to the left, all further columns are aligned
+        to the right.
+
+        .. note:: This is only a heuristic and most probably has to be fine-tuned
+        post export. Column alignment should depend on the data type, e.g., textual
+        content should usually be aligned to the left while numeric content almost
+        always should be aligned to the right.
+
+        :param dataset_width: width of the dataset
+        """
+
+        spec = 'l'
+        for _ in range(1, dataset_width):
+            spec += 'r'
+        return spec
+
+    @classmethod
+    def _midrule(cls, dataset_width):
+        """Generates the table `midrule`, which may be composed of several
+        `cmidrules`.
+
+        :param dataset_width: width of the dataset to serialize
+        """
+
+        if not dataset_width or dataset_width == 1:
+            return '\\midrule'
+        return ' '.join([cls._cmidrule(colindex, dataset_width) for colindex in
+                         range(1, dataset_width + 1)])
+
+    @classmethod
+    def _cmidrule(cls, colindex, dataset_width):
+        """Generates the `cmidrule` for a single column with appropriate trimming
+        based on the column position.
+
+        :param colindex: Column index
+        :param dataset_width: width of the dataset
+        """
+
+        rule = '\\cmidrule(%s){%d-%d}'
+        if colindex == 1:
+            # Rule of first column is trimmed on the right
+            return rule % ('r', colindex, colindex)
+        if colindex == dataset_width:
+            # Rule of last column is trimmed on the left
+            return rule % ('l', colindex, colindex)
+        # Inner columns are trimmed on the left and right
+        return rule % ('lr', colindex, colindex)
+
+    @classmethod
+    def _serialize_row(cls, row):
+        """Returns string representation of a single row.
+
+        :param row: single dataset row
+        """
+
+        new_row = [cls._escape_tex_reserved_symbols(str(item)) if item else ''
+                   for item in row]
+        return 6 * ' ' + ' & '.join(new_row) + ' \\\\'
+
+    @classmethod
+    def _escape_tex_reserved_symbols(cls, input):
+        """Escapes all TeX reserved symbols ('_', '~', etc.) in a string.
+
+        :param input: String to escape
+        """
+        def replace(match):
+            return cls.TEX_RESERVED_SYMBOLS_MAP[match.group()]
+        return cls.TEX_RESERVED_SYMBOLS_RE.sub(replace, input)

src/tablib/formats/_ods.py

@@ -0,0 +1,105 @@
+""" Tablib - ODF Support.
+"""
+
+from io import BytesIO
+
+from odf import opendocument, style, table, text
+
+bold = style.Style(name="bold", family="paragraph")
+bold.addElement(style.TextProperties(fontweight="bold", fontweightasian="bold", fontweightcomplex="bold"))
+
+
+class ODSFormat:
+    title = 'ods'
+    extensions = ('ods',)
+
+    @classmethod
+    def export_set(cls, dataset):
+        """Returns ODF representation of Dataset."""
+
+        wb = opendocument.OpenDocumentSpreadsheet()
+        wb.automaticstyles.addElement(bold)
+
+        ws = table.Table(name=dataset.title if dataset.title else 'Tablib Dataset')
+        wb.spreadsheet.addElement(ws)
+        cls.dset_sheet(dataset, ws)
+
+        stream = BytesIO()
+        wb.save(stream)
+        return stream.getvalue()
+
+    @classmethod
+    def export_book(cls, databook):
+        """Returns ODF representation of DataBook."""
+
+        wb = opendocument.OpenDocumentSpreadsheet()
+        wb.automaticstyles.addElement(bold)
+
+        for i, dset in enumerate(databook._datasets):
+            ws = table.Table(name=dset.title if dset.title else 'Sheet%s' % (i))
+            wb.spreadsheet.addElement(ws)
+            cls.dset_sheet(dset, ws)
+
+        stream = BytesIO()
+        wb.save(stream)
+        return stream.getvalue()
+
+    @classmethod
+    def dset_sheet(cls, 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
+            odf_row = table.TableRow(stylename=bold, defaultcellstylename='bold')
+            for j, col in enumerate(row):
+                try:
+                    col = str(col, errors='ignore')
+                except TypeError:
+                    # col is already str
+                    pass
+                ws.addElement(table.TableColumn())
+
+                # bold headers
+                if (row_number == 1) and dataset.headers:
+                    odf_row.setAttribute('stylename', bold)
+                    ws.addElement(odf_row)
+                    cell = table.TableCell()
+                    p = text.P()
+                    p.addElement(text.Span(text=col, stylename=bold))
+                    cell.addElement(p)
+                    odf_row.addElement(cell)
+
+                # wrap the rest
+                else:
+                    try:
+                        if '\n' in col:
+                            ws.addElement(odf_row)
+                            cell = table.TableCell()
+                            cell.addElement(text.P(text=col))
+                            odf_row.addElement(cell)
+                        else:
+                            ws.addElement(odf_row)
+                            cell = table.TableCell()
+                            cell.addElement(text.P(text=col))
+                            odf_row.addElement(cell)
+                    except TypeError:
+                        ws.addElement(odf_row)
+                        cell = table.TableCell()
+                        cell.addElement(text.P(text=col))
+                        odf_row.addElement(cell)
+
+    @classmethod
+    def detect(cls, stream):
+        if isinstance(stream, bytes):
+            # load expects a file-like object.
+            stream = BytesIO(stream)
+        try:
+            opendocument.load(stream)
+            return True
+        except Exception:
+            return False

src/tablib/formats/_rst.py

@@ -0,0 +1,265 @@
+""" Tablib - reStructuredText Support
+"""
+
+from itertools import zip_longest
+from statistics import median
+from textwrap import TextWrapper
+
+JUSTIFY_LEFT = 'left'
+JUSTIFY_CENTER = 'center'
+JUSTIFY_RIGHT = 'right'
+JUSTIFY_VALUES = (JUSTIFY_LEFT, JUSTIFY_CENTER, JUSTIFY_RIGHT)
+
+
+def to_str(value):
+    if isinstance(value, bytes):
+        return value.decode('utf-8')
+    return str(value)
+
+
+def _max_word_len(text):
+    """
+    Return the length of the longest word in `text`.
+
+    >>> _max_word_len('Python Module for Tabular Datasets')
+    8
+    """
+    return max([len(word) for word in text.split()], default=0) if text else 0
+
+
+class ReSTFormat:
+    title = 'rst'
+    extensions = ('rst',)
+
+    MAX_TABLE_WIDTH = 80  # Roughly. It may be wider to avoid breaking words.
+
+    @classmethod
+    def _get_column_string_lengths(cls, dataset):
+        """
+        Returns a list of string lengths of each column, and a list of
+        maximum word lengths.
+        """
+        if dataset.headers:
+            column_lengths = [[len(h)] for h in dataset.headers]
+            word_lens = [_max_word_len(h) for h in dataset.headers]
+        else:
+            column_lengths = [[] for _ in range(dataset.width)]
+            word_lens = [0 for _ in range(dataset.width)]
+        for row in dataset.dict:
+            values = iter(row.values() if hasattr(row, 'values') else row)
+            for i, val in enumerate(values):
+                text = to_str(val)
+                column_lengths[i].append(len(text))
+                word_lens[i] = max(word_lens[i], _max_word_len(text))
+        return column_lengths, word_lens
+
+    @classmethod
+    def _row_to_lines(cls, values, widths, wrapper, sep='|', justify=JUSTIFY_LEFT):
+        """
+        Returns a table row of wrapped values as a list of lines
+        """
+        if justify not in JUSTIFY_VALUES:
+            raise ValueError('Value of "justify" must be one of "{}"'.format(
+                '", "'.join(JUSTIFY_VALUES)
+            ))
+        if justify == JUSTIFY_LEFT:
+            just = lambda text, width: text.ljust(width)
+        elif justify == JUSTIFY_CENTER:
+            just = lambda text, width: text.center(width)
+        else:
+            just = lambda text, width: text.rjust(width)
+        lpad = sep + ' ' if sep else ''
+        rpad = ' ' + sep if sep else ''
+        pad = ' ' + sep + ' '
+        cells = []
+        for value, width in zip(values, widths):
+            wrapper.width = width
+            text = to_str(value)
+            cell = wrapper.wrap(text)
+            cells.append(cell)
+        lines = zip_longest(*cells, fillvalue='')
+        lines = (
+            (just(cell_line, widths[i]) for i, cell_line in enumerate(line))
+            for line in lines
+        )
+        lines = [''.join((lpad, pad.join(line), rpad)) for line in lines]
+        return lines
+
+    @classmethod
+    def _get_column_widths(cls, dataset, max_table_width=MAX_TABLE_WIDTH, pad_len=3):
+        """
+        Returns a list of column widths proportional to the median length
+        of the text in their cells.
+        """
+        str_lens, word_lens = cls._get_column_string_lengths(dataset)
+        median_lens = [int(median(lens)) for lens in str_lens]
+        total = sum(median_lens)
+        if total > max_table_width - (pad_len * len(median_lens)):
+            column_widths = (max_table_width * l // total for l in median_lens)
+        else:
+            column_widths = (l for l in median_lens)
+        # Allow for separator and padding:
+        column_widths = (w - pad_len if w > pad_len else w for w in column_widths)
+        # Rather widen table than break words:
+        column_widths = [max(w, l) for w, l in zip(column_widths, word_lens)]
+        return column_widths
+
+    @classmethod
+    def export_set_as_simple_table(cls, dataset, column_widths=None):
+        """
+        Returns reStructuredText grid table representation of dataset.
+        """
+        lines = []
+        wrapper = TextWrapper()
+        if column_widths is None:
+            column_widths = cls._get_column_widths(dataset, pad_len=2)
+        border = '  '.join(['=' * w for w in column_widths])
+
+        lines.append(border)
+        if dataset.headers:
+            lines.extend(cls._row_to_lines(
+                dataset.headers,
+                column_widths,
+                wrapper,
+                sep='',
+                justify=JUSTIFY_CENTER,
+            ))
+            lines.append(border)
+        for row in dataset.dict:
+            values = iter(row.values() if hasattr(row, 'values') else row)
+            lines.extend(cls._row_to_lines(values, column_widths, wrapper, ''))
+        lines.append(border)
+        return '\n'.join(lines)
+
+    @classmethod
+    def export_set_as_grid_table(cls, dataset, column_widths=None):
+        """
+        Returns reStructuredText grid table representation of dataset.
+
+
+        >>> from tablib import Dataset
+        >>> from tablib.formats import registry
+        >>> bits = ((0, 0), (1, 0), (0, 1), (1, 1))
+        >>> data = Dataset()
+        >>> data.headers = ['A', 'B', 'A and B']
+        >>> for a, b in bits:
+        ...     data.append([bool(a), bool(b), bool(a * b)])
+        >>> rst = registry.get_format('rst')
+        >>> print(rst.export_set(data, force_grid=True))
+        +-------+-------+-------+
+        |   A   |   B   | A and |
+        |       |       |   B   |
+        +=======+=======+=======+
+        | False | False | False |
+        +-------+-------+-------+
+        | True  | False | False |
+        +-------+-------+-------+
+        | False | True  | False |
+        +-------+-------+-------+
+        | True  | True  | True  |
+        +-------+-------+-------+
+
+        """
+        lines = []
+        wrapper = TextWrapper()
+        if column_widths is None:
+            column_widths = cls._get_column_widths(dataset)
+        header_sep = '+=' + '=+='.join(['=' * w for w in column_widths]) + '=+'
+        row_sep = '+-' + '-+-'.join(['-' * w for w in column_widths]) + '-+'
+
+        lines.append(row_sep)
+
+        if dataset.headers:
+            lines.extend(cls._row_to_lines(
+                dataset.headers,
+                column_widths,
+                wrapper,
+                justify=JUSTIFY_CENTER,
+            ))
+            lines.append(header_sep)
+        for row in dataset.dict:
+            values = iter(row.values() if hasattr(row, 'values') else row)
+            lines.extend(cls._row_to_lines(values, column_widths, wrapper))
+            lines.append(row_sep)
+        return '\n'.join(lines)
+
+    @classmethod
+    def _use_simple_table(cls, head0, col0, width0):
+        """
+        Use a simple table if the text in the first column is never wrapped
+
+
+        >>> from tablib.formats import registry
+        >>> rst = registry.get_format('rst')
+        >>> rst._use_simple_table('menu', ['egg', 'bacon'], 10)
+        True
+        >>> rst._use_simple_table(None, ['lobster thermidor', 'spam'], 10)
+        False
+
+        """
+        if head0 is not None:
+            head0 = to_str(head0)
+            if len(head0) > width0:
+                return False
+        for cell in col0:
+            cell = to_str(cell)
+            if len(cell) > width0:
+                return False
+        return True
+
+    @classmethod
+    def export_set(cls, dataset, **kwargs):
+        """
+        Returns reStructuredText table representation of dataset.
+
+        Returns a simple table if the text in the first column is never
+        wrapped, otherwise returns a grid table.
+
+
+        >>> from tablib import Dataset
+        >>> bits = ((0, 0), (1, 0), (0, 1), (1, 1))
+        >>> data = Dataset()
+        >>> data.headers = ['A', 'B', 'A and B']
+        >>> for a, b in bits:
+        ...     data.append([bool(a), bool(b), bool(a * b)])
+        >>> table = data.rst
+        >>> table.split('\\n') == [
+        ...     '=====  =====  =====',
+        ...     '  A      B    A and',
+        ...     '                B  ',
+        ...     '=====  =====  =====',
+        ...     'False  False  False',
+        ...     'True   False  False',
+        ...     'False  True   False',
+        ...     'True   True   True ',
+        ...     '=====  =====  =====',
+        ... ]
+        True
+
+        """
+        if not dataset.dict:
+            return ''
+        force_grid = kwargs.get('force_grid', False)
+        max_table_width = kwargs.get('max_table_width', cls.MAX_TABLE_WIDTH)
+        column_widths = cls._get_column_widths(dataset, max_table_width)
+
+        use_simple_table = cls._use_simple_table(
+            dataset.headers[0] if dataset.headers else None,
+            dataset.get_col(0),
+            column_widths[0],
+        )
+        if use_simple_table and not force_grid:
+            return cls.export_set_as_simple_table(dataset, column_widths)
+        else:
+            return cls.export_set_as_grid_table(dataset, column_widths)
+
+    @classmethod
+    def export_book(cls, databook):
+        """
+        reStructuredText representation of a Databook.
+
+        Tables are separated by a blank line. All tables use the grid
+        format.
+        """
+        return '\n\n'.join(cls.export_set(dataset, force_grid=True)
+                           for dataset in databook._datasets)

src/tablib/formats/_tsv.py

@@ -0,0 +1,11 @@
+""" Tablib - TSV (Tab Separated Values) Support.
+"""
+
+from ._csv import CSVFormat
+
+
+class TSVFormat(CSVFormat):
+    title = 'tsv'
+    extensions = ('tsv',)
+
+    DEFAULT_DELIMITER = '\t'

src/tablib/formats/_xls.py

@@ -0,0 +1,147 @@
+""" Tablib - XLS Support.
+"""
+
+from io import BytesIO
+
+import xlrd
+import xlwt
+from xlrd.xldate import xldate_as_datetime
+
+import tablib
+
+# special styles
+wrap = xlwt.easyxf("alignment: wrap on")
+bold = xlwt.easyxf("font: bold on")
+
+
+class XLSFormat:
+    title = 'xls'
+    extensions = ('xls',)
+
+    @classmethod
+    def detect(cls, stream):
+        """Returns True if given stream is a readable excel file."""
+        try:
+            xlrd.open_workbook(file_contents=stream)
+            return True
+        except Exception:
+            pass
+        try:
+            xlrd.open_workbook(file_contents=stream.read())
+            return True
+        except Exception:
+            pass
+        try:
+            xlrd.open_workbook(filename=stream)
+            return True
+        except Exception:
+            return False
+
+    @classmethod
+    def export_set(cls, dataset):
+        """Returns XLS representation of Dataset."""
+
+        wb = xlwt.Workbook(encoding='utf8')
+        ws = wb.add_sheet(dataset.title if dataset.title else 'Tablib Dataset')
+
+        cls.dset_sheet(dataset, ws)
+
+        stream = BytesIO()
+        wb.save(stream)
+        return stream.getvalue()
+
+    @classmethod
+    def export_book(cls, databook):
+        """Returns XLS representation of DataBook."""
+
+        wb = xlwt.Workbook(encoding='utf8')
+
+        for i, dset in enumerate(databook._datasets):
+            ws = wb.add_sheet(dset.title if dset.title else 'Sheet%s' % (i))
+
+            cls.dset_sheet(dset, ws)
+
+        stream = BytesIO()
+        wb.save(stream)
+        return stream.getvalue()
+
+    @classmethod
+    def import_set(cls, dset, in_stream, headers=True):
+        """Returns databook from XLS stream."""
+
+        dset.wipe()
+
+        xls_book = xlrd.open_workbook(file_contents=in_stream.read())
+        sheet = xls_book.sheet_by_index(0)
+
+        dset.title = sheet.name
+
+        def cell_value(value, type_):
+            if type_ == xlrd.XL_CELL_ERROR:
+                return xlrd.error_text_from_code[value]
+            elif type_ == xlrd.XL_CELL_DATE:
+                return xldate_as_datetime(value, xls_book.datemode)
+            return value
+
+        for i in range(sheet.nrows):
+            if i == 0 and headers:
+                dset.headers = sheet.row_values(0)
+            else:
+                dset.append([
+                    cell_value(val, typ)
+                    for val, typ in zip(sheet.row_values(i), sheet.row_types(i))
+                ])
+
+    @classmethod
+    def import_book(cls, dbook, in_stream, headers=True):
+        """Returns databook from XLS stream."""
+
+        dbook.wipe()
+
+        xls_book = xlrd.open_workbook(file_contents=in_stream)
+
+        for sheet in xls_book.sheets():
+            data = tablib.Dataset()
+            data.title = sheet.name
+
+            for i in range(sheet.nrows):
+                if i == 0 and headers:
+                    data.headers = sheet.row_values(0)
+                else:
+                    data.append(sheet.row_values(i))
+
+            dbook.add_sheet(data)
+
+    @classmethod
+    def dset_sheet(cls, 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):
+            for j, col in enumerate(row):
+
+                # bold headers
+                if (i == 0) and dataset.headers:
+                    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.write(i, j, col, bold)
+
+                # wrap the rest
+                else:
+                    try:
+                        if '\n' in col:
+                            ws.write(i, j, col, wrap)
+                        else:
+                            ws.write(i, j, col)
+                    except TypeError:
+                        ws.write(i, j, col)

src/tablib/formats/_xlsx.py

@@ -0,0 +1,143 @@
+""" Tablib - XLSX Support.
+"""
+
+from io import BytesIO
+
+from openpyxl.reader.excel import ExcelReader, load_workbook
+from openpyxl.styles import Alignment, Font
+from openpyxl.utils import get_column_letter
+from openpyxl.workbook import Workbook
+from openpyxl.writer.excel import ExcelWriter
+
+import tablib
+
+
+class XLSXFormat:
+    title = 'xlsx'
+    extensions = ('xlsx',)
+
+    @classmethod
+    def detect(cls, stream):
+        """Returns True if given stream is a readable excel file."""
+        try:
+            # No need to fully load the file, it should be enough to be able to
+            # read the manifest.
+            reader = ExcelReader(stream, read_only=False)
+            reader.read_manifest()
+            return True
+        except Exception:
+            return False
+
+    @classmethod
+    def export_set(cls, dataset, freeze_panes=True):
+        """Returns XLSX representation of Dataset."""
+        wb = Workbook()
+        ws = wb.worksheets[0]
+        ws.title = dataset.title if dataset.title else 'Tablib Dataset'
+
+        cls.dset_sheet(dataset, ws, freeze_panes=freeze_panes)
+
+        stream = BytesIO()
+        wb.save(stream)
+        return stream.getvalue()
+
+    @classmethod
+    def export_book(cls, databook, freeze_panes=True):
+        """Returns XLSX representation of DataBook."""
+
+        wb = Workbook()
+        for sheet in wb.worksheets:
+            wb.remove(sheet)
+        for i, dset in enumerate(databook._datasets):
+            ws = wb.create_sheet()
+            ws.title = dset.title if dset.title else 'Sheet%s' % (i)
+
+            cls.dset_sheet(dset, ws, freeze_panes=freeze_panes)
+
+        stream = BytesIO()
+        wb.save(stream)
+        return stream.getvalue()
+
+    @classmethod
+    def import_set(cls, dset, in_stream, headers=True, read_only=True):
+        """Returns databook from XLS stream."""
+
+        dset.wipe()
+
+        xls_book = load_workbook(in_stream, read_only=read_only, data_only=True)
+        sheet = xls_book.active
+
+        dset.title = sheet.title
+
+        for i, row in enumerate(sheet.rows):
+            row_vals = [c.value for c in row]
+            if (i == 0) and (headers):
+                dset.headers = row_vals
+            else:
+                dset.append(row_vals)
+
+    @classmethod
+    def import_book(cls, dbook, in_stream, headers=True, read_only=True):
+        """Returns databook from XLS stream."""
+
+        dbook.wipe()
+
+        xls_book = load_workbook(in_stream, read_only=read_only, data_only=True)
+
+        for sheet in xls_book.worksheets:
+            data = tablib.Dataset()
+            data.title = sheet.title
+
+            for i, row in enumerate(sheet.rows):
+                row_vals = [c.value for c in row]
+                if (i == 0) and (headers):
+                    data.headers = row_vals
+                else:
+                    if i > 0 and len(row_vals) < data.width:
+                        row_vals += [''] * (data.width - len(row_vals))
+                    data.append(row_vals)
+
+            dbook.add_sheet(data)
+
+    @classmethod
+    def dset_sheet(cls, dataset, ws, freeze_panes=True):
+        """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],))
+
+        bold = Font(bold=True)
+        wrap_text = Alignment(wrap_text=True)
+
+        for i, row in enumerate(_package):
+            row_number = i + 1
+            for j, col in enumerate(row):
+                col_idx = get_column_letter(j + 1)
+                cell = ws[f'{col_idx}{row_number}']
+
+                # bold headers
+                if (row_number == 1) and dataset.headers:
+                    cell.font = bold
+                    if freeze_panes:
+                        #  Export Freeze only after first Line
+                        ws.freeze_panes = 'A2'
+
+                # bold separators
+                elif len(row) < dataset.width:
+                    cell.font = bold
+
+                # wrap the rest
+                else:
+                    try:
+                        str_col_value = str(col)
+                    except TypeError:
+                        str_col_value = ''
+                    if '\n' in str_col_value:
+                        cell.alignment = wrap_text
+
+                try:
+                    cell.value = col
+                except (ValueError, TypeError):
+                    cell.value = str(col)

src/tablib/formats/_yaml.py

@@ -0,0 +1,54 @@
+""" Tablib - YAML Support.
+"""
+
+import yaml
+
+import tablib
+
+
+class YAMLFormat:
+    title = 'yaml'
+    extensions = ('yaml', 'yml')
+
+    @classmethod
+    def export_set(cls, dataset):
+        """Returns YAML representation of Dataset."""
+
+        return yaml.safe_dump(dataset._package(ordered=False), default_flow_style=None)
+
+    @classmethod
+    def export_book(cls, databook):
+        """Returns YAML representation of Databook."""
+        return yaml.safe_dump(databook._package(ordered=False), default_flow_style=None)
+
+    @classmethod
+    def import_set(cls, dset, in_stream):
+        """Returns dataset from YAML stream."""
+
+        dset.wipe()
+        dset.dict = yaml.safe_load(in_stream)
+
+    @classmethod
+    def import_book(cls, dbook, in_stream):
+        """Returns databook from YAML stream."""
+
+        dbook.wipe()
+
+        for sheet in yaml.safe_load(in_stream):
+            data = tablib.Dataset()
+            data.title = sheet['title']
+            data.dict = sheet['data']
+            dbook.add_sheet(data)
+
+    @classmethod
+    def detect(cls, stream):
+        """Returns True if given stream is valid YAML."""
+        try:
+            _yaml = yaml.safe_load(stream)
+            if isinstance(_yaml, (list, tuple, dict)):
+                return True
+            else:
+                return False
+        except (yaml.parser.ParserError, yaml.reader.ReaderError,
+                yaml.scanner.ScannerError):
+            return False

src/tablib/packages/dbfpy/dbf.py

@@ -0,0 +1,297 @@
+#! /usr/bin/env python
+"""DBF accessing helpers.
+
+FIXME: more documentation needed
+
+Examples:
+
+    Create new table, setup structure, add records:
+
+        dbf = Dbf(filename, new=True)
+        dbf.addField(
+            ("NAME", "C", 15),
+            ("SURNAME", "C", 25),
+            ("INITIALS", "C", 10),
+            ("BIRTHDATE", "D"),
+        )
+        for (n, s, i, b) in (
+            ("John", "Miller", "YC", (1980, 10, 11)),
+            ("Andy", "Larkin", "", (1980, 4, 11)),
+        ):
+            rec = dbf.newRecord()
+            rec["NAME"] = n
+            rec["SURNAME"] = s
+            rec["INITIALS"] = i
+            rec["BIRTHDATE"] = b
+            rec.store()
+        dbf.close()
+
+    Open existed dbf, read some data:
+
+        dbf = Dbf(filename, True)
+        for rec in dbf:
+            for fldName in dbf.fieldNames:
+                print('%s:\t %s (%s)' % (fldName, rec[fldName],
+                    type(rec[fldName])))
+            print()
+        dbf.close()
+
+"""
+"""History (most recent first):
+11-feb-2007 [als]   export INVALID_VALUE;
+                    Dbf: added .ignoreErrors, .INVALID_VALUE
+04-jul-2006 [als]   added export declaration
+20-dec-2005 [yc]    removed fromStream and newDbf methods:
+                    use argument of __init__ call must be used instead;
+                    added class fields pointing to the header and
+                    record classes.
+17-dec-2005 [yc]    split to several modules; reimplemented
+13-dec-2005 [yc]    adapted to the changes of the `strutil` module.
+13-sep-2002 [als]   support FoxPro Timestamp datatype
+15-nov-1999 [jjk]   documentation updates, add demo
+24-aug-1998 [jjk]   add some encodeValue methods (not tested), other tweaks
+08-jun-1998 [jjk]   fix problems, add more features
+20-feb-1998 [jjk]   fix problems, add more features
+19-feb-1998 [jjk]   add create/write capabilities
+18-feb-1998 [jjk]   from dbfload.py
+"""
+
+__version__ = "$Revision: 1.7 $"[11:-2]
+__date__ = "$Date: 2007/02/11 09:23:13 $"[7:-2]
+__author__ = "Jeff Kunce <kuncej@mail.conservation.state.mo.us>"
+
+__all__ = ["Dbf"]
+
+from . import header, record
+from .utils import INVALID_VALUE
+
+
+class Dbf:
+    """DBF accessor.
+
+    FIXME:
+        docs and examples needed (dont' forget to tell
+        about problems adding new fields on the fly)
+
+    Implementation notes:
+        ``_new`` field is used to indicate whether this is
+        a new data table. `addField` could be used only for
+        the new tables! If at least one record was appended
+        to the table it's structure couldn't be changed.
+
+    """
+
+    __slots__ = ("name", "header", "stream",
+                 "_changed", "_new", "_ignore_errors")
+
+    HeaderClass = header.DbfHeader
+    RecordClass = record.DbfRecord
+    INVALID_VALUE = INVALID_VALUE
+
+    # initialization and creation helpers
+
+    def __init__(self, f, readOnly=False, new=False, ignoreErrors=False):
+        """Initialize instance.
+
+        Arguments:
+            f:
+                Filename or file-like object.
+            new:
+                True if new data table must be created. Assume
+                data table exists if this argument is False.
+            readOnly:
+                if ``f`` argument is a string file will
+                be opend in read-only mode; in other cases
+                this argument is ignored. This argument is ignored
+                even if ``new`` argument is True.
+            headerObj:
+                `header.DbfHeader` instance or None. If this argument
+                is None, new empty header will be used with the
+                all fields set by default.
+            ignoreErrors:
+                if set, failing field value conversion will return
+                ``INVALID_VALUE`` instead of raising conversion error.
+
+        """
+        if isinstance(f, str):
+            # a filename
+            self.name = f
+            if new:
+                # new table (table file must be
+                # created or opened and truncated)
+                self.stream = open(f, "w+b")
+            else:
+                # table file must exist
+                self.stream = open(f, ("r+b", "rb")[bool(readOnly)])
+        else:
+            # a stream
+            self.name = getattr(f, "name", "")
+            self.stream = f
+        if new:
+            # if this is a new table, header will be empty
+            self.header = self.HeaderClass()
+        else:
+            # or instantiated using stream
+            self.header = self.HeaderClass.fromStream(self.stream)
+        self.ignoreErrors = ignoreErrors
+        self._new = bool(new)
+        self._changed = False
+
+    # properties
+
+    closed = property(lambda self: self.stream.closed)
+    recordCount = property(lambda self: self.header.recordCount)
+    fieldNames = property(
+        lambda self: [_fld.name for _fld in self.header.fields])
+    fieldDefs = property(lambda self: self.header.fields)
+    changed = property(lambda self: self._changed or self.header.changed)
+
+    def ignoreErrors(self, value):
+        """Update `ignoreErrors` flag on the header object and self"""
+        self.header.ignoreErrors = self._ignore_errors = bool(value)
+
+    ignoreErrors = property(
+        lambda self: self._ignore_errors,
+        ignoreErrors,
+        doc="""Error processing mode for DBF field value conversion
+
+        if set, failing field value conversion will return
+        ``INVALID_VALUE`` instead of raising conversion error.
+
+        """)
+
+    # protected methods
+
+    def _fixIndex(self, index):
+        """Return fixed index.
+
+        This method fails if index isn't a numeric object
+        (long or int). Or index isn't in a valid range
+        (less or equal to the number of records in the db).
+
+        If ``index`` is a negative number, it will be
+        treated as a negative indexes for list objects.
+
+        Return:
+            Return value is numeric object maning valid index.
+
+        """
+        if not isinstance(index, int):
+            raise TypeError("Index must be a numeric object")
+        if index < 0:
+            # index from the right side
+            # fix it to the left-side index
+            index += len(self) + 1
+        if index >= len(self):
+            raise IndexError("Record index out of range")
+        return index
+
+    # interface methods
+
+    def close(self):
+        self.flush()
+        self.stream.close()
+
+    def flush(self):
+        """Flush data to the associated stream."""
+        if self.changed:
+            self.header.setCurrentDate()
+            self.header.write(self.stream)
+            self.stream.flush()
+            self._changed = False
+
+    def indexOfFieldName(self, name):
+        """Index of field named ``name``."""
+        # FIXME: move this to header class
+        names = [f.name for f in self.header.fields]
+        return names.index(name.upper())
+
+    def newRecord(self):
+        """Return new record, which belong to this table."""
+        return self.RecordClass(self)
+
+    def append(self, record):
+        """Append ``record`` to the database."""
+        record.index = self.header.recordCount
+        record._write()
+        self.header.recordCount += 1
+        self._changed = True
+        self._new = False
+
+    def addField(self, *defs):
+        """Add field definitions.
+
+        For more information see `header.DbfHeader.addField`.
+
+        """
+        if self._new:
+            self.header.addField(*defs)
+        else:
+            raise TypeError("At least one record was added, "
+                            "structure can't be changed")
+
+    # 'magic' methods (representation and sequence interface)
+
+    def __repr__(self):
+        return "Dbf stream '%s'\n" % self.stream + repr(self.header)
+
+    def __len__(self):
+        """Return number of records."""
+        return self.recordCount
+
+    def __getitem__(self, index):
+        """Return `DbfRecord` instance."""
+        return self.RecordClass.fromStream(self, self._fixIndex(index))
+
+    def __setitem__(self, index, record):
+        """Write `DbfRecord` instance to the stream."""
+        record.index = self._fixIndex(index)
+        record._write()
+        self._changed = True
+        self._new = False
+
+        # def __del__(self):
+        #    """Flush stream upon deletion of the object."""
+        #    self.flush()
+
+
+def demo_read(filename):
+    _dbf = Dbf(filename, True)
+    for _rec in _dbf:
+        print()
+        print(repr(_rec))
+    _dbf.close()
+
+
+def demo_create(filename):
+    _dbf = Dbf(filename, new=True)
+    _dbf.addField(
+        ("NAME", "C", 15),
+        ("SURNAME", "C", 25),
+        ("INITIALS", "C", 10),
+        ("BIRTHDATE", "D"),
+    )
+    for (_n, _s, _i, _b) in (
+            ("John", "Miller", "YC", (1981, 1, 2)),
+            ("Andy", "Larkin", "AL", (1982, 3, 4)),
+            ("Bill", "Clinth", "", (1983, 5, 6)),
+            ("Bobb", "McNail", "", (1984, 7, 8)),
+    ):
+        _rec = _dbf.newRecord()
+        _rec["NAME"] = _n
+        _rec["SURNAME"] = _s
+        _rec["INITIALS"] = _i
+        _rec["BIRTHDATE"] = _b
+        _rec.store()
+    print(repr(_dbf))
+    _dbf.close()
+
+
+if __name__ == '__main__':
+    import sys
+
+    _name = len(sys.argv) > 1 and sys.argv[1] or "county.dbf"
+    demo_create(_name)
+    demo_read(_name)
+
+# vim: set et sw=4 sts=4 :

src/tablib/packages/dbfpy/dbfnew.py

@@ -0,0 +1,183 @@
+#!/usr/bin/python
+""".DBF creation helpers.
+
+Note: this is a legacy interface.  New code should use Dbf class
+    for table creation (see examples in dbf.py)
+
+TODO:
+  - handle Memo fields.
+  - check length of the fields according to the
+    `http://www.clicketyclick.dk/databases/xbase/format/data_types.html`
+
+"""
+"""History (most recent first)
+04-jul-2006 [als]   added export declaration;
+                    updated for dbfpy 2.0
+15-dec-2005 [yc]    define dbf_new.__slots__
+14-dec-2005 [yc]    added vim modeline; retab'd; added doc-strings;
+                    dbf_new now is a new class (inherited from object)
+??-jun-2000 [--]    added by Hans Fiby
+"""
+
+__version__ = "$Revision: 1.4 $"[11:-2]
+__date__ = "$Date: 2006/07/04 08:18:18 $"[7:-2]
+
+__all__ = ["dbf_new"]
+
+from .dbf import *
+from .fields import *
+from .header import *
+from .record import *
+
+
+class _FieldDefinition:
+    """Field definition.
+
+    This is a simple structure, which contains ``name``, ``type``,
+    ``len``, ``dec`` and ``cls`` fields.
+
+    Objects also implement get/setitem magic functions, so fields
+    could be accessed via sequence interface, where 'name' has
+    index 0, 'type' index 1, 'len' index 2, 'dec' index 3 and
+    'cls' could be located at index 4.
+
+    """
+
+    __slots__ = "name", "type", "len", "dec", "cls"
+
+    # WARNING: be attentive - dictionaries are mutable!
+    FLD_TYPES = {
+        # type: (cls, len)
+        "C": (DbfCharacterFieldDef, None),
+        "N": (DbfNumericFieldDef, None),
+        "L": (DbfLogicalFieldDef, 1),
+        # FIXME: support memos
+        # "M": (DbfMemoFieldDef),
+        "D": (DbfDateFieldDef, 8),
+        # FIXME: I'm not sure length should be 14 characters!
+        # but temporary I use it, cuz date is 8 characters
+        # and time 6 (hhmmss)
+        "T": (DbfDateTimeFieldDef, 14),
+    }
+
+    def __init__(self, name, type, len=None, dec=0):
+        _cls, _len = self.FLD_TYPES[type]
+        if _len is None:
+            if len is None:
+                raise ValueError("Field length must be defined")
+            _len = len
+        self.name = name
+        self.type = type
+        self.len = _len
+        self.dec = dec
+        self.cls = _cls
+
+    def getDbfField(self):
+        "Return `DbfFieldDef` instance from the current definition."
+        return self.cls(self.name, self.len, self.dec)
+
+    def appendToHeader(self, dbfh):
+        """Create a `DbfFieldDef` instance and append it to the dbf header.
+
+        Arguments:
+            dbfh: `DbfHeader` instance.
+
+        """
+        _dbff = self.getDbfField()
+        dbfh.addField(_dbff)
+
+
+class dbf_new:
+    """New .DBF creation helper.
+
+    Example Usage:
+
+        dbfn = dbf_new()
+        dbfn.add_field("name",'C',80)
+        dbfn.add_field("price",'N',10,2)
+        dbfn.add_field("date",'D',8)
+        dbfn.write("tst.dbf")
+
+    Note:
+        This module cannot handle Memo-fields,
+        they are special.
+
+    """
+
+    __slots__ = ("fields",)
+
+    FieldDefinitionClass = _FieldDefinition
+
+    def __init__(self):
+        self.fields = []
+
+    def add_field(self, name, typ, len, dec=0):
+        """Add field definition.
+
+        Arguments:
+            name:
+                field name (str object). field name must not
+                contain ASCII NULs and it's length shouldn't
+                exceed 10 characters.
+            typ:
+                type of the field. this must be a single character
+                from the "CNLMDT" set meaning character, numeric,
+                logical, memo, date and date/time respectively.
+            len:
+                length of the field. this argument is used only for
+                the character and numeric fields. all other fields
+                have fixed length.
+                FIXME: use None as a default for this argument?
+            dec:
+                decimal precision. used only for the numric fields.
+
+        """
+        self.fields.append(self.FieldDefinitionClass(name, typ, len, dec))
+
+    def write(self, filename):
+        """Create empty .DBF file using current structure."""
+        _dbfh = DbfHeader()
+        _dbfh.setCurrentDate()
+        for _fldDef in self.fields:
+            _fldDef.appendToHeader(_dbfh)
+
+        _dbfStream = open(filename, "wb")
+        _dbfh.write(_dbfStream)
+        _dbfStream.close()
+
+
+if __name__ == '__main__':
+    # create a new DBF-File
+    dbfn = dbf_new()
+    dbfn.add_field("name", 'C', 80)
+    dbfn.add_field("price", 'N', 10, 2)
+    dbfn.add_field("date", 'D', 8)
+    dbfn.write("tst.dbf")
+    # test new dbf
+    print("*** created tst.dbf: ***")
+    dbft = Dbf('tst.dbf', readOnly=0)
+    print(repr(dbft))
+    # add a record
+    rec = DbfRecord(dbft)
+    rec['name'] = 'something'
+    rec['price'] = 10.5
+    rec['date'] = (2000, 1, 12)
+    rec.store()
+    # add another record
+    rec = DbfRecord(dbft)
+    rec['name'] = 'foo and bar'
+    rec['price'] = 12234
+    rec['date'] = (1992, 7, 15)
+    rec.store()
+
+    # show the records
+    print("*** inserted 2 records into tst.dbf: ***")
+    print(repr(dbft))
+    for i1 in range(len(dbft)):
+        rec = dbft[i1]
+        for fldName in dbft.fieldNames:
+            print('{}:\t {}'.format(fldName, rec[fldName]))
+        print()
+    dbft.close()
+
+# vim: set et sts=4 sw=4 :

src/tablib/packages/dbfpy/fields.py

@@ -0,0 +1,475 @@
+"""DBF fields definitions.
+
+TODO:
+  - make memos work
+"""
+"""History (most recent first):
+26-may-2009 [als]   DbfNumericFieldDef.decodeValue: strip zero bytes
+05-feb-2009 [als]   DbfDateFieldDef.encodeValue: empty arg produces empty date
+16-sep-2008 [als]   DbfNumericFieldDef decoding looks for decimal point
+                    in the value to select float or integer return type
+13-mar-2008 [als]   check field name length in constructor
+11-feb-2007 [als]   handle value conversion errors
+10-feb-2007 [als]   DbfFieldDef: added .rawFromRecord()
+01-dec-2006 [als]   Timestamp columns use None for empty values
+31-oct-2006 [als]   support field types 'F' (float), 'I' (integer)
+                    and 'Y' (currency);
+                    automate export and registration of field classes
+04-jul-2006 [als]   added export declaration
+10-mar-2006 [als]   decode empty values for Date and Logical fields;
+                    show field name in errors
+10-mar-2006 [als]   fix Numeric value decoding: according to spec,
+                    value always is string representation of the number;
+                    ensure that encoded Numeric value fits into the field
+20-dec-2005 [yc]    use field names in upper case
+15-dec-2005 [yc]    field definitions moved from `dbf`.
+"""
+
+__version__ = "$Revision: 1.14 $"[11:-2]
+__date__ = "$Date: 2009/05/26 05:16:51 $"[7:-2]
+
+__all__ = ["lookupFor"]  # field classes added at the end of the module
+
+import datetime
+import struct
+import sys
+from functools import total_ordering
+
+from . import utils
+
+# abstract definitions
+
+
+@total_ordering
+class DbfFieldDef:
+    """Abstract field definition.
+
+    Child classes must override ``type`` class attribute to provide datatype
+    information of the field definition. For more info about types visit
+    `http://www.clicketyclick.dk/databases/xbase/format/data_types.html`
+
+    Also child classes must override ``defaultValue`` field to provide
+    default value for the field value.
+
+    If child class has fixed length ``length`` class attribute must be
+    overridden and set to the valid value. None value means, that field
+    isn't of fixed length.
+
+    Note: ``name`` field must not be changed after instantiation.
+
+    """
+
+    __slots__ = ("name", "decimalCount", "start", "end", "ignoreErrors")
+
+    # length of the field, None in case of variable-length field,
+    # or a number if this field is a fixed-length field
+    length = None
+
+    # field type. for more information about fields types visit
+    # `http://www.clicketyclick.dk/databases/xbase/format/data_types.html`
+    # must be overridden in child classes
+    typeCode = None
+
+    # default value for the field. this field must be
+    # overridden in child classes
+    defaultValue = None
+
+    def __init__(self, name, length=None, decimalCount=None,
+                 start=None, stop=None, ignoreErrors=False):
+        """Initialize instance."""
+        assert self.typeCode is not None, "Type code must be overridden"
+        assert self.defaultValue is not None, "Default value must be overridden"
+        # fix arguments
+        if len(name) > 10:
+            raise ValueError("Field name \"%s\" is too long" % name)
+        name = str(name).upper()
+        if self.__class__.length is None:
+            if length is None:
+                raise ValueError("[%s] Length isn't specified" % name)
+            length = int(length)
+            if length <= 0:
+                raise ValueError("[%s] Length must be a positive integer" % name)
+        else:
+            length = self.length
+        if decimalCount is None:
+            decimalCount = 0
+        # set fields
+        self.name = name
+        # FIXME: validate length according to the specification at
+        # http://www.clicketyclick.dk/databases/xbase/format/data_types.html
+        self.length = length
+        self.decimalCount = decimalCount
+        self.ignoreErrors = ignoreErrors
+        self.start = start
+        self.end = stop
+
+    def __eq__(self, other):
+        return repr(self) == repr(other)
+
+    def __ne__(self, other):
+        return repr(self) != repr(other)
+
+    def __lt__(self, other):
+        return repr(self) < repr(other)
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def fromString(cls, string, start, ignoreErrors=False):
+        """Decode dbf field definition from the string data.
+
+        Arguments:
+            string:
+                a string, dbf definition is decoded from. length of
+                the string must be 32 bytes.
+            start:
+                position in the database file.
+            ignoreErrors:
+                initial error processing mode for the new field (boolean)
+
+        """
+        assert len(string) == 32
+        _length = string[16]
+        return cls(utils.unzfill(string)[:11].decode('utf-8'), _length,
+            string[17], start, start + _length, ignoreErrors=ignoreErrors)
+    fromString = classmethod(fromString)
+
+    def toString(self):
+        """Return encoded field definition.
+
+        Return:
+            Return value is a string object containing encoded
+            definition of this field.
+
+        """
+        _name = self.name.ljust(11, '\0')
+        return (
+            _name +
+            self.typeCode +
+            # data address
+            chr(0) * 4 +
+            chr(self.length) +
+            chr(self.decimalCount) +
+            chr(0) * 14
+        )
+
+    def __repr__(self):
+        return "%-10s %1s %3d %3d" % self.fieldInfo()
+
+    def fieldInfo(self):
+        """Return field information.
+
+        Return:
+            Return value is a (name, type, length, decimals) tuple.
+
+        """
+        return (self.name, self.typeCode, self.length, self.decimalCount)
+
+    def rawFromRecord(self, record):
+        """Return a "raw" field value from the record string."""
+        return record[self.start:self.end]
+
+    def decodeFromRecord(self, record):
+        """Return decoded field value from the record string."""
+        try:
+            return self.decodeValue(self.rawFromRecord(record))
+        except Exception:
+            if self.ignoreErrors:
+                return utils.INVALID_VALUE
+            else:
+                raise
+
+    def decodeValue(self, value):
+        """Return decoded value from string value.
+
+        This method shouldn't be used publicly. It's called from the
+        `decodeFromRecord` method.
+
+        This is an abstract method and it must be overridden in child classes.
+        """
+        raise NotImplementedError
+
+    def encodeValue(self, value):
+        """Return str object containing encoded field value.
+
+        This is an abstract method and it must be overridden in child classes.
+        """
+        raise NotImplementedError
+
+# real classes
+
+
+class DbfCharacterFieldDef(DbfFieldDef):
+    """Definition of the character field."""
+
+    typeCode = "C"
+    defaultValue = b''
+
+    def decodeValue(self, value):
+        """Return string object.
+
+        Return value is a ``value`` argument with stripped right spaces.
+
+        """
+        return value.rstrip(b' ').decode('utf-8')
+
+    def encodeValue(self, value):
+        """Return raw data string encoded from a ``value``."""
+        return str(value)[:self.length].ljust(self.length)
+
+
+class DbfNumericFieldDef(DbfFieldDef):
+    """Definition of the numeric field."""
+
+    typeCode = "N"
+    # XXX: now I'm not sure it was a good idea to make a class field
+    # `defaultValue` instead of a generic method as it was implemented
+    # previously -- it's ok with all types except number, cuz
+    # if self.decimalCount is 0, we should return 0 and 0.0 otherwise.
+    defaultValue = 0
+
+    def decodeValue(self, value):
+        """Return a number decoded from ``value``.
+
+        If decimals is zero, value will be decoded as an integer;
+        or as a float otherwise.
+
+        Return:
+            Return value is a int (long) or float instance.
+
+        """
+        value = value.strip(b' \0')
+        if b'.' in value:
+            # a float (has decimal separator)
+            return float(value)
+        elif value:
+            # must be an integer
+            return int(value)
+        else:
+            return 0
+
+    def encodeValue(self, value):
+        """Return string containing encoded ``value``."""
+        _rv = ("%*.*f" % (self.length, self.decimalCount, value))
+        if len(_rv) > self.length:
+            _ppos = _rv.find(".")
+            if 0 <= _ppos <= self.length:
+                _rv = _rv[:self.length]
+            else:
+                raise ValueError("[%s] Numeric overflow: %s (field width: %i)"
+                    % (self.name, _rv, self.length))
+        return _rv
+
+
+class DbfFloatFieldDef(DbfNumericFieldDef):
+    """Definition of the float field - same as numeric."""
+
+    typeCode = "F"
+
+
+class DbfIntegerFieldDef(DbfFieldDef):
+    """Definition of the integer field."""
+
+    typeCode = "I"
+    length = 4
+    defaultValue = 0
+
+    def decodeValue(self, value):
+        """Return an integer number decoded from ``value``."""
+        return struct.unpack("<i", value)[0]
+
+    def encodeValue(self, value):
+        """Return string containing encoded ``value``."""
+        return struct.pack("<i", int(value))
+
+
+class DbfCurrencyFieldDef(DbfFieldDef):
+    """Definition of the currency field."""
+
+    typeCode = "Y"
+    length = 8
+    defaultValue = 0.0
+
+    def decodeValue(self, value):
+        """Return float number decoded from ``value``."""
+        return struct.unpack("<q", value)[0] / 10000.
+
+    def encodeValue(self, value):
+        """Return string containing encoded ``value``."""
+        return struct.pack("<q", round(value * 10000))
+
+
+class DbfLogicalFieldDef(DbfFieldDef):
+    """Definition of the logical field."""
+
+    typeCode = "L"
+    defaultValue = -1
+    length = 1
+
+    def decodeValue(self, value):
+        """Return True, False or -1 decoded from ``value``."""
+        # Note: value always is 1-char string
+        if value == "?":
+            return -1
+        if value in "NnFf ":
+            return False
+        if value in "YyTt":
+            return True
+        raise ValueError(f"[{self.name}] Invalid logical value {value!r}")
+
+    def encodeValue(self, value):
+        """Return a character from the "TF?" set.
+
+        Return:
+            Return value is "T" if ``value`` is True
+            "?" if value is -1 or False otherwise.
+
+        """
+        if value is True:
+            return "T"
+        if value == -1:
+            return "?"
+        return "F"
+
+
+class DbfMemoFieldDef(DbfFieldDef):
+    """Definition of the memo field.
+
+    Note: memos aren't currently completely supported.
+
+    """
+
+    typeCode = "M"
+    defaultValue = " " * 10
+    length = 10
+
+    def decodeValue(self, value):
+        """Return int .dbt block number decoded from the string object."""
+        # return int(value)
+        raise NotImplementedError
+
+    def encodeValue(self, value):
+        """Return raw data string encoded from a ``value``.
+
+        Note: this is an internal method.
+
+        """
+        # return str(value)[:self.length].ljust(self.length)
+        raise NotImplementedError
+
+
+class DbfDateFieldDef(DbfFieldDef):
+    """Definition of the date field."""
+
+    typeCode = "D"
+    defaultValue = utils.classproperty(lambda cls: datetime.date.today())
+    # "yyyymmdd" gives us 8 characters
+    length = 8
+
+    def decodeValue(self, value):
+        """Return a ``datetime.date`` instance decoded from ``value``."""
+        if value.strip():
+            return utils.getDate(value)
+        else:
+            return None
+
+    def encodeValue(self, value):
+        """Return a string-encoded value.
+
+        ``value`` argument should be a value suitable for the
+        `utils.getDate` call.
+
+        Return:
+            Return value is a string in format "yyyymmdd".
+
+        """
+        if value:
+            return utils.getDate(value).strftime("%Y%m%d")
+        else:
+            return " " * self.length
+
+
+class DbfDateTimeFieldDef(DbfFieldDef):
+    """Definition of the timestamp field."""
+
+    # a difference between JDN (Julian Day Number)
+    # and GDN (Gregorian Day Number). note, that GDN < JDN
+    JDN_GDN_DIFF = 1721425
+    typeCode = "T"
+    defaultValue = utils.classproperty(lambda cls: datetime.datetime.now())
+    # two 32-bits integers representing JDN and amount of
+    # milliseconds respectively gives us 8 bytes.
+    # note, that values must be encoded in LE byteorder.
+    length = 8
+
+    def decodeValue(self, value):
+        """Return a `datetime.datetime` instance."""
+        assert len(value) == self.length
+        # LE byteorder
+        _jdn, _msecs = struct.unpack("<2I", value)
+        if _jdn >= 1:
+            _rv = datetime.datetime.fromordinal(_jdn - self.JDN_GDN_DIFF)
+            _rv += datetime.timedelta(0, _msecs / 1000.0)
+        else:
+            # empty date
+            _rv = None
+        return _rv
+
+    def encodeValue(self, value):
+        """Return a string-encoded ``value``."""
+        if value:
+            value = utils.getDateTime(value)
+            # LE byteorder
+            _rv = struct.pack("<2I", value.toordinal() + self.JDN_GDN_DIFF,
+                (value.hour * 3600 + value.minute * 60 + value.second) * 1000)
+        else:
+            _rv = "\0" * self.length
+        assert len(_rv) == self.length
+        return _rv
+
+
+_fieldsRegistry = {}
+
+
+def registerField(fieldCls):
+    """Register field definition class.
+
+    ``fieldCls`` should be subclass of the `DbfFieldDef`.
+
+    Use `lookupFor` to retrieve field definition class
+    by the type code.
+
+    """
+    assert fieldCls.typeCode is not None, "Type code isn't defined"
+    # XXX: use fieldCls.typeCode.upper()? in case of any decign
+    # don't forget to look to the same comment in ``lookupFor`` method
+    _fieldsRegistry[fieldCls.typeCode] = fieldCls
+
+
+def lookupFor(typeCode):
+    """Return field definition class for the given type code.
+
+    ``typeCode`` must be a single character. That type should be
+    previously registered.
+
+    Use `registerField` to register new field class.
+
+    Return:
+        Return value is a subclass of the `DbfFieldDef`.
+
+    """
+    # XXX: use typeCode.upper()? in case of any decign don't
+    # forget to look to the same comment in ``registerField``
+    return _fieldsRegistry[chr(typeCode)]
+
+# register generic types
+
+
+for (_name, _val) in list(globals().items()):
+    if isinstance(_val, type) and issubclass(_val, DbfFieldDef) \
+       and (_name != "DbfFieldDef"):
+        __all__.append(_name)
+        registerField(_val)
+del _name, _val
+
+# vim: et sts=4 sw=4 :

src/tablib/packages/dbfpy/header.py

@@ -0,0 +1,270 @@
+"""DBF header definition.
+
+TODO:
+  - handle encoding of the character fields
+    (encoding information stored in the DBF header)
+
+"""
+"""History (most recent first):
+16-sep-2010 [als]   fromStream: fix century of the last update field
+11-feb-2007 [als]   added .ignoreErrors
+10-feb-2007 [als]   added __getitem__: return field definitions
+                    by field name or field number (zero-based)
+04-jul-2006 [als]   added export declaration
+15-dec-2005 [yc]    created
+"""
+
+__version__ = "$Revision: 1.6 $"[11:-2]
+__date__ = "$Date: 2010/09/16 05:06:39 $"[7:-2]
+
+__all__ = ["DbfHeader"]
+
+import datetime
+import io
+import struct
+import sys
+
+from . import fields
+from .utils import getDate
+
+
+class DbfHeader:
+    """Dbf header definition.
+
+    For more information about dbf header format visit
+    `http://www.clicketyclick.dk/databases/xbase/format/dbf.html#DBF_STRUCT`
+
+    Examples:
+        Create an empty dbf header and add some field definitions:
+            dbfh = DbfHeader()
+            dbfh.addField(("name", "C", 10))
+            dbfh.addField(("date", "D"))
+            dbfh.addField(DbfNumericFieldDef("price", 5, 2))
+        Create a dbf header with field definitions:
+            dbfh = DbfHeader([
+                ("name", "C", 10),
+                ("date", "D"),
+                DbfNumericFieldDef("price", 5, 2),
+            ])
+
+    """
+
+    __slots__ = ("signature", "fields", "lastUpdate", "recordLength",
+                 "recordCount", "headerLength", "changed", "_ignore_errors")
+
+    # instance construction and initialization methods
+
+    def __init__(self, fields=None, headerLength=0, recordLength=0,
+                 recordCount=0, signature=0x03, lastUpdate=None, ignoreErrors=False):
+        """Initialize instance.
+
+        Arguments:
+            fields:
+                a list of field definitions;
+            recordLength:
+                size of the records;
+            headerLength:
+                size of the header;
+            recordCount:
+                number of records stored in DBF;
+            signature:
+                version number (aka signature). using 0x03 as a default meaning
+                "File without DBT". for more information about this field visit
+                ``http://www.clicketyclick.dk/databases/xbase/format/dbf.html#DBF_NOTE_1_TARGET``
+            lastUpdate:
+                date of the DBF's update. this could be a string ('yymmdd' or
+                'yyyymmdd'), timestamp (int or float), datetime/date value,
+                a sequence (assuming (yyyy, mm, dd, ...)) or an object having
+                callable ``ticks`` field.
+            ignoreErrors:
+                error processing mode for DBF fields (boolean)
+
+        """
+        self.signature = signature
+        if fields is None:
+            self.fields = []
+        else:
+            self.fields = list(fields)
+        self.lastUpdate = getDate(lastUpdate)
+        self.recordLength = recordLength
+        self.headerLength = headerLength
+        self.recordCount = recordCount
+        self.ignoreErrors = ignoreErrors
+        # XXX: I'm not sure this is safe to
+        # initialize `self.changed` in this way
+        self.changed = bool(self.fields)
+
+    # @classmethod
+    def fromString(cls, string):
+        """Return header instance from the string object."""
+        return cls.fromStream(io.StringIO(str(string)))
+    fromString = classmethod(fromString)
+
+    # @classmethod
+    def fromStream(cls, stream):
+        """Return header object from the stream."""
+        stream.seek(0)
+        first_32 = stream.read(32)
+        if type(first_32) != bytes:
+            _data = bytes(first_32, sys.getfilesystemencoding())
+        _data = first_32
+        (_cnt, _hdrLen, _recLen) = struct.unpack("<I2H", _data[4:12])
+        # reserved = _data[12:32]
+        _year = _data[1]
+        if _year < 80:
+            # dBase II started at 1980.  It is quite unlikely
+            # that actual last update date is before that year.
+            _year += 2000
+        else:
+            _year += 1900
+        # create header object
+        _obj = cls(None, _hdrLen, _recLen, _cnt, _data[0],
+                   (_year, _data[2], _data[3]))
+        # append field definitions
+        # position 0 is for the deletion flag
+        _pos = 1
+        _data = stream.read(1)
+        while _data != b'\r':
+            _data += stream.read(31)
+            _fld = fields.lookupFor(_data[11]).fromString(_data, _pos)
+            _obj._addField(_fld)
+            _pos = _fld.end
+            _data = stream.read(1)
+        return _obj
+    fromStream = classmethod(fromStream)
+
+    # properties
+
+    year = property(lambda self: self.lastUpdate.year)
+    month = property(lambda self: self.lastUpdate.month)
+    day = property(lambda self: self.lastUpdate.day)
+
+    def ignoreErrors(self, value):
+        """Update `ignoreErrors` flag on self and all fields"""
+        self._ignore_errors = value = bool(value)
+        for _field in self.fields:
+            _field.ignoreErrors = value
+    ignoreErrors = property(
+        lambda self: self._ignore_errors,
+        ignoreErrors,
+        doc="""Error processing mode for DBF field value conversion
+
+        if set, failing field value conversion will return
+        ``INVALID_VALUE`` instead of raising conversion error.
+
+        """)
+
+    # object representation
+
+    def __repr__(self):
+        _rv = """\
+Version (signature): 0x%02x
+        Last update: %s
+      Header length: %d
+      Record length: %d
+       Record count: %d
+ FieldName Type Len Dec
+""" % (self.signature, self.lastUpdate, self.headerLength,
+    self.recordLength, self.recordCount)
+        _rv += "\n".join(
+            ["%10s %4s %3s %3s" % _fld.fieldInfo() for _fld in self.fields]
+        )
+        return _rv
+
+    # internal methods
+
+    def _addField(self, *defs):
+        """Internal variant of the `addField` method.
+
+        This method doesn't set `self.changed` field to True.
+
+        Return value is a length of the appended records.
+        Note: this method doesn't modify ``recordLength`` and
+        ``headerLength`` fields. Use `addField` instead of this
+        method if you don't exactly know what you're doing.
+
+        """
+        # insure we have dbf.DbfFieldDef instances first (instantiation
+        # from the tuple could raise an error, in such a case I don't
+        # wanna add any of the definitions -- all will be ignored)
+        _defs = []
+        _recordLength = 0
+        for _def in defs:
+            if isinstance(_def, fields.DbfFieldDef):
+                _obj = _def
+            else:
+                (_name, _type, _len, _dec) = (tuple(_def) + (None,) * 4)[:4]
+                _cls = fields.lookupFor(_type)
+                _obj = _cls(_name, _len, _dec, ignoreErrors=self._ignore_errors)
+            _recordLength += _obj.length
+            _defs.append(_obj)
+        # and now extend field definitions and
+        # update record length
+        self.fields += _defs
+        return _recordLength
+
+    # interface methods
+
+    def addField(self, *defs):
+        """Add field definition to the header.
+
+        Examples:
+            dbfh.addField(
+                ("name", "C", 20),
+                dbf.DbfCharacterFieldDef("surname", 20),
+                dbf.DbfDateFieldDef("birthdate"),
+                ("member", "L"),
+            )
+            dbfh.addField(("price", "N", 5, 2))
+            dbfh.addField(dbf.DbfNumericFieldDef("origprice", 5, 2))
+
+        """
+        _oldLen = self.recordLength
+        self.recordLength += self._addField(*defs)
+        if not _oldLen:
+            self.recordLength += 1
+            # XXX: may be just use:
+            # self.recordeLength += self._addField(*defs) + bool(not _oldLen)
+        # recalculate headerLength
+        self.headerLength = 32 + (32 * len(self.fields)) + 1
+        self.changed = True
+
+    def write(self, stream):
+        """Encode and write header to the stream."""
+        stream.seek(0)
+        stream.write(self.toString())
+        fields = [_fld.toString() for _fld in self.fields]
+        stream.write(''.join(fields).encode(sys.getfilesystemencoding()))
+        stream.write(b'\x0D')   # cr at end of all header data
+        self.changed = False
+
+    def toString(self):
+        """Returned 32 chars length string with encoded header."""
+        return struct.pack("<4BI2H",
+            self.signature,
+            self.year - 1900,
+            self.month,
+            self.day,
+            self.recordCount,
+            self.headerLength,
+            self.recordLength) + (b'\x00' * 20)
+        # TODO: figure out if bytes(utf-8) is correct here.
+
+    def setCurrentDate(self):
+        """Update ``self.lastUpdate`` field with current date value."""
+        self.lastUpdate = datetime.date.today()
+
+    def __getitem__(self, item):
+        """Return a field definition by numeric index or name string"""
+        if isinstance(item, str):
+            _name = item.upper()
+            for _field in self.fields:
+                if _field.name == _name:
+                    return _field
+            else:
+                raise KeyError(item)
+        else:
+            # item must be field index
+            return self.fields[item]
+
+# vim: et sts=4 sw=4 :

src/tablib/packages/dbfpy/record.py

@@ -0,0 +1,267 @@
+"""DBF record definition.
+
+"""
+"""History (most recent first):
+11-feb-2007 [als]   __repr__: added special case for invalid field values
+10-feb-2007 [als]   added .rawFromStream()
+30-oct-2006 [als]   fix record length in .fromStream()
+04-jul-2006 [als]   added export declaration
+20-dec-2005 [yc]    DbfRecord.write() -> DbfRecord._write();
+                    added delete() method.
+16-dec-2005 [yc]    record definition moved from `dbf`.
+"""
+
+__version__ = "$Revision: 1.7 $"[11:-2]
+__date__ = "$Date: 2007/02/11 09:05:49 $"[7:-2]
+
+__all__ = ["DbfRecord"]
+
+import sys
+
+from . import utils
+
+
+class DbfRecord:
+    """DBF record.
+
+    Instances of this class shouldn't be created manually,
+    use `dbf.Dbf.newRecord` instead.
+
+    Class implements mapping/sequence interface, so
+    fields could be accessed via their names or indexes
+    (names is a preferred way to access fields).
+
+    Hint:
+        Use `store` method to save modified record.
+
+    Examples:
+        Add new record to the database:
+            db = Dbf(filename)
+            rec = db.newRecord()
+            rec["FIELD1"] = value1
+            rec["FIELD2"] = value2
+            rec.store()
+        Or the same, but modify existed
+        (second in this case) record:
+            db = Dbf(filename)
+            rec = db[2]
+            rec["FIELD1"] = value1
+            rec["FIELD2"] = value2
+            rec.store()
+
+    """
+
+    __slots__ = "dbf", "index", "deleted", "fieldData"
+
+    # creation and initialization
+
+    def __init__(self, dbf, index=None, deleted=False, data=None):
+        """Instance initialization.
+
+        Arguments:
+            dbf:
+                A `Dbf.Dbf` instance this record belongs to.
+            index:
+                An integer record index or None. If this value is
+                None, record will be appended to the DBF.
+            deleted:
+                Boolean flag indicating whether this record
+                is a deleted record.
+            data:
+                A sequence or None. This is a data of the fields.
+                If this argument is None, default values will be used.
+
+        """
+        self.dbf = dbf
+        # XXX: I'm not sure ``index`` is necessary
+        self.index = index
+        self.deleted = deleted
+        if data is None:
+            self.fieldData = [_fd.defaultValue for _fd in dbf.header.fields]
+        else:
+            self.fieldData = list(data)
+
+    # XXX: validate self.index before calculating position?
+    position = property(lambda self: self.dbf.header.headerLength + \
+                        self.index * self.dbf.header.recordLength)
+
+    def rawFromStream(cls, dbf, index):
+        """Return raw record contents read from the stream.
+
+        Arguments:
+            dbf:
+                A `Dbf.Dbf` instance containing the record.
+            index:
+                Index of the record in the records' container.
+                This argument can't be None in this call.
+
+        Return value is a string containing record data in DBF format.
+
+        """
+        # XXX: may be write smth assuming, that current stream
+        # position is the required one? it could save some
+        # time required to calculate where to seek in the file
+        dbf.stream.seek(dbf.header.headerLength +
+            index * dbf.header.recordLength)
+        return dbf.stream.read(dbf.header.recordLength)
+    rawFromStream = classmethod(rawFromStream)
+
+    def fromStream(cls, dbf, index):
+        """Return a record read from the stream.
+
+        Arguments:
+            dbf:
+                A `Dbf.Dbf` instance new record should belong to.
+            index:
+                Index of the record in the records' container.
+                This argument can't be None in this call.
+
+        Return value is an instance of the current class.
+
+        """
+        return cls.fromString(dbf, cls.rawFromStream(dbf, index), index)
+    fromStream = classmethod(fromStream)
+
+    def fromString(cls, dbf, string, index=None):
+        """Return record read from the string object.
+
+        Arguments:
+            dbf:
+                A `Dbf.Dbf` instance new record should belong to.
+            string:
+                A string new record should be created from.
+            index:
+                Index of the record in the container. If this
+                argument is None, record will be appended.
+
+        Return value is an instance of the current class.
+
+        """
+        return cls(dbf, index, string[0]=="*",
+                   [_fd.decodeFromRecord(string) for _fd in dbf.header.fields])
+    fromString = classmethod(fromString)
+
+    # object representation
+
+    def __repr__(self):
+        _template = "%%%ds: %%s (%%s)" % max([len(_fld)
+            for _fld in self.dbf.fieldNames])
+        _rv = []
+        for _fld in self.dbf.fieldNames:
+            _val = self[_fld]
+            if _val is utils.INVALID_VALUE:
+                _rv.append(_template %
+                    (_fld, "None", "value cannot be decoded"))
+            else:
+                _rv.append(_template % (_fld, _val, type(_val)))
+        return "\n".join(_rv)
+
+    # protected methods
+
+    def _write(self):
+        """Write data to the dbf stream.
+
+        Note:
+            This isn't a public method, it's better to
+            use 'store' instead publicly.
+            Be design ``_write`` method should be called
+            only from the `Dbf` instance.
+
+
+        """
+        self._validateIndex(False)
+        self.dbf.stream.seek(self.position)
+        self.dbf.stream.write(bytes(self.toString(),
+                              sys.getfilesystemencoding()))
+        # FIXME: may be move this write somewhere else?
+        # why we should check this condition for each record?
+        if self.index == len(self.dbf):
+            # this is the last record,
+            # we should write SUB (ASCII 26)
+            self.dbf.stream.write(b"\x1A")
+
+    # utility methods
+
+    def _validateIndex(self, allowUndefined=True, checkRange=False):
+        """Valid ``self.index`` value.
+
+        If ``allowUndefined`` argument is True functions does nothing
+        in case of ``self.index`` pointing to None object.
+
+        """
+        if self.index is None:
+            if not allowUndefined:
+                raise ValueError("Index is undefined")
+        elif self.index < 0:
+            raise ValueError("Index can't be negative (%s)" % self.index)
+        elif checkRange and self.index <= self.dbf.header.recordCount:
+            raise ValueError("There are only %d records in the DBF" %
+                             self.dbf.header.recordCount)
+
+    # interface methods
+
+    def store(self):
+        """Store current record in the DBF.
+
+        If ``self.index`` is None, this record will be appended to the
+        records of the DBF this records belongs to; or replaced otherwise.
+
+        """
+        self._validateIndex()
+        if self.index is None:
+            self.index = len(self.dbf)
+            self.dbf.append(self)
+        else:
+            self.dbf[self.index] = self
+
+    def delete(self):
+        """Mark method as deleted."""
+        self.deleted = True
+
+    def toString(self):
+        """Return string packed record values."""
+#        for (_def, _dat) in zip(self.dbf.header.fields, self.fieldData):
+#
+
+        return "".join([" *"[self.deleted]] + [
+           _def.encodeValue(_dat)
+            for (_def, _dat) in zip(self.dbf.header.fields, self.fieldData)
+        ])
+
+    def asList(self):
+        """Return a flat list of fields.
+
+        Note:
+            Change of the list's values won't change
+            real values stored in this object.
+
+        """
+        return self.fieldData[:]
+
+    def asDict(self):
+        """Return a dictionary of fields.
+
+        Note:
+            Change of the dicts's values won't change
+            real values stored in this object.
+
+        """
+        return dict([_i for _i in zip(self.dbf.fieldNames, self.fieldData)])
+
+    def __getitem__(self, key):
+        """Return value by field name or field index."""
+        if isinstance(key, int):
+            # integer index of the field
+            return self.fieldData[key]
+        # assuming string field name
+        return self.fieldData[self.dbf.indexOfFieldName(key)]
+
+    def __setitem__(self, key, value):
+        """Set field value by integer index of the field or string name."""
+        if isinstance(key, int):
+            # integer index of the field
+            return self.fieldData[key]
+        # assuming string field name
+        self.fieldData[self.dbf.indexOfFieldName(key)] = value
+
+# vim: et sts=4 sw=4 :

src/tablib/packages/dbfpy/utils.py

@@ -0,0 +1,168 @@
+"""String utilities.
+
+TODO:
+  - allow strings in getDateTime routine;
+"""
+"""History (most recent first):
+11-feb-2007 [als]   added INVALID_VALUE
+10-feb-2007 [als]   allow date strings padded with spaces instead of zeroes
+20-dec-2005 [yc]    handle long objects in getDate/getDateTime
+16-dec-2005 [yc]    created from ``strutil`` module.
+"""
+
+__version__ = "$Revision: 1.4 $"[11:-2]
+__date__ = "$Date: 2007/02/11 08:57:17 $"[7:-2]
+
+import datetime
+import time
+
+
+def unzfill(str):
+    """Return a string without ASCII NULs.
+
+    This function searchers for the first NUL (ASCII 0) occurrence
+    and truncates string till that position.
+
+    """
+    try:
+        return str[:str.index(b'\0')]
+    except ValueError:
+        return str
+
+
+def getDate(date=None):
+    """Return `datetime.date` instance.
+
+    Type of the ``date`` argument could be one of the following:
+        None:
+            use current date value;
+        datetime.date:
+            this value will be returned;
+        datetime.datetime:
+            the result of the date.date() will be returned;
+        string:
+            assuming "%Y%m%d" or "%y%m%dd" format;
+        number:
+            assuming it's a timestamp (returned for example
+            by the time.time() call;
+        sequence:
+            assuming (year, month, day, ...) sequence;
+
+    Additionally, if ``date`` has callable ``ticks`` attribute,
+    it will be used and result of the called would be treated
+    as a timestamp value.
+
+    """
+    if date is None:
+        # use current value
+        return datetime.date.today()
+    if isinstance(date, datetime.date):
+        return date
+    if isinstance(date, datetime.datetime):
+        return date.date()
+    if isinstance(date, (int, float)):
+        # date is a timestamp
+        return datetime.date.fromtimestamp(date)
+    if isinstance(date, str):
+        date = date.replace(" ", "0")
+        if len(date) == 6:
+            # yymmdd
+            return datetime.date(*time.strptime(date, "%y%m%d")[:3])
+        # yyyymmdd
+        return datetime.date(*time.strptime(date, "%Y%m%d")[:3])
+    if hasattr(date, "__getitem__"):
+        # a sequence (assuming date/time tuple)
+        return datetime.date(*date[:3])
+    return datetime.date.fromtimestamp(date.ticks())
+
+
+def getDateTime(value=None):
+    """Return `datetime.datetime` instance.
+
+    Type of the ``value`` argument could be one of the following:
+        None:
+            use current date value;
+        datetime.date:
+            result will be converted to the `datetime.datetime` instance
+            using midnight;
+        datetime.datetime:
+            ``value`` will be returned as is;
+        string:
+            *** CURRENTLY NOT SUPPORTED ***;
+        number:
+            assuming it's a timestamp (returned for example
+            by the time.time() call;
+        sequence:
+            assuming (year, month, day, ...) sequence;
+
+    Additionally, if ``value`` has callable ``ticks`` attribute,
+    it will be used and result of the called would be treated
+    as a timestamp value.
+
+    """
+    if value is None:
+        # use current value
+        return datetime.datetime.today()
+    if isinstance(value, datetime.datetime):
+        return value
+    if isinstance(value, datetime.date):
+        return datetime.datetime.fromordinal(value.toordinal())
+    if isinstance(value, (int, float)):
+        # value is a timestamp
+        return datetime.datetime.fromtimestamp(value)
+    if isinstance(value, str):
+        raise NotImplementedError("Strings aren't currently implemented")
+    if hasattr(value, "__getitem__"):
+        # a sequence (assuming date/time tuple)
+        return datetime.datetime(*tuple(value)[:6])
+    return datetime.datetime.fromtimestamp(value.ticks())
+
+
+class classproperty(property):
+    """Works in the same way as a ``property``, but for the classes."""
+
+    def __get__(self, obj, cls):
+        return self.fget(cls)
+
+
+class _InvalidValue:
+
+    """Value returned from DBF records when field validation fails
+
+    The value is not equal to anything except for itself
+    and equal to all empty values: None, 0, empty string etc.
+    In other words, invalid value is equal to None and not equal
+    to None at the same time.
+
+    This value yields zero upon explicit conversion to a number type,
+    empty string for string types, and False for boolean.
+
+    """
+
+    def __eq__(self, other):
+        return not other
+
+    def __ne__(self, other):
+        return not (other is self)
+
+    def __bool__(self):
+        return False
+
+    def __int__(self):
+        return 0
+    __long__ = __int__
+
+    def __float__(self):
+        return 0.0
+
+    def __str__(self):
+        return ""
+
+    def __repr__(self):
+        return "<INVALID>"
+
+
+# invalid value is a constant singleton
+INVALID_VALUE = _InvalidValue()
+
+# vim: set et sts=4 sw=4 :

src/tablib/utils.py

@@ -0,0 +1,13 @@
+from io import BytesIO, StringIO
+
+
+def normalize_input(stream):
+    """
+    Accept either a str/bytes stream or a file-like object and always return a
+    file-like object.
+    """
+    if isinstance(stream, str):
+        return StringIO(stream)
+    elif isinstance(stream, bytes):
+        return BytesIO(stream)
+    return stream

tablib/__init__.py

@@ -1,16 +0,0 @@
-""" Tablib.
-"""
-
-import sys
-if sys.version_info[0:1] > (2, 5):
-    from tablib.core import (
-        Databook, Dataset, detect, import_set, 
-        InvalidDatasetType, InvalidDimensions, UnsupportedFormat
-    )
-    
-else:
-    from tablib.core25 import (
-        Databook, Dataset, detect, import_set, 
-        InvalidDatasetType, InvalidDimensions, UnsupportedFormat
-    )
-

tablib/core25.py

@@ -1,818 +0,0 @@
-# -*- coding: utf-8 -*-
-u"""
-    tablib.core
-    ~~~~~~~~~~~
-
-    This module implements the central Tablib objects.
-
-    :copyright: (c) 2011 by Kenneth Reitz.
-    :license: MIT, see LICENSE for more details.
-"""
-
-from copy import copy
-from operator import itemgetter
-
-from tablib import formats
-import collections
-from itertools import izip
-from itertools import imap
-
-try:
-    from collections import OrderedDict
-except ImportError:
-    from tablib.packages.ordereddict import OrderedDict
-
-
-__title__ = u'tablib'
-__version__ = u'0.9.4'
-__build__ = 0x000904
-__author__ = u'Kenneth Reitz'
-__license__ = u'MIT'
-__copyright__ = u'Copyright 2011 Kenneth Reitz'
-__docformat__ = u'restructuredtext'
-
-
-class Row(object):
-    u"""Internal Row object. Mainly used for filtering."""
-
-    __slots__ = [u'tuple', u'_row', u'tags']
-
-    def __init__(self, row=list(), tags=list()):
-        self._row = list(row)
-        self.tags = list(tags)
-
-    def __iter__(self):
-        return (col for col in self._row)
-
-    def __len__(self):
-        return len(self._row)
-
-    def __repr__(self):
-        return repr(self._row)
-
-    def __getslice__(self, i, j):
-        return self._row[i,j]
-
-    def __getitem__(self, i):
-        return self._row[i]
-
-    def __setitem__(self, i, value):
-        self._row[i] = value
-
-    def __delitem__(self, i):
-        del self._row[i]
-
-    def __getstate__(self):
-        return {slot: [getattr(self, slot) for slot in self.__slots__]}
-
-    def __setstate__(self, state):
-        for (k, v) in list(state.items()): setattr(self, k, v)
-
-    def append(self, value):
-        self._row.append(value)
-
-    def insert(self, index, value):
-        self._row.insert(index, value)
-
-    def __contains__(self, item):
-        return (item in self._row)
-
-    @property
-    def tuple(self):
-        u'''Tuple representation of :class:`Row`.'''
-        return tuple(self._row)
-
-    @property
-    def list(self):
-        u'''List representation of :class:`Row`.'''
-        return list(self._row)
-
-    def has_tag(self, tag):
-        u"""Returns true if current row contains tag."""
-
-        if tag == None:
-            return False
-        elif isinstance(tag, basestring):
-            return (tag in self.tags)
-        else:
-            return bool(len(set(tag) & set(self.tags)))
-                
-
-
-
-class Dataset(object):
-    u"""The :class:`Dataset` object is the heart of Tablib. It provides all core
-    functionality.
-
-    Usually you create a :class:`Dataset` instance in your main module, and append
-    rows and columns as you collect data. ::
-
-        data = tablib.Dataset()
-        data.headers = ('name', 'age')
-
-        for (name, age) in some_collector():
-            data.append((name, age))
-
-    You can also set rows and headers upon instantiation. This is useful if dealing
-    with dozens or hundres of :class:`Dataset` objects. ::
-
-        headers = ('first_name', 'last_name')
-        data = [('John', 'Adams'), ('George', 'Washington')]
-
-        data = tablib.Dataset(*data, headers=headers)
-
-
-    :param \*args: (optional) list of rows to populate Dataset
-    :param headers: (optional) list strings for Dataset header row
-
-
-    .. admonition:: Format Attributes Definition
-
-     If you look at the code, the various output/import formats are not
-     defined within the :class:`Dataset` object. To add support for a new format, see
-     :ref:`Adding New Formats <newformats>`.
-
-    """
-
-    def __init__(self, *args, **kwargs):
-        self._data = list(Row(arg) for arg in args)
-        self.__headers = None
-
-        # ('title', index) tuples
-        self._separators = []
-        
-        # (column, callback) tuples
-        self._formatters = []
-
-        try:
-            self.headers = kwargs[u'headers']
-        except KeyError:
-            self.headers = None
-
-        try:
-            self.title = kwargs[u'title']
-        except KeyError:
-            self.title = None
-
-        self._register_formats()
-
-
-    def __len__(self):
-        return self.height
-
-
-    def __getitem__(self, key):
-        if isinstance(key, basestring):
-            if key in self.headers:
-                pos = self.headers.index(key) # get 'key' index from each data
-                return [row[pos] for row in self._data]
-            else:
-                raise KeyError
-        else:
-            _results = self._data[key]
-            if isinstance(_results, Row):
-                return _results.tuple
-            else:
-                return [result.tuple for result in _results]
-
-
-    def __setitem__(self, key, value):
-        self._validate(value)
-        self._data[key] = Row(value)
-
-
-    def __delitem__(self, key):
-        if isinstance(key, basestring):
-
-            if key in self.headers:
-
-                pos = self.headers.index(key)
-                del self.headers[pos]
-
-                for i, row in enumerate(self._data):
-
-                    del row[pos]
-                    self._data[i] = row
-            else:
-                raise KeyError
-        else:
-            del self._data[key]
-
-
-    def __repr__(self):
-        try:
-            return u'<%s dataset>' % (self.title.lower())
-        except AttributeError:
-            return u'<dataset object>'
-
-
-    @classmethod
-    def _register_formats(cls):
-        u"""Adds format properties."""
-        for fmt in formats.available:
-            try:
-                try:
-                    setattr(cls, fmt.title, property(fmt.export_set, fmt.import_set))
-                except AttributeError:
-                    setattr(cls, fmt.title, property(fmt.export_set))
-
-            except AttributeError:
-                pass
-
-
-    def _validate(self, row=None, col=None, safety=False):
-        u"""Assures size of every row in dataset is of proper proportions."""
-        if row:
-            is_valid = (len(row) == self.width) if self.width else True
-        elif col:
-            if len(col) < 1:
-                is_valid = True
-            else:
-                is_valid = (len(col) == self.height) if self.height else True
-        else:
-            is_valid = all((len(x) == self.width for x in self._data))
-
-        if is_valid:
-            return True
-        else:
-            if not safety:
-                raise InvalidDimensions
-            return False
-
-
-    def _package(self, dicts=True):
-        u"""Packages Dataset into lists of dictionaries for transmission."""
-
-        _data = list(self._data)
-        
-        # Execute formatters
-        if self._formatters:
-            for row_i, row in enumerate(_data):
-                for col, callback in self._formatters:
-                    try:                        
-                        if col is None:
-                            for j, c in enumerate(row):
-                                _data[row_i][j] = callback(c)
-                        else:
-                            _data[row_i][col] = callback(row[col])
-                    except IndexError:
-                        raise InvalidDatasetIndex
-                        
-
-        if self.headers:
-            if dicts:
-                data = [OrderedDict(list(izip(self.headers, data_row))) for data_row in _data]
-            else:
-                data = [list(self.headers)] + list(_data)
-        else:
-            data = [list(row) for row in _data]
-
-        return data
-
-
-    def _clean_col(self, col):
-        u"""Prepares the given column for insert/append."""
-
-        col = list(col)
-
-        if self.headers:
-            header = [col.pop(0)]
-        else:
-            header = []
-
-        if len(col) == 1 and hasattr(col[0], '__call__'):
-            col = list(imap(col[0], self._data))
-        col = tuple(header + col)
-
-        return col
-
-
-    @property
-    def height(self):
-        u"""The number of rows currently in the :class:`Dataset`.
-           Cannot be directly modified.
-        """
-        return len(self._data)
-
-
-    @property
-    def width(self):
-        u"""The number of columns currently in the :class:`Dataset`.
-           Cannot be directly modified.
-        """
-
-        try:
-            return len(self._data[0])
-        except IndexError:
-            try:
-                return len(self.headers)
-            except TypeError:
-                return 0
-
-
-    def _get_headers(self):
-        u"""An *optional* list of strings to be used for header rows and attribute names.
-
-        This must be set manually. The given list length must equal :class:`Dataset.width`.
-
-        """
-        return self.__headers
-
-
-    def _set_headers(self, collection):
-        u"""Validating headers setter."""
-        self._validate(collection)
-        if collection:
-            try:
-                self.__headers = list(collection)
-            except TypeError:
-                raise TypeError
-        else:
-            self.__headers = None
-
-    headers = property(_get_headers, _set_headers)
-
-    def _get_dict(self):
-        u"""A native Python representation of the :class:`Dataset` object. If headers have 
-        been set, a list of Python dictionaries will be returned. If no headers have been set, 
-        a list of tuples (rows) will be returned instead.
-
-        A dataset object can also be imported by setting the `Dataset.dict` attribute: ::
-
-            data = tablib.Dataset()
-            data.json = '[{"last_name": "Adams","age": 90,"first_name": "John"}]'
-
-        """
-        return self._package()
-
-
-    def _set_dict(self, pickle):
-        u"""A native Python representation of the Dataset object. If headers have been
-        set, a list of Python dictionaries will be returned. If no headers have been
-        set, a list of tuples (rows) will be returned instead.
-
-        A dataset object can also be imported by setting the :class:`Dataset.dict` attribute. ::
-
-            data = tablib.Dataset()
-            data.dict = [{'age': 90, 'first_name': 'Kenneth', 'last_name': 'Reitz'}]
-
-        """
-
-        if not len(pickle):
-            return
-
-        # if list of rows
-        if isinstance(pickle[0], list):
-            self.wipe()
-            for row in pickle:
-                self.append(Row(row))
-
-        # if list of objects
-        elif isinstance(pickle[0], dict):
-            self.wipe()
-            self.headers = list(pickle[0].keys())
-            for row in pickle:
-                self.append(Row(list(row.values())))
-        else:
-            raise UnsupportedFormat
-
-    dict = property(_get_dict, _set_dict)
-
-
-    @property
-    def xls():
-        u"""An Excel Spreadsheet representation of the :class:`Dataset` object, with :ref:`seperators`. Cannot be set.
-
-         .. admonition:: Binary Warning
-
-             :class:`Dataset.xls` contains binary data, so make sure to write in binary mode::
-
-                with open('output.xls', 'wb') as f:
-                    f.write(data.xls)'
-        """
-        pass
-
-
-    @property
-    def csv():
-        u"""A CSV representation of the :class:`Dataset` object. The top row will contain
-        headers, if they have been set. Otherwise, the top row will contain
-        the first row of the dataset.
-
-        A dataset object can also be imported by setting the :class:`Dataset.csv` attribute. ::
-
-            data = tablib.Dataset()
-            data.csv = 'age, first_name, last_name\\n90, John, Adams'
-
-        Import assumes (for now) that headers exist.
-        """
-        pass
-
-
-    @property
-    def tsv():
-        u"""A TSV representation of the :class:`Dataset` object. The top row will contain
-        headers, if they have been set. Otherwise, the top row will contain
-        the first row of the dataset.
-
-        A dataset object can also be imported by setting the :class:`Dataset.tsv` attribute. ::
-
-            data = tablib.Dataset()
-            data.tsv = 'age\tfirst_name\tlast_name\\n90\tJohn\tAdams'
-
-        Import assumes (for now) that headers exist.
-        """
-
-    @property
-    def yaml():
-        u"""A YAML representation of the :class:`Dataset` object. If headers have been
-        set, a YAML list of objects will be returned. If no headers have
-        been set, a YAML list of lists (rows) will be returned instead.
-
-        A dataset object can also be imported by setting the :class:`Dataset.json` attribute: ::
-
-            data = tablib.Dataset()
-            data.yaml = '- {age: 90, first_name: John, last_name: Adams}'
-
-        Import assumes (for now) that headers exist.
-        """
-        pass
-
-
-    @property
-    def json():
-        u"""A JSON representation of the :class:`Dataset` object. If headers have been
-        set, a JSON list of objects will be returned. If no headers have
-        been set, a JSON list of lists (rows) will be returned instead.
-
-        A dataset object can also be imported by setting the :class:`Dataset.json` attribute: ::
-
-            data = tablib.Dataset()
-            data.json = '[{age: 90, first_name: "John", liast_name: "Adams"}]'
-
-        Import assumes (for now) that headers exist.
-        """
-
-    @property
-    def html():
-        u"""A HTML table representation of the :class:`Dataset` object. If
-        headers have been set, they will be used as table headers.
-
-        ..notice:: This method can be used for export only.
-        """
-        pass
-
-
-    def append(self, row=None, col=None, header=None, tags=list()):
-        u"""Adds a row or column to the :class:`Dataset`.
-        Usage is  :class:`Dataset.insert` for documentation.
-        """
-
-        if row is not None:
-            self.insert(self.height, row=row, tags=tags)
-        elif col is not None:
-            self.insert(self.width, col=col, header=header)
-
-
-    def insert_separator(self, index, text=u'-'):
-        u"""Adds a separator to :class:`Dataset` at given index."""
-
-        sep = (index, text)
-        self._separators.append(sep)
-
-
-    def append_separator(self, text=u'-'):
-        u"""Adds a :ref:`seperator <seperators>` to the :class:`Dataset`."""
-
-        # change offsets if headers are or aren't defined
-        if not self.headers:
-            index = self.height if self.height else 0
-        else:
-            index = (self.height + 1) if self.height else 1
-
-        self.insert_separator(index, text)
-
-
-    def add_formatter(self, col, handler):
-        u"""Adds a :ref:`formatter` to the :class:`Dataset`.
-        
-        .. versionadded:: 0.9.5
-           :param col: column to. Accepts index int or header str.
-           :param handler: reference to callback function to execute 
-           against each cell value.
-        """
-        
-        if isinstance(col, basestring):
-            if col in self.headers:
-                col = self.headers.index(col) # get 'key' index from each data
-            else:
-                raise KeyError
-        
-        if not col > self.width:
-            self._formatters.append((col, handler))
-        else:
-            raise InvalidDatasetIndex
-        
-        return True
-        
-
-    def insert(self, index, row=None, col=None, header=None, tags=list()):
-        u"""Inserts a row or column to the :class:`Dataset` at the given index.
-
-        Rows and columns inserted must be the correct size (height or width).
-
-        The default behaviour is to insert the given row to the :class:`Dataset`
-        object at the given index. If the ``col`` parameter is given, however,
-        a new column will be insert to the :class:`Dataset` object instead.
-
-        You can also insert a column of a single callable object, which will
-        add a new column with the return values of the callable each as an
-        item in the column. ::
-
-            data.append(col=random.randint)
-
-        See :ref:`dyncols` for an in-depth example.
-
-        .. versionchanged:: 0.9.0
-           If inserting a column, and :class:`Dataset.headers` is set, the
-           header attribute must be set, and will be considered the header for
-           that row.
-
-        .. versionadded:: 0.9.0
-           If inserting a row, you can add :ref:`tags <tags>` to the row you are inserting.
-           This gives you the ability to :class:`filter <Dataset.filter>` your
-           :class:`Dataset` later.
-
-        """
-        if row:
-            self._validate(row)
-            self._data.insert(index, Row(row, tags=tags))
-        elif col:
-            col = list(col)
-
-            # Callable Columns...
-            if len(col) == 1 and hasattr(col[0], '__call__'):
-                col = list(imap(col[0], self._data))
-
-            col = self._clean_col(col)
-            self._validate(col=col)
-
-            if self.headers:
-                # pop the first item off, add to headers
-                if not header:
-                    raise HeadersNeeded()
-                self.headers.insert(index, header)
-
-            if self.height and self.width:
-
-                for i, row in enumerate(self._data):
-
-                    row.insert(index, col[i])
-                    self._data[i] = row
-            else:
-                self._data = [Row([row]) for row in col]
-
-
-    def filter(self, tag):
-        u"""Returns a new instance of the :class:`Dataset`, excluding any rows
-        that do not contain the given :ref:`tags <tags>`.
-        """
-        _dset = copy(self)
-        _dset._data = [row for row in _dset._data if row.has_tag(tag)]
-
-        return _dset
-
-
-    def sort(self, col, reverse=False):
-        u"""Sort a :class:`Dataset` by a specific column, given string (for
-        header) or integer (for column index). The order can be reversed by
-        setting ``reverse`` to ``True``. 
-        Returns a new :class:`Dataset` instance where columns have been
-        sorted."""
-        
-        if isinstance(col, basestring):
-
-            if not self.headers:
-                raise HeadersNeeded
-
-            _sorted = sorted(self.dict, key=itemgetter(col), reverse=reverse)
-            _dset = Dataset(headers=self.headers)
-
-            for item in _sorted:
-                row = [item[key] for key in self.headers]
-                _dset.append(row=row)
-
-        else:
-            if self.headers:
-                col = self.headers[col]
-
-            _sorted = sorted(self.dict, key=itemgetter(col), reverse=reverse)
-            _dset = Dataset(headers=self.headers)
-
-            for item in _sorted:
-                if self.headers:
-                    row = [item[key] for key in self.headers]
-                else:
-                    row = item
-                _dset.append(row=row)
-
-
-        return _dset
-
-
-    def transpose(self):
-        u"""Transpose a :class:`Dataset`, turning rows into columns and vice
-        versa, returning a new ``Dataset`` instance. The first row of the
-        original instance becomes the new header row."""
-
-        # Don't transpose if there is no data
-        if not self:
-            return
-
-        _dset = Dataset()
-        # The first element of the headers stays in the headers,
-        # it is our "hinge" on which we rotate the data
-        new_headers = [self.headers[0]] + self[self.headers[0]]
-
-        _dset.headers = new_headers
-        for column in self.headers:
-
-            if column == self.headers[0]:
-                # It's in the headers, so skip it
-                continue
-
-            # Adding the column name as now they're a regular column
-            row_data = [column] + self[column]
-            row_data = Row(row_data)
-            _dset.append(row=row_data)
-
-        return _dset
-
-
-    def stack_rows(self, other):
-        u"""Stack two :class:`Dataset` instances together by
-        joining at the row level, and return new combined
-        ``Dataset`` instance."""
-
-        if not isinstance(other, Dataset):
-            return
-
-        if self.width != other.width:
-            raise InvalidDimensions
-
-        # Copy the source data
-        _dset = copy(self)
-
-        rows_to_stack = [row for row in _dset._data]
-        other_rows = [row for row in other._data]
-
-        rows_to_stack.extend(other_rows)
-        _dset._data = rows_to_stack
-
-        return _dset
-
-
-    def stack_columns(self, other):
-        u"""Stack two :class:`Dataset` instances together by
-        joining at the column level, and return a new
-        combined ``Dataset`` instance. If either ``Dataset``
-        has headers set, than the other must as well."""
-
-        if not isinstance(other, Dataset):
-            return
-
-        if self.headers or other.headers:
-            if not self.headers or not other.headers:
-                raise HeadersNeeded
-
-        if self.height != other.height:
-            raise InvalidDimensions
-
-        try:
-            new_headers = self.headers + other.headers
-        except TypeError:
-            new_headers = None
-
-        _dset = Dataset()
-
-        for column in self.headers:
-            _dset.append(col=self[column])
-
-        for column in other.headers:
-            _dset.append(col=other[column])
-
-        _dset.headers = new_headers
-
-        return _dset
-
-
-    def wipe(self):
-        u"""Removes all content and headers from the :class:`Dataset` object."""
-        self._data = list()
-        self.__headers = None
-
-
-
-class Databook(object):
-    u"""A book of :class:`Dataset` objects.
-    """
-
-    def __init__(self, sets=None):
-
-        if sets is None:
-            self._datasets = list()
-        else:
-            self._datasets = sets
-
-        self._register_formats()
-
-    def __repr__(self):
-        try:
-            return u'<%s databook>' % (self.title.lower())
-        except AttributeError:
-            return u'<databook object>'
-
-
-    def wipe(self):
-        u"""Removes all :class:`Dataset` objects from the :class:`Databook`."""
-        self._datasets = []
-
-
-    @classmethod
-    def _register_formats(cls):
-        u"""Adds format properties."""
-        for fmt in formats.available:
-            try:
-                try:
-                    setattr(cls, fmt.title, property(fmt.export_book, fmt.import_book))
-                except AttributeError:
-                    setattr(cls, fmt.title, property(fmt.export_book))
-
-            except AttributeError:
-                pass
-
-
-    def add_sheet(self, dataset):
-        u"""Adds given :class:`Dataset` to the :class:`Databook`."""
-        if type(dataset) is Dataset:
-            self._datasets.append(dataset)
-        else:
-            raise InvalidDatasetType
-
-
-    def _package(self):
-        u"""Packages :class:`Databook` for delivery."""
-        collector = []
-        for dset in self._datasets:
-            collector.append(OrderedDict(
-                title = dset.title,
-                data = dset.dict
-            ))
-        return collector
-
-
-    @property
-    def size(self):
-        u"""The number of the :class:`Dataset` objects within :class:`Databook`."""
-        return len(self._datasets)
-
-
-def detect(stream):
-    u"""Return (format, stream) of given stream."""
-    for fmt in formats.available:
-        try:
-            if fmt.detect(stream):
-                return (fmt, stream)
-        except AttributeError:
-            pass
-    return (None, stream)
-
-
-def import_set(stream):
-    u"""Return dataset of given stream."""
-    (format, stream) = detect(stream)
-
-    try:
-        data = Dataset()
-        format.import_set(data, stream)
-        return data
-
-    except AttributeError, e:
-        return None
-
-
-class InvalidDatasetType(Exception):
-    u"Only Datasets can be added to a DataBook"
-
-
-class InvalidDimensions(Exception):
-    u"Invalid size"
-    
-class InvalidDatasetIndex(Exception):
-    u"Outside of Dataset size"
-
-class HeadersNeeded(Exception):
-    u"Header parameter must be given when appending a column in this Dataset."
-
-class UnsupportedFormat(NotImplementedError):
-    u"Format is not supported"

tablib/formats/__init__.py

@@ -1,13 +0,0 @@
-# -*- coding: utf-8 -*-
-
-""" Tablib - formats
-"""
-
-from . import _csv as csv
-from . import _json as json
-from . import _xls as xls
-from . import _yaml as yaml
-from . import _tsv as tsv
-from . import _html as html
-
-available = (json, xls, yaml, csv, tsv, html)

tablib/formats/_csv.py

@@ -1,55 +0,0 @@
-# -*- coding: utf-8 -*-
-
-""" Tablib - CSV Support.
-"""
-
-import sys
-if sys.version_info[0] > 2:
-    from io import StringIO
-else:
-    from cStringIO import StringIO
-
-
-import csv
-import os
-
-import tablib
-
-
-title = 'csv'
-extentions = ('csv',)
-
-
-
-def export_set(dataset):
-    """Returns CSV representation of Dataset."""
-    stream = StringIO()
-    _csv = csv.writer(stream)
-
-    for row in dataset._package(dicts=False):
-        _csv.writerow(row)
-
-    return stream.getvalue()
-
-
-def import_set(dset, in_stream, headers=True):
-    """Returns dataset from CSV stream."""
-
-    dset.wipe()
-
-    rows = csv.reader(in_stream.splitlines())
-    for i, row in enumerate(rows):
-
-        if (i == 0) and (headers):
-            dset.headers = row
-        else:
-            dset.append(row)
-
-
-def detect(stream):
-    """Returns True if given stream is valid CSV."""
-    try:
-        rows = dialect = csv.Sniffer().sniff(stream)
-        return True
-    except csv.Error:
-        return False

tablib/formats/_html.py

@@ -1,60 +0,0 @@
-# -*- coding: utf-8 -*-
-
-""" Tablib - HTML export support.
-"""
-
-import sys
-
-
-if sys.version_info[0] > 2:
-    from io import StringIO
-    from tablib.packages import markup3 as markup
-else:
-    from cStringIO import StringIO
-    from tablib.packages import markup
-
-import tablib
-
-BOOK_ENDINGS = 'h3'
-
-title = 'html'
-extentions = ('html', )
-
-
-def export_set(dataset):
-	"""HTML representation of a Dataset."""
-
-	stream = StringIO()
-
-	page = markup.page()
-	page.table.open()
-
-	if dataset.headers is not None:
-		page.thead.open()
-		headers = markup.oneliner.th(dataset.headers)
-		page.tr(headers)
-		page.thead.close()
-
-	for row in dataset:
-		html_row = markup.oneliner.td(row)
-		page.tr(html_row)
-
-	page.table.close()
-
-	stream.writelines(str(page))
-
-	return stream.getvalue()
-
-
-def export_book(databook):
-	"""HTML representation of a Databook."""
-
-	stream = StringIO()
-
-	for i, dset in enumerate(databook._datasets):
-		title = (dset.title if dset.title else 'Set %s' % (i))
-		stream.write('<%s>%s</%s>\n' % (BOOK_ENDINGS, title, BOOK_ENDINGS))
-		stream.write(dset.html)
-		stream.write('\n')
-
-	return stream.getvalue()

tablib/formats/_json.py

@@ -1,54 +0,0 @@
-# -*- coding: utf-8 -*-
-
-""" Tablib - JSON Support
-"""
-
-import tablib
-
-import sys
-if sys.version_info[:2] > (2, 5):
-    from tablib.packages import anyjson
-else:
-    from tablib.packages import anyjson25 as anyjson
-
-
-
-title = 'json'
-extentions = ('json', 'jsn')
-
-
-def export_set(dataset):
-    """Returns JSON representation of Dataset."""
-    return anyjson.serialize(dataset.dict)
-
-
-def export_book(databook):
-    """Returns JSON representation of Databook."""
-    return anyjson.serialize(databook._package())
-
-
-def import_set(dset, in_stream):
-    """Returns dataset from JSON stream."""
-
-    dset.wipe()
-    dset.dict = anyjson.deserialize(in_stream)
-
-
-def import_book(dbook, in_stream):
-    """Returns databook from JSON stream."""
-
-    dbook.wipe()
-    for sheet in anyjson.deserialize(in_stream):
-        data = tablib.Dataset()
-        data.title = sheet['title']
-        data.dict = sheet['data']
-        dbook.add_sheet(data)
-
-
-def detect(stream):
-    """Returns True if given stream is valid JSON."""
-    try:
-        anyjson.deserialize(stream)
-        return True
-    except ValueError:
-        return False

tablib/formats/_tsv.py

@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-
-""" Tablib - TSV (Tab Separated Values) Support.
-"""
-
-import sys
-if sys.version_info[0] > 2:
-    from io import StringIO
-else:
-    from cStringIO import StringIO
-    
-import csv
-import os
-
-import tablib
-
-
-title = 'tsv'
-extentions = ('tsv',)
-
-
-
-def export_set(dataset):
-    """Returns a TSV representation of Dataset."""
-    stream = StringIO()
-    _tsv = csv.writer(stream, delimiter='\t')
-
-    for row in dataset._package(dicts=False):
-        _tsv.writerow(row)
-
-    return stream.getvalue()
-
-
-def import_set(dset, in_stream, headers=True):
-    """Returns dataset from TSV stream."""
-    dset.wipe()
-
-    rows = csv.reader(in_stream.split('\r\n'), delimiter='\t')
-    for i, row in enumerate(rows):
-        # Skip empty rows
-        if not row:
-            continue
-
-        if (i == 0) and (headers):
-            dset.headers = row
-        else:
-            dset.append(row)
-
-
-def detect(stream):
-    """Returns True if given stream is valid TSV."""
-    try:
-        rows = dialect = csv.Sniffer().sniff(stream, delimiters='\t')
-        return True
-    except csv.Error:
-        return False

tablib/formats/_xls.py

@@ -1,90 +0,0 @@
-# -*- coding: utf-8 -*-
-
-""" Tablib - XLS 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
-
-
-
-title = 'xls'
-extentions = ('xls',)
-
-# special styles
-wrap = xlwt.easyxf("alignment: wrap on")
-bold = xlwt.easyxf("font: bold on")
-
-
-def export_set(dataset):
-    """Returns XLS representation of Dataset."""
-
-    wb = xlwt.Workbook(encoding='utf8')
-    ws = wb.add_sheet(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 = xlwt.Workbook(encoding='utf8')
-
-    for i, dset in enumerate(databook._datasets):
-        ws = wb.add_sheet(dset.title if dset.title else 'Sheet%s' % (i))
-
-        dset_sheet(dset, ws)
-
-
-    stream = BytesIO()
-    wb.save(stream)
-    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):
-        for j, col in enumerate(row):
-
-            # bold headers
-            if (i == 0) and dataset.headers:
-                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.write(i, j, col, bold)
-
-            # wrap the rest
-            else:
-                try:
-                    if '\n' in col:
-                        ws.write(i, j, col, wrap)
-                    else:
-                        ws.write(i, j, col)
-                except TypeError:
-                    ws.write(i, j, col)
-
-

tablib/formats/_yaml.py

@@ -1,63 +0,0 @@
-# -*- coding: utf-8 -*-
-
-""" Tablib - YAML Support.
-"""
-
-import sys
-
-try:
-    import yaml
-except ImportError:
-    if sys.version_info[0] > 2:
-        import tablib.packages.yaml3 as yaml
-    else:
-        import tablib.packages.yaml as yaml
-    
-
-import tablib
-
-
-
-title = 'yaml'
-extentions = ('yaml', 'yml')
-
-
-
-def export_set(dataset):
-    """Returns YAML representation of Dataset."""
-    return yaml.dump(dataset.dict)
-
-
-def export_book(databook):
-    """Returns YAML representation of Databook."""
-    return yaml.dump(databook._package())
-
-
-def import_set(dset, in_stream):
-    """Returns dataset from YAML stream."""
-
-    dset.wipe()
-    dset.dict = yaml.load(in_stream)
-
-
-def import_book(dbook, in_stream):
-    """Returns databook from YAML stream."""
-
-    dbook.wipe()
-
-    for sheet in yaml.load(in_stream):
-        data = tablib.Dataset()
-        data.title = sheet['title']
-        data.dict = sheet['data']
-        dbook.add_sheet(data)
-        
-def detect(stream):
-    """Returns True if given stream is valid YAML."""
-    try:
-        _yaml = yaml.load(stream)
-        if isinstance(_yaml, (list, tuple, dict)):
-            return True
-        else:
-            return False
-    except yaml.parser.ParserError:
-        return False

tablib/packages/anyjson.py

@@ -1,117 +0,0 @@
-"""
-Wraps the best available JSON implementation available in a common interface
-"""
-
-__version__ = "0.2.0"
-__author__ = "Rune Halvorsen <runefh@gmail.com>"
-__homepage__ = "http://bitbucket.org/runeh/anyjson/"
-__docformat__ = "restructuredtext"
-
-"""
-
-.. function:: serialize(obj)
-
-    Serialize the object to JSON.
-
-.. function:: deserialize(str)
-
-    Deserialize JSON-encoded object to a Python object.
-
-.. function:: force_implementation(name)
-
-    Load a specific json module. This is useful for testing and not much else
-
-.. attribute:: implementation
-
-    The json implementation object. This is probably not useful to you,
-    except to get the name of the implementation in use. The name is
-    available through `implementation.name`.
-"""
-
-import sys
-
-implementation = None
-
-"""
-.. data:: _modules
-
-    List of known json modules, and the names of their serialize/unserialize
-    methods, as well as the exception they throw. Exception can be either
-    an exception class or a string.
-"""
-_modules = [("cjson", "encode", "EncodeError", "decode", "DecodeError"),
-            ("jsonlib2", "write", "WriteError", "read", "ReadError"),
-            ("jsonlib", "write", "WriteError", "read", "ReadError"),
-            ("simplejson", "dumps", TypeError, "loads", ValueError),
-            ("json", "dumps", TypeError, "loads", ValueError),
-            ("django.utils.simplejson", "dumps", TypeError, "loads",
-             ValueError)]
-_fields = ("modname", "encoder", "encerror", "decoder", "decerror")
-
-
-class _JsonImplementation(object):
-    """Incapsulates a JSON implementation"""
-
-    def __init__(self, modspec):
-        modinfo = dict(list(zip(_fields, modspec)))
-
-        # No try block. We want importerror to end up at caller
-        module = self._attempt_load(modinfo["modname"])
-
-        self.implementation = modinfo["modname"]
-        self._encode = getattr(module, modinfo["encoder"])
-        self._decode = getattr(module, modinfo["decoder"])
-        self._encode_error = modinfo["encerror"]
-        self._decode_error = modinfo["decerror"]
-
-        if isinstance(modinfo["encerror"], str):
-            self._encode_error = getattr(module, modinfo["encerror"])
-        if isinstance(modinfo["decerror"], str):
-            self._decode_error = getattr(module, modinfo["decerror"])
-
-        self.name = modinfo["modname"]
-
-    def _attempt_load(self, modname):
-        """Attempt to load module name modname, returning it on success,
-        throwing ImportError if module couldn't be imported"""
-        __import__(modname)
-        return sys.modules[modname]
-
-    def serialize(self, data):
-        """Serialize the datastructure to json. Returns a string. Raises
-        TypeError if the object could not be serialized."""
-        try:
-            return self._encode(data)
-        except self._encode_error as exc:
-            raise TypeError(*exc.args)
-
-    def deserialize(self, s):
-        """deserialize the string to python data types. Raises
-        ValueError if the string vould not be parsed."""
-        try:
-            return self._decode(s)
-        except self._decode_error as exc:
-            raise ValueError(*exc.args)
-
-
-def force_implementation(modname):
-    """Forces anyjson to use a specific json module if it's available"""
-    global implementation
-    for name, spec in [(e[0], e) for e in _modules]:
-        if name == modname:
-            implementation = _JsonImplementation(spec)
-            return
-    raise ImportError("No module named: %s" % modname)
-
-
-for modspec in _modules:
-    try:
-        implementation = _JsonImplementation(modspec)
-        break
-    except ImportError:
-        pass
-else:
-    raise ImportError("No supported JSON module found")
-
-serialize = lambda value: implementation.serialize(value)
-deserialize = lambda value: implementation.deserialize(value)

tablib/packages/anyjson25.py

@@ -1,118 +0,0 @@
-u"""
-Wraps the best available JSON implementation available in a common interface
-"""
-
-__version__ = u"0.2.0"
-__author__ = u"Rune Halvorsen <runefh@gmail.com>"
-__homepage__ = u"http://bitbucket.org/runeh/anyjson/"
-__docformat__ = u"restructuredtext"
-
-u"""
-
-.. function:: serialize(obj)
-
-    Serialize the object to JSON.
-
-.. function:: deserialize(str)
-
-    Deserialize JSON-encoded object to a Python object.
-
-.. function:: force_implementation(name)
-
-    Load a specific json module. This is useful for testing and not much else
-
-.. attribute:: implementation
-
-    The json implementation object. This is probably not useful to you,
-    except to get the name of the implementation in use. The name is
-    available through `implementation.name`.
-"""
-
-import sys
-from itertools import izip
-
-implementation = None
-
-u"""
-.. data:: _modules
-
-    List of known json modules, and the names of their serialize/unserialize
-    methods, as well as the exception they throw. Exception can be either
-    an exception class or a string.
-"""
-_modules = [(u"cjson", u"encode", u"EncodeError", u"decode", u"DecodeError"),
-            (u"jsonlib2", u"write", u"WriteError", u"read", u"ReadError"),
-            (u"jsonlib", u"write", u"WriteError", u"read", u"ReadError"),
-            (u"simplejson", u"dumps", TypeError, u"loads", ValueError),
-            (u"json", u"dumps", TypeError, u"loads", ValueError),
-            (u"django.utils.simplejson", u"dumps", TypeError, u"loads",
-             ValueError)]
-_fields = (u"modname", u"encoder", u"encerror", u"decoder", u"decerror")
-
-
-class _JsonImplementation(object):
-    u"""Incapsulates a JSON implementation"""
-
-    def __init__(self, modspec):
-        modinfo = dict(list(izip(_fields, modspec)))
-
-        # No try block. We want importerror to end up at caller
-        module = self._attempt_load(modinfo[u"modname"])
-
-        self.implementation = modinfo[u"modname"]
-        self._encode = getattr(module, modinfo[u"encoder"])
-        self._decode = getattr(module, modinfo[u"decoder"])
-        self._encode_error = modinfo[u"encerror"]
-        self._decode_error = modinfo[u"decerror"]
-
-        if isinstance(modinfo[u"encerror"], unicode):
-            self._encode_error = getattr(module, modinfo[u"encerror"])
-        if isinstance(modinfo[u"decerror"], unicode):
-            self._decode_error = getattr(module, modinfo[u"decerror"])
-
-        self.name = modinfo[u"modname"]
-
-    def _attempt_load(self, modname):
-        u"""Attempt to load module name modname, returning it on success,
-        throwing ImportError if module couldn't be imported"""
-        __import__(modname)
-        return sys.modules[modname]
-
-    def serialize(self, data):
-        u"""Serialize the datastructure to json. Returns a string. Raises
-        TypeError if the object could not be serialized."""
-        try:
-            return self._encode(data)
-        except self._encode_error, exc:
-            raise TypeError(*exc.args)
-
-    def deserialize(self, s):
-        u"""deserialize the string to python data types. Raises
-        ValueError if the string vould not be parsed."""
-        try:
-            return self._decode(s)
-        except self._decode_error, exc:
-            raise ValueError(*exc.args)
-
-
-def force_implementation(modname):
-    u"""Forces anyjson to use a specific json module if it's available"""
-    global implementation
-    for name, spec in [(e[0], e) for e in _modules]:
-        if name == modname:
-            implementation = _JsonImplementation(spec)
-            return
-    raise ImportError(u"No module named: %s" % modname)
-
-
-for modspec in _modules:
-    try:
-        implementation = _JsonImplementation(modspec)
-        break
-    except ImportError:
-        pass
-else:
-    raise ImportError(u"No supported JSON module found")
-
-serialize = lambda value: implementation.serialize(value)
-deserialize = lambda value: implementation.deserialize(value)

tablib/packages/markup.py

@@ -1,484 +0,0 @@
-# This code is in the public domain, it comes
-# with absolutely no warranty and you can do
-# absolutely whatever you want with it.
-
-__date__ = '17 May 2007'
-__version__ = '1.7'
-__doc__= """
-This is markup.py - a Python module that attempts to
-make it easier to generate HTML/XML from a Python program
-in an intuitive, lightweight, customizable and pythonic way.
-
-The code is in the public domain.
-
-Version: %s as of %s.
-
-Documentation and further info is at http://markup.sourceforge.net/
-
-Please send bug reports, feature requests, enhancement
-ideas or questions to nogradi at gmail dot com.
-
-Installation: drop markup.py somewhere into your Python path.
-""" % ( __version__, __date__ )
-
-import string
-
-class element:
-    """This class handles the addition of a new element."""
-
-    def __init__( self, tag, case='lower', parent=None ):
-        self.parent = parent
-
-        if case == 'lower':
-            self.tag = tag.lower( )
-        else:
-            self.tag = tag.upper( )
-    
-    def __call__( self, *args, **kwargs ):
-        if len( args ) > 1:
-            raise ArgumentError( self.tag )
-
-        # if class_ was defined in parent it should be added to every element
-        if self.parent is not None and self.parent.class_ is not None:
-            if 'class_' not in kwargs:
-                kwargs['class_'] = self.parent.class_
-            
-        if self.parent is None and len( args ) == 1:
-            x = [ self.render( self.tag, False, myarg, mydict ) for myarg, mydict in _argsdicts( args, kwargs ) ]
-            return '\n'.join( x )
-        elif self.parent is None and len( args ) == 0:
-            x = [ self.render( self.tag, True, myarg, mydict ) for myarg, mydict in _argsdicts( args, kwargs ) ]
-            return '\n'.join( x )
-            
-        if self.tag in self.parent.twotags:
-            for myarg, mydict in _argsdicts( args, kwargs ):
-                self.render( self.tag, False, myarg, mydict )
-        elif self.tag in self.parent.onetags:
-            if len( args ) == 0:
-                for myarg, mydict in _argsdicts( args, kwargs ):
-                    self.render( self.tag, True, myarg, mydict )    # here myarg is always None, because len( args ) = 0
-            else:
-                raise ClosingError( self.tag )
-        elif self.parent.mode == 'strict_html' and self.tag in self.parent.deptags:
-            raise DeprecationError( self.tag )
-        else:
-            raise InvalidElementError( self.tag, self.parent.mode )
-    
-    def render( self, tag, single, between, kwargs ):
-        """Append the actual tags to content."""
-
-        out = "<%s" % tag
-        for key, value in kwargs.iteritems( ):
-            if value is not None:               # when value is None that means stuff like <... checked>
-                key = key.strip('_')            # strip this so class_ will mean class, etc.
-                if key == 'http_equiv':         # special cases, maybe change _ to - overall?
-                    key = 'http-equiv'
-                elif key == 'accept_charset':
-                    key = 'accept-charset'
-                out = "%s %s=\"%s\"" % ( out, key, escape( value ) )
-            else:
-                out = "%s %s" % ( out, key )
-        if between is not None:
-            out = "%s>%s</%s>" % ( out, between, tag )
-        else:
-            if single:
-                out = "%s />" % out
-            else:
-                out = "%s>" % out
-        if self.parent is not None:
-            self.parent.content.append( out )
-        else:
-            return out
-    
-    def close( self ):
-        """Append a closing tag unless element has only opening tag."""
-
-        if self.tag in self.parent.twotags:
-            self.parent.content.append( "</%s>" % self.tag )
-        elif self.tag in self.parent.onetags:
-            raise ClosingError( self.tag )
-        elif self.parent.mode == 'strict_html' and self.tag in self.parent.deptags:
-            raise DeprecationError( self.tag )
-
-    def open( self, **kwargs ):
-        """Append an opening tag."""
-
-        if self.tag in self.parent.twotags or self.tag in self.parent.onetags:
-            self.render( self.tag, False, None, kwargs )
-        elif self.mode == 'strict_html' and self.tag in self.parent.deptags:
-            raise DeprecationError( self.tag )
-
-class page:
-    """This is our main class representing a document. Elements are added
-    as attributes of an instance of this class."""
-
-    def __init__( self, mode='strict_html', case='lower', onetags=None, twotags=None, separator='\n', class_=None ):
-        """Stuff that effects the whole document.
-
-        mode -- 'strict_html'   for HTML 4.01 (default)
-                'html'          alias for 'strict_html'
-                'loose_html'    to allow some deprecated elements
-                'xml'           to allow arbitrary elements
-
-        case -- 'lower'         element names will be printed in lower case (default)
-                'upper'         they will be printed in upper case
-
-        onetags --              list or tuple of valid elements with opening tags only
-        twotags --              list or tuple of valid elements with both opening and closing tags
-                                these two keyword arguments may be used to select
-                                the set of valid elements in 'xml' mode
-                                invalid elements will raise appropriate exceptions
-        
-        separator --            string to place between added elements, defaults to newline
-        
-        class_ --               a class that will be added to every element if defined"""
-        
-        valid_onetags = [ "AREA", "BASE", "BR", "COL", "FRAME", "HR", "IMG", "INPUT", "LINK", "META", "PARAM" ]
-        valid_twotags = [ "A", "ABBR", "ACRONYM", "ADDRESS", "B", "BDO", "BIG", "BLOCKQUOTE", "BODY", "BUTTON",
-                "CAPTION", "CITE", "CODE", "COLGROUP", "DD", "DEL", "DFN", "DIV", "DL", "DT", "EM", "FIELDSET",
-                "FORM", "FRAMESET", "H1", "H2", "H3", "H4", "H5", "H6", "HEAD", "HTML", "I", "IFRAME", "INS",
-                "KBD", "LABEL", "LEGEND", "LI", "MAP", "NOFRAMES", "NOSCRIPT", "OBJECT", "OL", "OPTGROUP",
-                "OPTION", "P", "PRE", "Q", "SAMP", "SCRIPT", "SELECT", "SMALL", "SPAN", "STRONG", "STYLE",
-                "SUB", "SUP", "TABLE", "TBODY", "TD", "TEXTAREA", "TFOOT", "TH", "THEAD", "TITLE", "TR",
-                "TT", "UL", "VAR" ]
-        deprecated_onetags = [ "BASEFONT", "ISINDEX" ]
-        deprecated_twotags = [ "APPLET", "CENTER", "DIR", "FONT", "MENU", "S", "STRIKE", "U" ]
-
-        self.header = [ ]
-        self.content = [ ]
-        self.footer = [ ]
-        self.case = case
-        self.separator = separator
-
-        # init( ) sets it to True so we know that </body></html> has to be printed at the end
-        self._full = False
-        self.class_= class_
-
-        if mode == 'strict_html' or mode == 'html':
-            self.onetags = valid_onetags
-            self.onetags += map( string.lower, self.onetags )
-            self.twotags = valid_twotags
-            self.twotags += map( string.lower, self.twotags )
-            self.deptags = deprecated_onetags + deprecated_twotags
-            self.deptags += map( string.lower, self.deptags )
-            self.mode = 'strict_html'
-        elif mode == 'loose_html':
-            self.onetags = valid_onetags + deprecated_onetags 
-            self.onetags += map( string.lower, self.onetags )
-            self.twotags = valid_twotags + deprecated_twotags
-            self.twotags += map( string.lower, self.twotags )
-            self.mode = mode
-        elif mode == 'xml':
-            if onetags and twotags:
-                self.onetags = onetags
-                self.twotags = twotags
-            elif ( onetags and not twotags ) or ( twotags and not onetags ):
-                raise CustomizationError( )
-            else:
-                self.onetags = russell( )
-                self.twotags = russell( )
-            self.mode = mode
-        else:
-            raise ModeError( mode )
-
-    def __getattr__( self, attr ):
-        if attr.startswith("__") and attr.endswith("__"):
-            raise AttributeError, attr
-        return element( attr, case=self.case, parent=self )
-
-    def __str__( self ):
-        
-        if self._full and ( self.mode == 'strict_html' or self.mode == 'loose_html' ):
-            end = [ '</body>', '</html>' ]
-        else:
-            end = [ ]
-        
-        return self.separator.join( self.header + self.content + self.footer + end )
-
-    def __call__( self, escape=False ):
-        """Return the document as a string.
-
-        escape --   False   print normally
-                    True    replace < and > by &lt; and &gt;
-                            the default escape sequences in most browsers"""
-
-        if escape:
-            return _escape( self.__str__( ) )
-        else:
-            return self.__str__( )
-
-    def add( self, text ):
-        """This is an alias to addcontent."""
-        self.addcontent( text )
-
-    def addfooter( self, text ):
-        """Add some text to the bottom of the document"""
-        self.footer.append( text )
-
-    def addheader( self, text ):
-        """Add some text to the top of the document"""
-        self.header.append( text )
-
-    def addcontent( self, text ):
-        """Add some text to the main part of the document"""
-        self.content.append( text )
-
-
-    def init( self, lang='en', css=None, metainfo=None, title=None, header=None,
-              footer=None, charset=None, encoding=None, doctype=None, bodyattrs=None, script=None ):
-        """This method is used for complete documents with appropriate
-        doctype, encoding, title, etc information. For an HTML/XML snippet
-        omit this method.
-
-        lang --     language, usually a two character string, will appear
-                    as <html lang='en'> in html mode (ignored in xml mode)
-        
-        css --      Cascading Style Sheet filename as a string or a list of
-                    strings for multiple css files (ignored in xml mode)
-
-        metainfo -- a dictionary in the form { 'name':'content' } to be inserted
-                    into meta element(s) as <meta name='name' content='content'>
-                    (ignored in xml mode)
-
-        bodyattrs --a dictionary in the form { 'key':'value', ... } which will be added
-                    as attributes of the <body> element as <body key='value' ... >
-                    (ignored in xml mode)
-
-        script --   dictionary containing src:type pairs, <script type='text/type' src=src></script>
-
-        title --    the title of the document as a string to be inserted into
-                    a title element as <title>my title</title> (ignored in xml mode)
-
-        header --   some text to be inserted right after the <body> element
-                    (ignored in xml mode)
-
-        footer --   some text to be inserted right before the </body> element
-                    (ignored in xml mode)
-
-        charset --  a string defining the character set, will be inserted into a
-                    <meta http-equiv='Content-Type' content='text/html; charset=myset'>
-                    element (ignored in xml mode)
-
-        encoding -- a string defining the encoding, will be put into to first line of
-                    the document as <?xml version='1.0' encoding='myencoding' ?> in
-                    xml mode (ignored in html mode)
-
-        doctype --  the document type string, defaults to
-                    <!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN'>
-                    in html mode (ignored in xml mode)"""
-
-        self._full = True
-
-        if self.mode == 'strict_html' or self.mode == 'loose_html':
-            if doctype is None:
-                doctype = "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN'>"
-            self.header.append( doctype )
-            self.html( lang=lang )
-            self.head( )
-            if charset is not None:
-                self.meta( http_equiv='Content-Type', content="text/html; charset=%s" % charset )
-            if metainfo is not None:
-                self.metainfo( metainfo )
-            if css is not None:
-                self.css( css )
-            if title is not None:
-                self.title( title )
-            if script is not None:
-                self.scripts( script )
-            self.head.close()
-            if bodyattrs is not None:
-                self.body( **bodyattrs )
-            else:
-                self.body( )
-            if header is not None:
-                self.content.append( header )
-            if footer is not None:
-                self.footer.append( footer )
-
-        elif self.mode == 'xml':
-            if doctype is None:
-                if encoding is not None:
-                    doctype = "<?xml version='1.0' encoding='%s' ?>" % encoding
-                else:
-                    doctype = "<?xml version='1.0' ?>"
-            self.header.append( doctype )
-
-    def css( self, filelist ):
-        """This convenience function is only useful for html.
-        It adds css stylesheet(s) to the document via the <link> element."""
-      
-        if isinstance( filelist, basestring ):
-            self.link( href=filelist, rel='stylesheet', type='text/css', media='all' )
-        else:
-            for file in filelist:
-                self.link( href=file, rel='stylesheet', type='text/css', media='all' )
-
-    def metainfo( self, mydict ):
-        """This convenience function is only useful for html.
-        It adds meta information via the <meta> element, the argument is
-        a dictionary of the form { 'name':'content' }."""
-
-        if isinstance( mydict, dict ):
-            for name, content in mydict.iteritems( ):
-                self.meta( name=name, content=content )
-        else:
-            raise TypeError, "Metainfo should be called with a dictionary argument of name:content pairs."
-
-    def scripts( self, mydict ):
-        """Only useful in html, mydict is dictionary of src:type pairs will
-        be rendered as <script type='text/type' src=src></script>"""
-
-        if isinstance( mydict, dict ):
-            for src, type in mydict.iteritems( ):
-                self.script( '', src=src, type='text/%s' % type )
-        else:
-            raise TypeError, "Script should be given a dictionary of src:type pairs."
-
-
-class _oneliner:
-    """An instance of oneliner returns a string corresponding to one element.
-    This class can be used to write 'oneliners' that return a string
-    immediately so there is no need to instantiate the page class."""
-    
-    def __init__( self, case='lower' ):
-        self.case = case
-    
-    def __getattr__( self, attr ):
-        if attr.startswith("__") and attr.endswith("__"):
-            raise AttributeError, attr
-        return element( attr, case=self.case, parent=None )
-
-oneliner = _oneliner( case='lower' )
-upper_oneliner = _oneliner( case='upper' )
-
-def _argsdicts( args, mydict ):
-    """A utility generator that pads argument list and dictionary values, will only be called with len( args ) = 0, 1."""
-    
-    if len( args ) == 0:
-        args = None, 
-    elif len( args ) == 1:
-        args = _totuple( args[0] )
-    else:
-        raise Exception, "We should have never gotten here."
-
-    mykeys = mydict.keys( )
-    myvalues = map( _totuple, mydict.values( ) )
-
-    maxlength = max( map( len, [ args ] + myvalues ) )
-
-    for i in xrange( maxlength ):
-        thisdict = { }
-        for key, value in zip( mykeys, myvalues ):
-            try:
-                thisdict[ key ] = value[i]
-            except IndexError:
-                thisdict[ key ] = value[-1]
-        try:
-            thisarg = args[i]
-        except IndexError:
-            thisarg = args[-1]
-
-        yield thisarg, thisdict
-
-def _totuple( x ):
-    """Utility stuff to convert string, int, float, None or anything to a usable tuple."""
-
-    if isinstance( x, basestring ):
-        out = x,
-    elif isinstance( x, ( int, float ) ):
-        out = str( x ),
-    elif x is None:
-        out = None,
-    else:
-        out = tuple( x )
-
-    return out
-
-def escape( text, newline=False ):
-    """Escape special html characters."""
-
-    if isinstance( text, basestring ):
-        if '&' in text:
-            text = text.replace( '&', '&amp;' )
-        if '>' in text:
-            text = text.replace( '>', '&gt;' )
-        if '<' in text:
-            text = text.replace( '<', '&lt;' )
-        if '\"' in text:
-            text = text.replace( '\"', '&quot;' )
-        if '\'' in text:
-            text = text.replace( '\'', '&quot;' )
-        if newline:
-            if '\n' in text:
-                text = text.replace( '\n', '<br>' )
-
-    return text
-
-_escape = escape
-
-def unescape( text ):
-    """Inverse of escape."""
-    
-    if isinstance( text, basestring ):
-        if '&amp;' in text:
-            text = text.replace( '&amp;', '&' )
-        if '&gt;' in text:
-            text = text.replace( '&gt;', '>' )
-        if '&lt;' in text:
-            text = text.replace( '&lt;', '<' )
-        if '&quot;' in text:
-            text = text.replace( '&quot;', '\"' )
-
-    return text
-
-class dummy:
-    """A dummy class for attaching attributes."""
-    pass
-
-doctype = dummy( )
-doctype.frameset = "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Frameset//EN' 'http://www.w3.org/TR/html4/frameset.dtd'>"
-doctype.strict = "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01//EN' 'http://www.w3.org/TR/html4/strict.dtd'>"
-doctype.loose = "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN' 'http://www.w3.org/TR/html4/loose.dtd'>"
-
-class russell:
-    """A dummy class that contains anything."""
-
-    def __contains__( self, item ):
-        return True
-
-
-class MarkupError( Exception ):
-    """All our exceptions subclass this."""
-    def __str__( self ):
-        return self.message
-
-class ClosingError( MarkupError ):
-    def __init__( self, tag ):
-        self.message = "The element '%s' does not accept non-keyword arguments (has no closing tag)." % tag
-
-class OpeningError( MarkupError ):
-    def __init__( self, tag ):
-        self.message = "The element '%s' can not be opened." % tag
-
-class ArgumentError( MarkupError ):
-    def __init__( self, tag ):
-        self.message = "The element '%s' was called with more than one non-keyword argument." % tag
-
-class InvalidElementError( MarkupError ):
-    def __init__( self, tag, mode ):
-        self.message = "The element '%s' is not valid for your mode '%s'." % ( tag, mode )
-
-class DeprecationError( MarkupError ):
-    def __init__( self, tag ):
-        self.message = "The element '%s' is deprecated, instantiate markup.page with mode='loose_html' to allow it." % tag
-
-class ModeError( MarkupError ):
-    def __init__( self, mode ):
-        self.message = "Mode '%s' is invalid, possible values: strict_html, loose_html, xml." % mode
-
-class CustomizationError( MarkupError ):
-    def __init__( self ):
-        self.message = "If you customize the allowed elements, you must define both types 'onetags' and 'twotags'."
-
-if __name__ == '__main__':
-    print __doc__

tablib/packages/markup3.py

@@ -1,484 +0,0 @@
-# This code is in the public domain, it comes
-# with absolutely no warranty and you can do
-# absolutely whatever you want with it.
-
-__date__ = '17 May 2007'
-__version__ = '1.7'
-__doc__= """
-This is markup.py - a Python module that attempts to
-make it easier to generate HTML/XML from a Python program
-in an intuitive, lightweight, customizable and pythonic way.
-
-The code is in the public domain.
-
-Version: %s as of %s.
-
-Documentation and further info is at http://markup.sourceforge.net/
-
-Please send bug reports, feature requests, enhancement
-ideas or questions to nogradi at gmail dot com.
-
-Installation: drop markup.py somewhere into your Python path.
-""" % ( __version__, __date__ )
-
-import string
-
-class element:
-    """This class handles the addition of a new element."""
-
-    def __init__( self, tag, case='lower', parent=None ):
-        self.parent = parent
-
-        if case == 'lower':
-            self.tag = tag.lower( )
-        else:
-            self.tag = tag.upper( )
-    
-    def __call__( self, *args, **kwargs ):
-        if len( args ) > 1:
-            raise ArgumentError( self.tag )
-
-        # if class_ was defined in parent it should be added to every element
-        if self.parent is not None and self.parent.class_ is not None:
-            if 'class_' not in kwargs:
-                kwargs['class_'] = self.parent.class_
-            
-        if self.parent is None and len( args ) == 1:
-            x = [ self.render( self.tag, False, myarg, mydict ) for myarg, mydict in _argsdicts( args, kwargs ) ]
-            return '\n'.join( x )
-        elif self.parent is None and len( args ) == 0:
-            x = [ self.render( self.tag, True, myarg, mydict ) for myarg, mydict in _argsdicts( args, kwargs ) ]
-            return '\n'.join( x )
-            
-        if self.tag in self.parent.twotags:
-            for myarg, mydict in _argsdicts( args, kwargs ):
-                self.render( self.tag, False, myarg, mydict )
-        elif self.tag in self.parent.onetags:
-            if len( args ) == 0:
-                for myarg, mydict in _argsdicts( args, kwargs ):
-                    self.render( self.tag, True, myarg, mydict )    # here myarg is always None, because len( args ) = 0
-            else:
-                raise ClosingError( self.tag )
-        elif self.parent.mode == 'strict_html' and self.tag in self.parent.deptags:
-            raise DeprecationError( self.tag )
-        else:
-            raise InvalidElementError( self.tag, self.parent.mode )
-    
-    def render( self, tag, single, between, kwargs ):
-        """Append the actual tags to content."""
-
-        out = "<%s" % tag
-        for key, value in kwargs.items( ):
-            if value is not None:               # when value is None that means stuff like <... checked>
-                key = key.strip('_')            # strip this so class_ will mean class, etc.
-                if key == 'http_equiv':         # special cases, maybe change _ to - overall?
-                    key = 'http-equiv'
-                elif key == 'accept_charset':
-                    key = 'accept-charset'
-                out = "%s %s=\"%s\"" % ( out, key, escape( value ) )
-            else:
-                out = "%s %s" % ( out, key )
-        if between is not None:
-            out = "%s>%s</%s>" % ( out, between, tag )
-        else:
-            if single:
-                out = "%s />" % out
-            else:
-                out = "%s>" % out
-        if self.parent is not None:
-            self.parent.content.append( out )
-        else:
-            return out
-    
-    def close( self ):
-        """Append a closing tag unless element has only opening tag."""
-
-        if self.tag in self.parent.twotags:
-            self.parent.content.append( "</%s>" % self.tag )
-        elif self.tag in self.parent.onetags:
-            raise ClosingError( self.tag )
-        elif self.parent.mode == 'strict_html' and self.tag in self.parent.deptags:
-            raise DeprecationError( self.tag )
-
-    def open( self, **kwargs ):
-        """Append an opening tag."""
-
-        if self.tag in self.parent.twotags or self.tag in self.parent.onetags:
-            self.render( self.tag, False, None, kwargs )
-        elif self.mode == 'strict_html' and self.tag in self.parent.deptags:
-            raise DeprecationError( self.tag )
-
-class page:
-    """This is our main class representing a document. Elements are added
-    as attributes of an instance of this class."""
-
-    def __init__( self, mode='strict_html', case='lower', onetags=None, twotags=None, separator='\n', class_=None ):
-        """Stuff that effects the whole document.
-
-        mode -- 'strict_html'   for HTML 4.01 (default)
-                'html'          alias for 'strict_html'
-                'loose_html'    to allow some deprecated elements
-                'xml'           to allow arbitrary elements
-
-        case -- 'lower'         element names will be printed in lower case (default)
-                'upper'         they will be printed in upper case
-
-        onetags --              list or tuple of valid elements with opening tags only
-        twotags --              list or tuple of valid elements with both opening and closing tags
-                                these two keyword arguments may be used to select
-                                the set of valid elements in 'xml' mode
-                                invalid elements will raise appropriate exceptions
-        
-        separator --            string to place between added elements, defaults to newline
-        
-        class_ --               a class that will be added to every element if defined"""
-        
-        valid_onetags = [ "AREA", "BASE", "BR", "COL", "FRAME", "HR", "IMG", "INPUT", "LINK", "META", "PARAM" ]
-        valid_twotags = [ "A", "ABBR", "ACRONYM", "ADDRESS", "B", "BDO", "BIG", "BLOCKQUOTE", "BODY", "BUTTON",
-                "CAPTION", "CITE", "CODE", "COLGROUP", "DD", "DEL", "DFN", "DIV", "DL", "DT", "EM", "FIELDSET",
-                "FORM", "FRAMESET", "H1", "H2", "H3", "H4", "H5", "H6", "HEAD", "HTML", "I", "IFRAME", "INS",
-                "KBD", "LABEL", "LEGEND", "LI", "MAP", "NOFRAMES", "NOSCRIPT", "OBJECT", "OL", "OPTGROUP",
-                "OPTION", "P", "PRE", "Q", "SAMP", "SCRIPT", "SELECT", "SMALL", "SPAN", "STRONG", "STYLE",
-                "SUB", "SUP", "TABLE", "TBODY", "TD", "TEXTAREA", "TFOOT", "TH", "THEAD", "TITLE", "TR",
-                "TT", "UL", "VAR" ]
-        deprecated_onetags = [ "BASEFONT", "ISINDEX" ]
-        deprecated_twotags = [ "APPLET", "CENTER", "DIR", "FONT", "MENU", "S", "STRIKE", "U" ]
-
-        self.header = [ ]
-        self.content = [ ]
-        self.footer = [ ]
-        self.case = case
-        self.separator = separator
-
-        # init( ) sets it to True so we know that </body></html> has to be printed at the end
-        self._full = False
-        self.class_= class_
-
-        if mode == 'strict_html' or mode == 'html':
-            self.onetags = valid_onetags
-            self.onetags += list(map( str.lower, self.onetags ))
-            self.twotags = valid_twotags
-            self.twotags += list(map( str.lower, self.twotags ))
-            self.deptags = deprecated_onetags + deprecated_twotags
-            self.deptags += list(map( str.lower, self.deptags ))
-            self.mode = 'strict_html'
-        elif mode == 'loose_html':
-            self.onetags = valid_onetags + deprecated_onetags 
-            self.onetags += list(map( str.lower, self.onetags ))
-            self.twotags = valid_twotags + deprecated_twotags
-            self.twotags += list(map( str.lower, self.twotags ))
-            self.mode = mode
-        elif mode == 'xml':
-            if onetags and twotags:
-                self.onetags = onetags
-                self.twotags = twotags
-            elif ( onetags and not twotags ) or ( twotags and not onetags ):
-                raise CustomizationError( )
-            else:
-                self.onetags = russell( )
-                self.twotags = russell( )
-            self.mode = mode
-        else:
-            raise ModeError( mode )
-
-    def __getattr__( self, attr ):
-        if attr.startswith("__") and attr.endswith("__"):
-            raise AttributeError(attr)
-        return element( attr, case=self.case, parent=self )
-
-    def __str__( self ):
-        
-        if self._full and ( self.mode == 'strict_html' or self.mode == 'loose_html' ):
-            end = [ '</body>', '</html>' ]
-        else:
-            end = [ ]
-        
-        return self.separator.join( self.header + self.content + self.footer + end )
-
-    def __call__( self, escape=False ):
-        """Return the document as a string.
-
-        escape --   False   print normally
-                    True    replace < and > by &lt; and &gt;
-                            the default escape sequences in most browsers"""
-
-        if escape:
-            return _escape( self.__str__( ) )
-        else:
-            return self.__str__( )
-
-    def add( self, text ):
-        """This is an alias to addcontent."""
-        self.addcontent( text )
-
-    def addfooter( self, text ):
-        """Add some text to the bottom of the document"""
-        self.footer.append( text )
-
-    def addheader( self, text ):
-        """Add some text to the top of the document"""
-        self.header.append( text )
-
-    def addcontent( self, text ):
-        """Add some text to the main part of the document"""
-        self.content.append( text )
-
-
-    def init( self, lang='en', css=None, metainfo=None, title=None, header=None,
-              footer=None, charset=None, encoding=None, doctype=None, bodyattrs=None, script=None ):
-        """This method is used for complete documents with appropriate
-        doctype, encoding, title, etc information. For an HTML/XML snippet
-        omit this method.
-
-        lang --     language, usually a two character string, will appear
-                    as <html lang='en'> in html mode (ignored in xml mode)
-        
-        css --      Cascading Style Sheet filename as a string or a list of
-                    strings for multiple css files (ignored in xml mode)
-
-        metainfo -- a dictionary in the form { 'name':'content' } to be inserted
-                    into meta element(s) as <meta name='name' content='content'>
-                    (ignored in xml mode)
-
-        bodyattrs --a dictionary in the form { 'key':'value', ... } which will be added
-                    as attributes of the <body> element as <body key='value' ... >
-                    (ignored in xml mode)
-
-        script --   dictionary containing src:type pairs, <script type='text/type' src=src></script>
-
-        title --    the title of the document as a string to be inserted into
-                    a title element as <title>my title</title> (ignored in xml mode)
-
-        header --   some text to be inserted right after the <body> element
-                    (ignored in xml mode)
-
-        footer --   some text to be inserted right before the </body> element
-                    (ignored in xml mode)
-
-        charset --  a string defining the character set, will be inserted into a
-                    <meta http-equiv='Content-Type' content='text/html; charset=myset'>
-                    element (ignored in xml mode)
-
-        encoding -- a string defining the encoding, will be put into to first line of
-                    the document as <?xml version='1.0' encoding='myencoding' ?> in
-                    xml mode (ignored in html mode)
-
-        doctype --  the document type string, defaults to
-                    <!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN'>
-                    in html mode (ignored in xml mode)"""
-
-        self._full = True
-
-        if self.mode == 'strict_html' or self.mode == 'loose_html':
-            if doctype is None:
-                doctype = "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN'>"
-            self.header.append( doctype )
-            self.html( lang=lang )
-            self.head( )
-            if charset is not None:
-                self.meta( http_equiv='Content-Type', content="text/html; charset=%s" % charset )
-            if metainfo is not None:
-                self.metainfo( metainfo )
-            if css is not None:
-                self.css( css )
-            if title is not None:
-                self.title( title )
-            if script is not None:
-                self.scripts( script )
-            self.head.close()
-            if bodyattrs is not None:
-                self.body( **bodyattrs )
-            else:
-                self.body( )
-            if header is not None:
-                self.content.append( header )
-            if footer is not None:
-                self.footer.append( footer )
-
-        elif self.mode == 'xml':
-            if doctype is None:
-                if encoding is not None:
-                    doctype = "<?xml version='1.0' encoding='%s' ?>" % encoding
-                else:
-                    doctype = "<?xml version='1.0' ?>"
-            self.header.append( doctype )
-
-    def css( self, filelist ):
-        """This convenience function is only useful for html.
-        It adds css stylesheet(s) to the document via the <link> element."""
-      
-        if isinstance( filelist, str ):
-            self.link( href=filelist, rel='stylesheet', type='text/css', media='all' )
-        else:
-            for file in filelist:
-                self.link( href=file, rel='stylesheet', type='text/css', media='all' )
-
-    def metainfo( self, mydict ):
-        """This convenience function is only useful for html.
-        It adds meta information via the <meta> element, the argument is
-        a dictionary of the form { 'name':'content' }."""
-
-        if isinstance( mydict, dict ):
-            for name, content in mydict.items( ):
-                self.meta( name=name, content=content )
-        else:
-            raise TypeError("Metainfo should be called with a dictionary argument of name:content pairs.")
-
-    def scripts( self, mydict ):
-        """Only useful in html, mydict is dictionary of src:type pairs will
-        be rendered as <script type='text/type' src=src></script>"""
-
-        if isinstance( mydict, dict ):
-            for src, type in mydict.items( ):
-                self.script( '', src=src, type='text/%s' % type )
-        else:
-            raise TypeError("Script should be given a dictionary of src:type pairs.")
-
-
-class _oneliner:
-    """An instance of oneliner returns a string corresponding to one element.
-    This class can be used to write 'oneliners' that return a string
-    immediately so there is no need to instantiate the page class."""
-    
-    def __init__( self, case='lower' ):
-        self.case = case
-    
-    def __getattr__( self, attr ):
-        if attr.startswith("__") and attr.endswith("__"):
-            raise AttributeError(attr)
-        return element( attr, case=self.case, parent=None )
-
-oneliner = _oneliner( case='lower' )
-upper_oneliner = _oneliner( case='upper' )
-
-def _argsdicts( args, mydict ):
-    """A utility generator that pads argument list and dictionary values, will only be called with len( args ) = 0, 1."""
-    
-    if len( args ) == 0:
-        args = None, 
-    elif len( args ) == 1:
-        args = _totuple( args[0] )
-    else:
-        raise Exception("We should have never gotten here.")
-
-    mykeys = list(mydict.keys( ))
-    myvalues = list(map( _totuple, list(mydict.values( )) ))
-
-    maxlength = max( list(map( len, [ args ] + myvalues )) )
-
-    for i in range( maxlength ):
-        thisdict = { }
-        for key, value in zip( mykeys, myvalues ):
-            try:
-                thisdict[ key ] = value[i]
-            except IndexError:
-                thisdict[ key ] = value[-1]
-        try:
-            thisarg = args[i]
-        except IndexError:
-            thisarg = args[-1]
-
-        yield thisarg, thisdict
-
-def _totuple( x ):
-    """Utility stuff to convert string, int, float, None or anything to a usable tuple."""
-
-    if isinstance( x, str ):
-        out = x,
-    elif isinstance( x, ( int, float ) ):
-        out = str( x ),
-    elif x is None:
-        out = None,
-    else:
-        out = tuple( x )
-
-    return out
-
-def escape( text, newline=False ):
-    """Escape special html characters."""
-
-    if isinstance( text, str ):
-        if '&' in text:
-            text = text.replace( '&', '&amp;' )
-        if '>' in text:
-            text = text.replace( '>', '&gt;' )
-        if '<' in text:
-            text = text.replace( '<', '&lt;' )
-        if '\"' in text:
-            text = text.replace( '\"', '&quot;' )
-        if '\'' in text:
-            text = text.replace( '\'', '&quot;' )
-        if newline:
-            if '\n' in text:
-                text = text.replace( '\n', '<br>' )
-
-    return text
-
-_escape = escape
-
-def unescape( text ):
-    """Inverse of escape."""
-    
-    if isinstance( text, str ):
-        if '&amp;' in text:
-            text = text.replace( '&amp;', '&' )
-        if '&gt;' in text:
-            text = text.replace( '&gt;', '>' )
-        if '&lt;' in text:
-            text = text.replace( '&lt;', '<' )
-        if '&quot;' in text:
-            text = text.replace( '&quot;', '\"' )
-
-    return text
-
-class dummy:
-    """A dummy class for attaching attributes."""
-    pass
-
-doctype = dummy( )
-doctype.frameset = "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Frameset//EN' 'http://www.w3.org/TR/html4/frameset.dtd'>"
-doctype.strict = "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01//EN' 'http://www.w3.org/TR/html4/strict.dtd'>"
-doctype.loose = "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN' 'http://www.w3.org/TR/html4/loose.dtd'>"
-
-class russell:
-    """A dummy class that contains anything."""
-
-    def __contains__( self, item ):
-        return True
-
-
-class MarkupError( Exception ):
-    """All our exceptions subclass this."""
-    def __str__( self ):
-        return self.message
-
-class ClosingError( MarkupError ):
-    def __init__( self, tag ):
-        self.message = "The element '%s' does not accept non-keyword arguments (has no closing tag)." % tag
-
-class OpeningError( MarkupError ):
-    def __init__( self, tag ):
-        self.message = "The element '%s' can not be opened." % tag
-
-class ArgumentError( MarkupError ):
-    def __init__( self, tag ):
-        self.message = "The element '%s' was called with more than one non-keyword argument." % tag
-
-class InvalidElementError( MarkupError ):
-    def __init__( self, tag, mode ):
-        self.message = "The element '%s' is not valid for your mode '%s'." % ( tag, mode )
-
-class DeprecationError( MarkupError ):
-    def __init__( self, tag ):
-        self.message = "The element '%s' is deprecated, instantiate markup.page with mode='loose_html' to allow it." % tag
-
-class ModeError( MarkupError ):
-    def __init__( self, mode ):
-        self.message = "Mode '%s' is invalid, possible values: strict_html, loose_html, xml." % mode
-
-class CustomizationError( MarkupError ):
-    def __init__( self ):
-        self.message = "If you customize the allowed elements, you must define both types 'onetags' and 'twotags'."
-
-if __name__ == '__main__':
-    print(__doc__)

tablib/packages/ordereddict.py

@@ -1,127 +0,0 @@
-# Copyright (c) 2009 Raymond Hettinger
-#
-# 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.
-
-from UserDict import DictMixin
-
-class OrderedDict(dict, DictMixin):
-
-    def __init__(self, *args, **kwds):
-        if len(args) > 1:
-            raise TypeError('expected at most 1 arguments, got %d' % len(args))
-        try:
-            self.__end
-        except AttributeError:
-            self.clear()
-        self.update(*args, **kwds)
-
-    def clear(self):
-        self.__end = end = []
-        end += [None, end, end]         # sentinel node for doubly linked list
-        self.__map = {}                 # key --> [key, prev, next]
-        dict.clear(self)
-
-    def __setitem__(self, key, value):
-        if key not in self:
-            end = self.__end
-            curr = end[1]
-            curr[2] = end[1] = self.__map[key] = [key, curr, end]
-        dict.__setitem__(self, key, value)
-
-    def __delitem__(self, key):
-        dict.__delitem__(self, key)
-        key, prev, next = self.__map.pop(key)
-        prev[2] = next
-        next[1] = prev
-
-    def __iter__(self):
-        end = self.__end
-        curr = end[2]
-        while curr is not end:
-            yield curr[0]
-            curr = curr[2]
-
-    def __reversed__(self):
-        end = self.__end
-        curr = end[1]
-        while curr is not end:
-            yield curr[0]
-            curr = curr[1]
-
-    def popitem(self, last=True):
-        if not self:
-            raise KeyError('dictionary is empty')
-        if last:
-            key = next(reversed(self))
-        else:
-            key = next(iter(self))
-        value = self.pop(key)
-        return key, value
-
-    def __reduce__(self):
-        items = [[k, self[k]] for k in self]
-        tmp = self.__map, self.__end
-        del self.__map, self.__end
-        inst_dict = vars(self).copy()
-        self.__map, self.__end = tmp
-        if inst_dict:
-            return (self.__class__, (items,), inst_dict)
-        return self.__class__, (items,)
-
-    def keys(self):
-        return list(self)
-
-    setdefault = DictMixin.setdefault
-    update = DictMixin.update
-    pop = DictMixin.pop
-    values = DictMixin.values
-    items = DictMixin.items
-    iterkeys = DictMixin.iterkeys
-    itervalues = DictMixin.itervalues
-    iteritems = DictMixin.iteritems
-
-    def __repr__(self):
-        if not self:
-            return '%s()' % (self.__class__.__name__,)
-        return '%s(%r)' % (self.__class__.__name__, list(self.items()))
-
-    def copy(self):
-        return self.__class__(self)
-
-    @classmethod
-    def fromkeys(cls, iterable, value=None):
-        d = cls()
-        for key in iterable:
-            d[key] = value
-        return d
-
-    def __eq__(self, other):
-        if isinstance(other, OrderedDict):
-            if len(self) != len(other):
-                return False
-            for p, q in  zip(list(self.items()), list(other.items())):
-                if p != q:
-                    return False
-            return True
-        return dict.__eq__(self, other)
-
-    def __ne__(self, other):
-        return not self == other

tablib/packages/xlwt/Bitmap.py

@@ -1,262 +0,0 @@
-# -*- coding: windows-1251 -*-
-
-#  Portions are Copyright (C) 2005 Roman V. Kiseliov
-#  Portions are Copyright (c) 2004 Evgeny Filatov <fufff@users.sourceforge.net>
-#  Portions are Copyright (c) 2002-2004 John McNamara (Perl Spreadsheet::WriteExcel)
-
-from BIFFRecords import BiffRecord
-from struct import *
-
-
-def _size_col(sheet, col):
-    return sheet.col_width(col)
-
-
-def _size_row(sheet, row):
-    return sheet.row_height(row)
-
-
-def _position_image(sheet, row_start, col_start, x1, y1, width, height):
-    """Calculate the vertices that define the position of the image as required by
-    the OBJ record.
-
-             +------------+------------+
-             |     A      |      B     |
-       +-----+------------+------------+
-       |     |(x1,y1)     |            |
-       |  1  |(A1)._______|______      |
-       |     |    |              |     |
-       |     |    |              |     |
-       +-----+----|    BITMAP    |-----+
-       |     |    |              |     |
-       |  2  |    |______________.     |
-       |     |            |        (B2)|
-       |     |            |     (x2,y2)|
-       +---- +------------+------------+
-
-    Example of a bitmap that covers some of the area from cell A1 to cell B2.
-
-    Based on the width and height of the bitmap we need to calculate 8 vars:
-        col_start, row_start, col_end, row_end, x1, y1, x2, y2.
-    The width and height of the cells are also variable and have to be taken into
-    account.
-    The values of col_start and row_start are passed in from the calling
-    function. The values of col_end and row_end are calculated by subtracting
-    the width and height of the bitmap from the width and height of the
-    underlying cells.
-    The vertices are expressed as a percentage of the underlying cell width as
-    follows (rhs values are in pixels):
-
-           x1 = X / W *1024
-           y1 = Y / H *256
-           x2 = (X-1) / W *1024
-           y2 = (Y-1) / H *256
-
-           Where:  X is distance from the left side of the underlying cell
-                   Y is distance from the top of the underlying cell
-                   W is the width of the cell
-                   H is the height of the cell
-
-    Note: the SDK incorrectly states that the height should be expressed as a
-    percentage of 1024.
-
-    col_start  - Col containing upper left corner of object
-    row_start  - Row containing top left corner of object
-    x1  - Distance to left side of object
-    y1  - Distance to top of object
-    width  - Width of image frame
-    height  - Height of image frame
-
-    """
-    # Adjust start column for offsets that are greater than the col width
-    while x1 >= _size_col(sheet, col_start):
-        x1 -= _size_col(sheet, col_start)
-        col_start += 1
-    # Adjust start row for offsets that are greater than the row height
-    while y1 >= _size_row(sheet, row_start):
-        y1 -= _size_row(sheet, row_start)
-        row_start += 1
-    # Initialise end cell to the same as the start cell
-    row_end = row_start   # Row containing bottom right corner of object
-    col_end = col_start   # Col containing lower right corner of object
-    width = width + x1 - 1
-    height = height + y1 - 1
-    # Subtract the underlying cell widths to find the end cell of the image
-    while (width >= _size_col(sheet, col_end)):
-        width -= _size_col(sheet, col_end)
-        col_end += 1
-    # Subtract the underlying cell heights to find the end cell of the image
-    while (height >= _size_row(sheet, row_end)):
-        height -= _size_row(sheet, row_end)
-        row_end += 1
-    # Bitmap isn't allowed to start or finish in a hidden cell, i.e. a cell
-    # with zero height or width.
-    if ((_size_col(sheet, col_start) == 0) or (_size_col(sheet, col_end) == 0)
-            or (_size_row(sheet, row_start) == 0) or (_size_row(sheet, row_end) == 0)):
-        return
-    # Convert the pixel values to the percentage value expected by Excel
-    x1 = int(float(x1) / _size_col(sheet, col_start) * 1024)
-    y1 = int(float(y1) / _size_row(sheet, row_start) * 256)
-    # Distance to right side of object
-    x2 = int(float(width) / _size_col(sheet, col_end) * 1024)
-    # Distance to bottom of object
-    y2 = int(float(height) / _size_row(sheet, row_end) * 256)
-    return (col_start, x1, row_start, y1, col_end, x2, row_end, y2)
-
-
-class ObjBmpRecord(BiffRecord):
-    _REC_ID = 0x005D    # Record identifier
-
-    def __init__(self, row, col, sheet, im_data_bmp, x, y, scale_x, scale_y):
-        # Scale the frame of the image.
-        width = im_data_bmp.width * scale_x
-        height = im_data_bmp.height * scale_y
-
-        # Calculate the vertices of the image and write the OBJ record
-        coordinates = _position_image(sheet, row, col, x, y, width, height)
-        # print coordinates
-        col_start, x1, row_start, y1, col_end, x2, row_end, y2 = coordinates
-
-        """Store the OBJ record that precedes an IMDATA record. This could be generalise
-        to support other Excel objects.
-
-        """
-        cObj = 0x0001      # Count of objects in file (set to 1)
-        OT = 0x0008        # Object type. 8 = Picture
-        id = 0x0001        # Object ID
-        grbit = 0x0614     # Option flags
-        colL = col_start    # Col containing upper left corner of object
-        dxL = x1            # Distance from left side of cell
-        rwT = row_start     # Row containing top left corner of object
-        dyT = y1            # Distance from top of cell
-        colR = col_end      # Col containing lower right corner of object
-        dxR = x2            # Distance from right of cell
-        rwB = row_end       # Row containing bottom right corner of object
-        dyB = y2            # Distance from bottom of cell
-        cbMacro = 0x0000    # Length of FMLA structure
-        Reserved1 = 0x0000  # Reserved
-        Reserved2 = 0x0000  # Reserved
-        icvBack = 0x09      # Background colour
-        icvFore = 0x09      # Foreground colour
-        fls = 0x00          # Fill pattern
-        fAuto = 0x00        # Automatic fill
-        icv = 0x08          # Line colour
-        lns = 0xff          # Line style
-        lnw = 0x01          # Line weight
-        fAutoB = 0x00       # Automatic border
-        frs = 0x0000        # Frame style
-        cf = 0x0009         # Image format, 9 = bitmap
-        Reserved3 = 0x0000  # Reserved
-        cbPictFmla = 0x0000 # Length of FMLA structure
-        Reserved4 = 0x0000  # Reserved
-        grbit2 = 0x0001     # Option flags
-        Reserved5 = 0x0000  # Reserved
-
-        data = pack("<L", cObj)
-        data += pack("<H", OT)
-        data += pack("<H", id)
-        data += pack("<H", grbit)
-        data += pack("<H", colL)
-        data += pack("<H", dxL)
-        data += pack("<H", rwT)
-        data += pack("<H", dyT)
-        data += pack("<H", colR)
-        data += pack("<H", dxR)
-        data += pack("<H", rwB)
-        data += pack("<H", dyB)
-        data += pack("<H", cbMacro)
-        data += pack("<L", Reserved1)
-        data += pack("<H", Reserved2)
-        data += pack("<B", icvBack)
-        data += pack("<B", icvFore)
-        data += pack("<B", fls)
-        data += pack("<B", fAuto)
-        data += pack("<B", icv)
-        data += pack("<B", lns)
-        data += pack("<B", lnw)
-        data += pack("<B", fAutoB)
-        data += pack("<H", frs)
-        data += pack("<L", cf)
-        data += pack("<H", Reserved3)
-        data += pack("<H", cbPictFmla)
-        data += pack("<H", Reserved4)
-        data += pack("<H", grbit2)
-        data += pack("<L", Reserved5)
-
-        self._rec_data = data
-
-def _process_bitmap(bitmap):
-    """Convert a 24 bit bitmap into the modified internal format used by Windows.
-    This is described in BITMAPCOREHEADER and BITMAPCOREINFO structures in the
-    MSDN library.
-
-    """
-    # Open file and binmode the data in case the platform needs it.
-    fh = file(bitmap, "rb")
-    try:
-        # Slurp the file into a string.
-        data = fh.read()
-    finally:
-        fh.close()
-    # Check that the file is big enough to be a bitmap.
-    if len(data) <= 0x36:
-        raise Exception("bitmap doesn't contain enough data.")
-    # The first 2 bytes are used to identify the bitmap.
-    if (data[:2] != "BM"):
-        raise Exception("bitmap doesn't appear to to be a valid bitmap image.")
-    # Remove bitmap data: ID.
-    data = data[2:]
-    # Read and remove the bitmap size. This is more reliable than reading
-    # the data size at offset 0x22.
-    #
-    size = unpack("<L", data[:4])[0]
-    size -=  0x36   # Subtract size of bitmap header.
-    size +=  0x0C   # Add size of BIFF header.
-    data = data[4:]
-    # Remove bitmap data: reserved, offset, header length.
-    data = data[12:]
-    # Read and remove the bitmap width and height. Verify the sizes.
-    width, height = unpack("<LL", data[:8])
-    data = data[8:]
-    if (width > 0xFFFF):
-        raise Exception("bitmap: largest image width supported is 65k.")
-    if (height > 0xFFFF):
-        raise Exception("bitmap: largest image height supported is 65k.")
-    # Read and remove the bitmap planes and bpp data. Verify them.
-    planes, bitcount = unpack("<HH", data[:4])
-    data = data[4:]
-    if (bitcount != 24):
-        raise Exception("bitmap isn't a 24bit true color bitmap.")
-    if (planes != 1):
-        raise Exception("bitmap: only 1 plane supported in bitmap image.")
-    # Read and remove the bitmap compression. Verify compression.
-    compression = unpack("<L", data[:4])[0]
-    data = data[4:]
-    if (compression != 0):
-        raise Exception("bitmap: compression not supported in bitmap image.")
-    # Remove bitmap data: data size, hres, vres, colours, imp. colours.
-    data = data[20:]
-    # Add the BITMAPCOREHEADER data
-    header = pack("<LHHHH", 0x000c, width, height, 0x01, 0x18)
-    data = header + data
-    return (width, height, size, data)
-
-
-class ImDataBmpRecord(BiffRecord):
-    _REC_ID = 0x007F
-
-    def __init__(self, filename):
-        """Insert a 24bit bitmap image in a worksheet. The main record required is
-        IMDATA but it must be proceeded by a OBJ record to define its position.
-
-        """
-        BiffRecord.__init__(self)
-
-        self.width, self.height, self.size, data = _process_bitmap(filename)
-        # Write the IMDATA record to store the bitmap data
-        cf = 0x09
-        env = 0x01
-        lcb = self.size
-        self._rec_data = pack("<HHL", cf, env, lcb) + data
-
-

tablib/packages/xlwt/Cell.py

@@ -1,243 +0,0 @@
-# -*- coding: windows-1252 -*-
-
-from struct import unpack, pack
-import BIFFRecords
-
-class StrCell(object):
-    __slots__ = ["rowx", "colx", "xf_idx", "sst_idx"]
-
-    def __init__(self, rowx, colx, xf_idx, sst_idx):
-        self.rowx = rowx
-        self.colx = colx
-        self.xf_idx = xf_idx
-        self.sst_idx = sst_idx
-
-    def get_biff_data(self):
-        # return BIFFRecords.LabelSSTRecord(self.rowx, self.colx, self.xf_idx, self.sst_idx).get()
-        return pack('<5HL', 0x00FD, 10, self.rowx, self.colx, self.xf_idx, self.sst_idx)
-
-class BlankCell(object):
-    __slots__ = ["rowx", "colx", "xf_idx"]
-
-    def __init__(self, rowx, colx, xf_idx):
-        self.rowx = rowx
-        self.colx = colx
-        self.xf_idx = xf_idx
-
-    def get_biff_data(self):
-        # return BIFFRecords.BlankRecord(self.rowx, self.colx, self.xf_idx).get()
-        return pack('<5H', 0x0201, 6, self.rowx, self.colx, self.xf_idx)
-
-class MulBlankCell(object):
-    __slots__ = ["rowx", "colx1", "colx2", "xf_idx"]
-
-    def __init__(self, rowx, colx1, colx2, xf_idx):
-        self.rowx = rowx
-        self.colx1 = colx1
-        self.colx2 = colx2
-        self.xf_idx = xf_idx
-
-    def get_biff_data(self):
-        return BIFFRecords.MulBlankRecord(self.rowx,
-            self.colx1, self.colx2, self.xf_idx).get()
-
-class NumberCell(object):
-    __slots__ = ["rowx", "colx", "xf_idx", "number"]
-
-    def __init__(self, rowx, colx, xf_idx, number):
-        self.rowx = rowx
-        self.colx = colx
-        self.xf_idx = xf_idx
-        self.number = float(number)
-
-    def get_encoded_data(self):
-        rk_encoded = 0
-        num = self.number
-
-        # The four possible kinds of RK encoding are *not* mutually exclusive.
-        # The 30-bit integer variety picks up the most.
-        # In the code below, the four varieties are checked in descending order
-        # of bangs per buck, or not at all.
-        # SJM 2007-10-01
-
-        if -0x20000000 <= num < 0x20000000: # fits in 30-bit *signed* int
-            inum = int(num)
-            if inum == num: # survives round-trip
-                # print "30-bit integer RK", inum, hex(inum)
-                rk_encoded = 2 | (inum << 2)
-                return 1, rk_encoded
-
-        temp = num * 100
-
-        if -0x20000000 <= temp < 0x20000000:
-            # That was step 1: the coded value will fit in
-            # a 30-bit signed integer.
-            itemp = int(round(temp, 0))
-            # That was step 2: "itemp" is the best candidate coded value.
-            # Now for step 3: simulate the decoding,
-            # to check for round-trip correctness.
-            if itemp / 100.0 == num:
-                # print "30-bit integer RK*100", itemp, hex(itemp)
-                rk_encoded = 3 | (itemp << 2)
-                return 1, rk_encoded
-
-        if 0: # Cost of extra pack+unpack not justified by tiny yield.
-            packed = pack('<d', num)
-            w01, w23 = unpack('<2i', packed)
-            if not w01 and not(w23 & 3):
-                # 34 lsb are 0
-                # print "float RK", w23, hex(w23)
-                return 1, w23
-
-            packed100 = pack('<d', temp)
-            w01, w23 = unpack('<2i', packed100)
-            if not w01 and not(w23 & 3):
-                # 34 lsb are 0
-                # print "float RK*100", w23, hex(w23)
-                return 1, w23 | 1
-
-        #print "Number"
-        #print
-        return 0, pack('<5Hd', 0x0203, 14, self.rowx, self.colx, self.xf_idx, num)
-
-    def get_biff_data(self):
-        isRK, value = self.get_encoded_data()
-        if isRK:
-            return pack('<5Hi', 0x27E, 10, self.rowx, self.colx, self.xf_idx, value)
-        return value # NUMBER record already packed
-
-class BooleanCell(object):
-    __slots__ = ["rowx", "colx", "xf_idx", "number"]
-
-    def __init__(self, rowx, colx, xf_idx, number):
-        self.rowx = rowx
-        self.colx = colx
-        self.xf_idx = xf_idx
-        self.number = number
-
-    def get_biff_data(self):
-        return BIFFRecords.BoolErrRecord(self.rowx,
-            self.colx, self.xf_idx, self.number, 0).get()
-
-error_code_map = {
-    0x00:  0, # Intersection of two cell ranges is empty
-    0x07:  7, # Division by zero
-    0x0F: 15, # Wrong type of operand
-    0x17: 23, # Illegal or deleted cell reference
-    0x1D: 29, # Wrong function or range name
-    0x24: 36, # Value range overflow
-    0x2A: 42, # Argument or function not available
-    '#NULL!' :  0, # Intersection of two cell ranges is empty
-    '#DIV/0!':  7, # Division by zero
-    '#VALUE!': 36, # Wrong type of operand
-    '#REF!'  : 23, # Illegal or deleted cell reference
-    '#NAME?' : 29, # Wrong function or range name
-    '#NUM!'  : 36, # Value range overflow
-    '#N/A!'  : 42, # Argument or function not available
-}
-
-class ErrorCell(object):
-    __slots__ = ["rowx", "colx", "xf_idx", "number"]
-
-    def __init__(self, rowx, colx, xf_idx, error_string_or_code):
-        self.rowx = rowx
-        self.colx = colx
-        self.xf_idx = xf_idx
-        try:
-            self.number = error_code_map[error_string_or_code]
-        except KeyError:
-            raise Exception('Illegal error value (%r)' % error_string_or_code)
-
-    def get_biff_data(self):
-        return BIFFRecords.BoolErrRecord(self.rowx,
-            self.colx, self.xf_idx, self.number, 1).get()
-
-class FormulaCell(object):
-    __slots__ = ["rowx", "colx", "xf_idx", "frmla", "calc_flags"]
-
-    def __init__(self, rowx, colx, xf_idx, frmla, calc_flags=0):
-        self.rowx = rowx
-        self.colx = colx
-        self.xf_idx = xf_idx
-        self.frmla = frmla
-        self.calc_flags = calc_flags
-
-    def get_biff_data(self):
-        return BIFFRecords.FormulaRecord(self.rowx,
-            self.colx, self.xf_idx, self.frmla.rpn(), self.calc_flags).get()
-
-# module-level function for *internal* use by the Row module
-
-def _get_cells_biff_data_mul(rowx, cell_items):
-    # Return the BIFF data for all cell records in the row.
-    # Adjacent BLANK|RK records are combined into MUL(BLANK|RK) records.
-    pieces = []
-    nitems = len(cell_items)
-    i = 0
-    while i < nitems:
-        icolx, icell = cell_items[i]
-        if isinstance(icell, NumberCell):
-            isRK, value = icell.get_encoded_data()
-            if not isRK:
-                pieces.append(value) # pre-packed NUMBER record
-                i += 1
-                continue
-            muldata = [(value, icell.xf_idx)]
-            target = NumberCell
-        elif isinstance(icell, BlankCell):
-            muldata = [icell.xf_idx]
-            target = BlankCell
-        else:
-            pieces.append(icell.get_biff_data())
-            i += 1
-            continue
-        lastcolx = icolx
-        j = i
-        packed_record = ''
-        for j in xrange(i+1, nitems):
-            jcolx, jcell = cell_items[j]
-            if jcolx != lastcolx + 1:
-                nexti = j
-                break
-            if not isinstance(jcell, target):
-                nexti = j
-                break
-            if target == NumberCell:
-                isRK, value = jcell.get_encoded_data()
-                if not isRK:
-                    packed_record = value
-                    nexti = j + 1
-                    break
-                muldata.append((value, jcell.xf_idx))
-            else:
-                muldata.append(jcell.xf_idx)
-            lastcolx = jcolx
-        else:
-            nexti = j + 1
-        if target == NumberCell:
-            if lastcolx == icolx:
-                # RK record
-                value, xf_idx = muldata[0]
-                pieces.append(pack('<5Hi', 0x027E, 10, rowx, icolx, xf_idx, value))
-            else:
-                # MULRK record
-                nc = lastcolx - icolx + 1
-                pieces.append(pack('<4H', 0x00BD, 6 * nc + 6, rowx, icolx))
-                pieces.append(''.join([pack('<Hi', xf_idx, value) for value, xf_idx in muldata]))
-                pieces.append(pack('<H', lastcolx))
-        else:
-            if lastcolx == icolx:
-                # BLANK record
-                xf_idx = muldata[0]
-                pieces.append(pack('<5H', 0x0201, 6, rowx, icolx, xf_idx))
-            else:
-                # MULBLANK record
-                nc = lastcolx - icolx + 1
-                pieces.append(pack('<4H', 0x00BE, 2 * nc + 6, rowx, icolx))
-                pieces.append(''.join([pack('<H', xf_idx) for xf_idx in muldata]))
-                pieces.append(pack('<H', lastcolx))
-        if packed_record:
-            pieces.append(packed_record)
-        i = nexti
-    return ''.join(pieces)
-

tablib/packages/xlwt/Column.py

@@ -1,34 +0,0 @@
-# -*- coding: windows-1252 -*-
-
-from BIFFRecords import ColInfoRecord
-
-class Column(object):
-    def __init__(self, colx, parent_sheet):
-        if not(isinstance(colx, int) and 0 <= colx <= 255):
-            raise ValueError("column index (%r) not an int in range(256)" % colx)
-        self._index = colx
-        self._parent = parent_sheet
-        self._parent_wb = parent_sheet.get_parent()
-        self._xf_index = 0x0F
-
-        self.width = 0x0B92
-        self.hidden = 0
-        self.level = 0
-        self.collapse = 0
-
-    def set_style(self, style):
-        self._xf_index = self._parent_wb.add_style(style)
-
-    def width_in_pixels(self):
-        # *** Approximation ****
-        return int(round(self.width * 0.0272 + 0.446, 0))
-
-    def get_biff_record(self):
-        options =  (self.hidden & 0x01) << 0
-        options |= (self.level & 0x07) << 8
-        options |= (self.collapse & 0x01) << 12
-
-        return ColInfoRecord(self._index, self._index, self.width, self._xf_index, options).get()
-
-
-

tablib/packages/xlwt/CompoundDoc.py

@@ -1,516 +0,0 @@
-# -*- coding: windows-1252 -*-
-
-import sys
-import struct
-
-class Reader:
-    def __init__(self, filename, dump = False):
-        self.dump = dump
-        self.STREAMS = {}
-
-        doc = file(filename, 'rb').read()
-        self.header, self.data = doc[0:512], doc[512:]
-        del doc
-
-        self.__build_header()
-        self.__build_MSAT()
-        self.__build_SAT()
-        self.__build_directory()
-        self.__build_short_sectors_data()
-        
-        if len(self.short_sectors_data) > 0:
-            self.__build_SSAT()
-        else:
-            if self.dump and (self.total_ssat_sectors != 0 or self.ssat_start_sid != -2):
-                print 'NOTE: header says that must be', self.total_ssat_sectors, 'short sectors'
-                print 'NOTE: starting at', self.ssat_start_sid, 'sector'
-                print 'NOTE: but file does not contains data in short sectors'
-            self.ssat_start_sid = -2
-            self.total_ssat_sectors = 0
-            self.SSAT = [-2]
-
-        for dentry in self.dir_entry_list[1:]:
-            (did, 
-             sz, name, 
-             t, c, 
-             did_left, did_right, did_root, 
-             dentry_start_sid, 
-             stream_size
-            ) = dentry
-            stream_data = ''
-            if stream_size > 0:
-                if stream_size >= self.min_stream_size:
-                    args = (self.data, self.SAT, dentry_start_sid, self.sect_size)
-                else:
-                    args = (self.short_sectors_data, self.SSAT, dentry_start_sid, self.short_sect_size)
-                stream_data = self.get_stream_data(*args)
-
-            if name != '':
-                # BAD IDEA: names may be equal. NEED use full paths...
-                self.STREAMS[name] = stream_data
-
-    
-    def __build_header(self):
-        self.doc_magic             = self.header[0:8]
-
-        if self.doc_magic != '\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1':
-            raise Exception, 'Not an OLE file.'
-
-        self.file_uid              = self.header[8:24]
-        self.rev_num               = self.header[24:26]
-        self.ver_num               = self.header[26:28]
-        self.byte_order            = self.header[28:30]
-        self.log2_sect_size,       = struct.unpack('<H', self.header[30:32])
-        self.log2_short_sect_size, = struct.unpack('<H', self.header[32:34])
-        self.total_sat_sectors,    = struct.unpack('<L', self.header[44:48])
-        self.dir_start_sid,        = struct.unpack('<l', self.header[48:52])
-        self.min_stream_size,      = struct.unpack('<L', self.header[56:60])
-        self.ssat_start_sid,       = struct.unpack('<l', self.header[60:64])
-        self.total_ssat_sectors,   = struct.unpack('<L', self.header[64:68])
-        self.msat_start_sid,       = struct.unpack('<l', self.header[68:72])
-        self.total_msat_sectors,   = struct.unpack('<L', self.header[72:76])
-         
-        self.sect_size        = 1 << self.log2_sect_size
-        self.short_sect_size  = 1 << self.log2_short_sect_size
-
-        if self.dump:
-            print 'file magic: '
-            print_bin_data(self.doc_magic)
-
-            print 'file uid: '
-            print_bin_data(self.file_uid)
-
-            print 'revision number: '
-            print_bin_data(self.rev_num)
-         
-            print 'version number: '
-            print_bin_data(self.ver_num)
-            
-            print 'byte order: '
-            print_bin_data(self.byte_order)
-            
-            print 'sector size                                :', hex(self.sect_size), self.sect_size
-            #print 'total sectors in file                      :', hex(self.total_sectors), self.total_sectors
-            print 'short sector size                          :', hex(self.short_sect_size), self.short_sect_size
-            print 'Total number of sectors used for the SAT   :', hex(self.total_sat_sectors), self.total_sat_sectors
-            print 'SID of first sector of the directory stream:', hex(self.dir_start_sid), self.dir_start_sid
-            print 'Minimum size of a standard stream          :', hex(self.min_stream_size), self.min_stream_size
-            print 'SID of first sector of the SSAT            :', hex(self.ssat_start_sid), self.ssat_start_sid
-            print 'Total number of sectors used for the SSAT  :', hex(self.total_ssat_sectors), self.total_ssat_sectors
-            print 'SID of first additional sector of the MSAT :', hex(self.msat_start_sid), self.msat_start_sid
-            print 'Total number of sectors used for the MSAT  :', hex(self.total_msat_sectors), self.total_msat_sectors
-
-
-    def __build_MSAT(self):
-        self.MSAT = list(struct.unpack('<109l', self.header[76:]))
-        
-        next = self.msat_start_sid
-        while next > 0:
-           msat_sector = struct.unpack('<128l', self.data[next*self.sect_size:(next+1)*self.sect_size])
-           self.MSAT.extend(msat_sector[:127])
-           next = msat_sector[-1]
-
-        if self.dump:
-            print 'MSAT (header part): \n', self.MSAT[:109]
-            print 'additional MSAT sectors: \n', self.MSAT[109:]
-
-
-    def __build_SAT(self):
-        sat_stream = ''.join([self.data[i*self.sect_size:(i+1)*self.sect_size] for i in self.MSAT if i >= 0])
-
-        sat_sids_count = len(sat_stream) >> 2
-        self.SAT = struct.unpack('<%dl' % sat_sids_count, sat_stream) # SIDs tuple
-
-        if self.dump:
-            print 'SAT sid count:\n', sat_sids_count
-            print 'SAT content:\n', self.SAT
-
-
-    def __build_SSAT(self):
-        ssat_stream = self.get_stream_data(self.data, self.SAT, self.ssat_start_sid, self.sect_size)
-
-        ssids_count = len(ssat_stream) >> 2
-        self.SSAT = struct.unpack('<%dl' % ssids_count, ssat_stream)
-
-        if self.dump:
-            print 'SSID count:', ssids_count
-            print 'SSAT content:\n', self.SSAT
-
-
-    def __build_directory(self):
-        dir_stream = self.get_stream_data(self.data, self.SAT, self.dir_start_sid, self.sect_size)
-
-        self.dir_entry_list = []
-
-        i = 0
-        while i < len(dir_stream):
-            dentry = dir_stream[i:i+128] # 128 -- dir entry size
-            i += 128
-            
-            did = len(self.dir_entry_list)
-            sz, = struct.unpack('<H', dentry[64:66])
-            if sz > 0 :
-                name = dentry[0:sz-2].decode('utf_16_le', 'replace')
-            else:
-                name = u''
-            t,  = struct.unpack('B', dentry[66])
-            c,  = struct.unpack('B', dentry[67])
-            did_left ,  = struct.unpack('<l', dentry[68:72])
-            did_right ,  = struct.unpack('<l', dentry[72:76])
-            did_root ,  = struct.unpack('<l', dentry[76:80])
-            dentry_start_sid ,  = struct.unpack('<l', dentry[116:120])
-            stream_size ,  = struct.unpack('<L', dentry[120:124])
-
-            self.dir_entry_list.extend([(did, sz, name, t, c, 
-                                            did_left, did_right, did_root, 
-                                            dentry_start_sid, stream_size)]) 
-
-        if self.dump:
-            dentry_types = {
-                0x00: 'Empty',
-                0x01: 'User storage',
-                0x02: 'User stream',
-                0x03: 'LockBytes',
-                0x04: 'Property',
-                0x05: 'Root storage'
-            }
-            node_colours = {
-                0x00: 'Red',
-                0x01: 'Black'
-            }
-            print 'total directory entries:', len(self.dir_entry_list)
-
-            for dentry in self.dir_entry_list:
-                (did, sz, name, t, c, 
-                 did_left, did_right, did_root, 
-                 dentry_start_sid, stream_size) = dentry
-                print 'DID', did
-                print 'Size of the used area of the character buffer of the name:', sz
-                print 'dir entry name:', repr(name)
-                print 'type of entry:', t, dentry_types[t]
-                print 'entry colour:', c, node_colours[c]
-                print 'left child DID :', did_left
-                print 'right child DID:', did_right
-                print 'root DID       :', did_root
-                print 'start SID       :', dentry_start_sid
-                print 'stream size     :', stream_size
-                if stream_size == 0:
-                    print 'stream is empty'
-                elif stream_size >= self.min_stream_size:
-                    print 'stream stored as normal stream'
-                else:
-                    print 'stream stored as short-stream'
-
-    
-    def __build_short_sectors_data(self):
-        (did, sz, name, t, c, 
-         did_left, did_right, did_root, 
-         dentry_start_sid, stream_size) = self.dir_entry_list[0]
-        assert t == 0x05 # Short-Stream Container Stream (SSCS) resides in Root Storage
-        if stream_size == 0:
-            self.short_sectors_data = ''
-        else:
-            self.short_sectors_data = self.get_stream_data(self.data, self.SAT, dentry_start_sid, self.sect_size)
-
-
-    def get_stream_data(self, data, SAT, start_sid, sect_size):
-        sid = start_sid
-        chunks = [(sid, sid)]
-        stream_data = ''
-
-        while SAT[sid] >= 0:
-            next_in_chain = SAT[sid]
-            last_chunk_start, last_chunk_finish = chunks[-1]
-            if next_in_chain == last_chunk_finish + 1:
-                chunks[-1] = last_chunk_start, next_in_chain
-            else:
-                chunks.extend([(next_in_chain, next_in_chain)]) 
-            sid = next_in_chain
-        for s, f in chunks:
-            stream_data += data[s*sect_size:(f+1)*sect_size]
-        #print chunks
-        return stream_data
-
-        
-def print_bin_data(data):
-    i = 0
-    while i < len(data):
-        j = 0
-        while (i < len(data)) and (j < 16):
-            c = '0x%02X' % ord(data[i])
-            sys.stdout.write(c)
-            sys.stdout.write(' ')
-            i += 1
-            j += 1
-        print
-    if i == 0:
-        print '<NO DATA>'
-
-
-
-# This implementation writes only 'Root Entry', 'Workbook' streams
-# and 2 empty streams for aligning directory stream on sector boundary
-# 
-# LAYOUT:
-# 0         header
-# 76                MSAT (1st part: 109 SID)
-# 512       workbook stream
-# ...       additional MSAT sectors if streams' size > about 7 Mb == (109*512 * 128)
-# ...       SAT
-# ...       directory stream
-#
-# NOTE: this layout is "ad hoc". It can be more general. RTFM
-
-class XlsDoc:
-    SECTOR_SIZE = 0x0200
-    MIN_LIMIT   = 0x1000
-
-    SID_FREE_SECTOR  = -1
-    SID_END_OF_CHAIN = -2
-    SID_USED_BY_SAT  = -3
-    SID_USED_BY_MSAT = -4
-
-    def __init__(self):
-        #self.book_stream = ''                # padded
-        self.book_stream_sect = []
-
-        self.dir_stream = ''
-        self.dir_stream_sect = []
-
-        self.packed_SAT = ''
-        self.SAT_sect = []
-
-        self.packed_MSAT_1st = ''
-        self.packed_MSAT_2nd = ''
-        self.MSAT_sect_2nd = []
-
-        self.header = ''
-
-    def __build_directory(self): # align on sector boundary
-        self.dir_stream = ''
-
-        dentry_name      = '\x00'.join('Root Entry\x00') + '\x00'
-        dentry_name_sz   = len(dentry_name)
-        dentry_name_pad  = '\x00'*(64 - dentry_name_sz)
-        dentry_type      = 0x05 # root storage
-        dentry_colour    = 0x01 # black
-        dentry_did_left  = -1
-        dentry_did_right = -1
-        dentry_did_root  = 1
-        dentry_start_sid = -2
-        dentry_stream_sz = 0
-
-        self.dir_stream += struct.pack('<64s H 2B 3l 9L l L L',
-           dentry_name + dentry_name_pad,
-           dentry_name_sz,
-           dentry_type,
-           dentry_colour,
-           dentry_did_left, 
-           dentry_did_right,
-           dentry_did_root,
-           0, 0, 0, 0, 0, 0, 0, 0, 0,
-           dentry_start_sid,
-           dentry_stream_sz,
-           0
-        )
-
-        dentry_name      = '\x00'.join('Workbook\x00') + '\x00'
-        dentry_name_sz   = len(dentry_name)
-        dentry_name_pad  = '\x00'*(64 - dentry_name_sz)
-        dentry_type      = 0x02 # user stream
-        dentry_colour    = 0x01 # black
-        dentry_did_left  = -1
-        dentry_did_right = -1
-        dentry_did_root  = -1
-        dentry_start_sid = 0     
-        dentry_stream_sz = self.book_stream_len
-
-        self.dir_stream += struct.pack('<64s H 2B 3l 9L l L L',
-           dentry_name + dentry_name_pad,
-           dentry_name_sz,
-           dentry_type,
-           dentry_colour,
-           dentry_did_left, 
-           dentry_did_right,
-           dentry_did_root,
-           0, 0, 0, 0, 0, 0, 0, 0, 0, 
-           dentry_start_sid,
-           dentry_stream_sz,
-           0
-        )
-        
-        # padding
-        dentry_name      = ''
-        dentry_name_sz   = len(dentry_name)
-        dentry_name_pad  = '\x00'*(64 - dentry_name_sz)
-        dentry_type      = 0x00 # empty
-        dentry_colour    = 0x01 # black
-        dentry_did_left  = -1
-        dentry_did_right = -1
-        dentry_did_root  = -1
-        dentry_start_sid = -2
-        dentry_stream_sz = 0
-
-        self.dir_stream += struct.pack('<64s H 2B 3l 9L l L L',
-           dentry_name + dentry_name_pad,
-           dentry_name_sz,
-           dentry_type,
-           dentry_colour,
-           dentry_did_left, 
-           dentry_did_right,
-           dentry_did_root,
-           0, 0, 0, 0, 0, 0, 0, 0, 0,
-           dentry_start_sid,
-           dentry_stream_sz,
-           0
-        ) * 2
-    
-    def __build_sat(self):
-        # Build SAT
-        book_sect_count = self.book_stream_len >> 9
-        dir_sect_count  = len(self.dir_stream) >> 9
-        
-        total_sect_count     = book_sect_count + dir_sect_count
-        SAT_sect_count       = 0
-        MSAT_sect_count      = 0
-        SAT_sect_count_limit = 109
-        while total_sect_count > 128*SAT_sect_count or SAT_sect_count > SAT_sect_count_limit:
-            SAT_sect_count   += 1
-            total_sect_count += 1
-            if SAT_sect_count > SAT_sect_count_limit:
-                MSAT_sect_count      += 1
-                total_sect_count     += 1
-                SAT_sect_count_limit += 127
-
-
-        SAT = [self.SID_FREE_SECTOR]*128*SAT_sect_count
-
-        sect = 0
-        while sect < book_sect_count - 1:
-            self.book_stream_sect.append(sect)
-            SAT[sect] = sect + 1
-            sect += 1
-        self.book_stream_sect.append(sect)
-        SAT[sect] = self.SID_END_OF_CHAIN
-        sect += 1
-
-        while sect < book_sect_count + MSAT_sect_count:
-            self.MSAT_sect_2nd.append(sect)
-            SAT[sect] = self.SID_USED_BY_MSAT
-            sect += 1
-
-        while sect < book_sect_count + MSAT_sect_count + SAT_sect_count:
-            self.SAT_sect.append(sect)            
-            SAT[sect] = self.SID_USED_BY_SAT
-            sect += 1
-
-        while sect < book_sect_count + MSAT_sect_count + SAT_sect_count + dir_sect_count - 1:
-            self.dir_stream_sect.append(sect)
-            SAT[sect] = sect + 1
-            sect += 1
-        self.dir_stream_sect.append(sect)
-        SAT[sect] = self.SID_END_OF_CHAIN
-        sect += 1
-
-        self.packed_SAT = struct.pack('<%dl' % (SAT_sect_count*128), *SAT)
-
-        MSAT_1st = [self.SID_FREE_SECTOR]*109
-        for i, SAT_sect_num in zip(range(0, 109), self.SAT_sect):
-            MSAT_1st[i] = SAT_sect_num
-        self.packed_MSAT_1st = struct.pack('<109l', *MSAT_1st)
-
-        MSAT_2nd = [self.SID_FREE_SECTOR]*128*MSAT_sect_count
-        if MSAT_sect_count > 0:
-            MSAT_2nd[- 1] = self.SID_END_OF_CHAIN
-
-        i = 109
-        msat_sect = 0
-        sid_num = 0
-        while i < SAT_sect_count:
-            if (sid_num + 1) % 128 == 0:
-                #print 'link: ',
-                msat_sect += 1
-                if msat_sect < len(self.MSAT_sect_2nd):
-                    MSAT_2nd[sid_num] = self.MSAT_sect_2nd[msat_sect]
-            else:
-                #print 'sid: ',
-                MSAT_2nd[sid_num] = self.SAT_sect[i]
-                i += 1
-            #print sid_num, MSAT_2nd[sid_num]
-            sid_num += 1
-
-        self.packed_MSAT_2nd = struct.pack('<%dl' % (MSAT_sect_count*128), *MSAT_2nd)
-
-        #print vars()
-        #print zip(range(0, sect), SAT)
-        #print self.book_stream_sect
-        #print self.MSAT_sect_2nd
-        #print MSAT_2nd
-        #print self.SAT_sect
-        #print self.dir_stream_sect
-
-
-    def __build_header(self):
-        doc_magic             = '\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1'
-        file_uid              = '\x00'*16
-        rev_num               = '\x3E\x00'
-        ver_num               = '\x03\x00'
-        byte_order            = '\xFE\xFF'
-        log_sect_size         = struct.pack('<H', 9)
-        log_short_sect_size   = struct.pack('<H', 6)
-        not_used0             = '\x00'*10
-        total_sat_sectors     = struct.pack('<L', len(self.SAT_sect))
-        dir_start_sid         = struct.pack('<l', self.dir_stream_sect[0])
-        not_used1             = '\x00'*4        
-        min_stream_size       = struct.pack('<L', 0x1000)
-        ssat_start_sid        = struct.pack('<l', -2)
-        total_ssat_sectors    = struct.pack('<L', 0)
-
-        if len(self.MSAT_sect_2nd) == 0:
-            msat_start_sid        = struct.pack('<l', -2)
-        else:
-            msat_start_sid        = struct.pack('<l', self.MSAT_sect_2nd[0])
-
-        total_msat_sectors    = struct.pack('<L', len(self.MSAT_sect_2nd))
-
-        self.header =       ''.join([  doc_magic,
-                                        file_uid,
-                                        rev_num,
-                                        ver_num,
-                                        byte_order,
-                                        log_sect_size,
-                                        log_short_sect_size,
-                                        not_used0,
-                                        total_sat_sectors,
-                                        dir_start_sid,
-                                        not_used1,
-                                        min_stream_size,
-                                        ssat_start_sid,
-                                        total_ssat_sectors,
-                                        msat_start_sid,
-                                        total_msat_sectors
-                                    ])
-                                        
-
-    def save(self, file_name_or_filelike_obj, stream):
-        # 1. Align stream on 0x1000 boundary (and therefore on sector boundary)
-        padding = '\x00' * (0x1000 - (len(stream) % 0x1000))
-        self.book_stream_len = len(stream) + len(padding)
-
-        self.__build_directory()
-        self.__build_sat()
-        self.__build_header()
-        
-        f = file_name_or_filelike_obj
-        we_own_it = not hasattr(f, 'write')
-        if we_own_it:
-            f = open(file_name_or_filelike_obj, 'wb')
-        f.write(self.header)
-        f.write(self.packed_MSAT_1st)
-        f.write(stream)
-        f.write(padding)
-        f.write(self.packed_MSAT_2nd)
-        f.write(self.packed_SAT)
-        f.write(self.dir_stream)
-        if we_own_it:
-            f.close()

tablib/packages/xlwt/ExcelFormula.py

@@ -1,43 +0,0 @@
-# -*- coding: windows-1252 -*-
-
-import ExcelFormulaParser, ExcelFormulaLexer
-import struct
-from antlr import ANTLRException
-
-
-class Formula(object):
-    __slots__ = ["__init__",  "__s", "__parser", "__sheet_refs", "__xcall_refs"]
-
-
-    def __init__(self, s):
-        try:
-            self.__s = s
-            lexer = ExcelFormulaLexer.Lexer(s)
-            self.__parser = ExcelFormulaParser.Parser(lexer)
-            self.__parser.formula()
-            self.__sheet_refs = self.__parser.sheet_references
-            self.__xcall_refs = self.__parser.xcall_references
-        except ANTLRException, e:
-            # print e
-            raise ExcelFormulaParser.FormulaParseException, "can't parse formula " + s
-
-    def get_references(self):
-        return self.__sheet_refs, self.__xcall_refs
-
-    def patch_references(self, patches):
-        for offset, idx in patches:
-            self.__parser.rpn = self.__parser.rpn[:offset] + struct.pack('<H', idx) + self.__parser.rpn[offset+2:]
-
-    def text(self):
-        return self.__s
-
-    def rpn(self):
-        '''
-        Offset    Size    Contents
-        0         2       Size of the following formula data (sz)
-        2         sz      Formula data (RPN token array)
-        [2+sz]    var.    (optional) Additional data for specific tokens
-
-        '''
-        return struct.pack("<H", len(self.__parser.rpn)) + self.__parser.rpn
-

tablib/packages/xlwt/ExcelFormulaLexer.py

@@ -1,128 +0,0 @@
-# -*- coding: windows-1252 -*-
-
-import sys
-from antlr import EOF, CommonToken as Tok, TokenStream, TokenStreamException
-import struct
-import ExcelFormulaParser
-from re import compile as recompile, match, LOCALE, UNICODE, IGNORECASE, VERBOSE
-
-
-int_const_pattern = r"\d+\b"
-flt_const_pattern = r"""
-    (?:
-        (?: \d* \. \d+ ) # .1 .12 .123 etc 9.1 etc 98.1 etc
-        |
-        (?: \d+ \. ) # 1. 12. 123. etc
-    )
-    # followed by optional exponent part
-    (?: [Ee] [+-]? \d+ ) ?
-    """
-str_const_pattern = r'"(?:[^"]|"")*"'
-#range2d_pattern   = recompile(r"\$?[A-I]?[A-Z]\$?\d+:\$?[A-I]?[A-Z]\$?\d+"
-ref2d_r1c1_pattern = r"[Rr]0*[1-9][0-9]*[Cc]0*[1-9][0-9]*"
-ref2d_pattern     = r"\$?[A-I]?[A-Z]\$?0*[1-9][0-9]*"
-true_pattern      = r"TRUE\b"
-false_pattern     = r"FALSE\b"
-if_pattern        = r"IF\b"
-choose_pattern    = r"CHOOSE\b"
-name_pattern      = r"\w[\.\w]*"
-quotename_pattern = r"'(?:[^']|'')*'" #### It's essential that this bracket be non-grouping.
-ne_pattern        = r"<>"
-ge_pattern        = r">="
-le_pattern        = r"<="
-
-pattern_type_tuples = (
-    (flt_const_pattern, ExcelFormulaParser.NUM_CONST),
-    (int_const_pattern, ExcelFormulaParser.INT_CONST),
-    (str_const_pattern, ExcelFormulaParser.STR_CONST),
-#    (range2d_pattern  , ExcelFormulaParser.RANGE2D),
-    (ref2d_r1c1_pattern, ExcelFormulaParser.REF2D_R1C1),
-    (ref2d_pattern    , ExcelFormulaParser.REF2D),
-    (true_pattern     , ExcelFormulaParser.TRUE_CONST),
-    (false_pattern    , ExcelFormulaParser.FALSE_CONST),
-    (if_pattern       , ExcelFormulaParser.FUNC_IF),
-    (choose_pattern   , ExcelFormulaParser.FUNC_CHOOSE),
-    (name_pattern     , ExcelFormulaParser.NAME),
-    (quotename_pattern, ExcelFormulaParser.QUOTENAME),
-    (ne_pattern,        ExcelFormulaParser.NE),
-    (ge_pattern,        ExcelFormulaParser.GE),
-    (le_pattern,        ExcelFormulaParser.LE),
-)
-
-_re = recompile(
-    '(' + ')|('.join([i[0] for i in pattern_type_tuples]) + ')',
-    VERBOSE+LOCALE+IGNORECASE)
-
-_toktype = [None] + [i[1] for i in pattern_type_tuples]
-# need dummy at start because re.MatchObject.lastindex counts from 1
-
-single_char_lookup = {
-    '=': ExcelFormulaParser.EQ,
-    '<': ExcelFormulaParser.LT,
-    '>': ExcelFormulaParser.GT,
-    '+': ExcelFormulaParser.ADD,
-    '-': ExcelFormulaParser.SUB,
-    '*': ExcelFormulaParser.MUL,
-    '/': ExcelFormulaParser.DIV,
-    ':': ExcelFormulaParser.COLON,
-    ';': ExcelFormulaParser.SEMICOLON,
-    ',': ExcelFormulaParser.COMMA,
-    '(': ExcelFormulaParser.LP,
-    ')': ExcelFormulaParser.RP,
-    '&': ExcelFormulaParser.CONCAT,
-    '%': ExcelFormulaParser.PERCENT,
-    '^': ExcelFormulaParser.POWER,
-    '!': ExcelFormulaParser.BANG,
-    }
-
-class Lexer(TokenStream):
-    def __init__(self, text):
-        self._text = text[:]
-        self._pos = 0
-        self._line = 0
-
-    def isEOF(self):
-        return len(self._text) <= self._pos
-
-    def curr_ch(self):
-        return self._text[self._pos]
-
-    def next_ch(self, n = 1):
-        self._pos += n
-
-    def is_whitespace(self):
-        return self.curr_ch() in " \t\n\r\f\v"
-
-    def match_pattern(self):
-        m = _re.match(self._text, self._pos)
-        if not m:
-            return None
-        self._pos = m.end(0)
-        return Tok(type = _toktype[m.lastindex], text = m.group(0), col = m.start(0) + 1)
-
-    def nextToken(self):
-        # skip whitespace
-        while not self.isEOF() and self.is_whitespace():
-            self.next_ch()
-        if self.isEOF():
-            return Tok(type = EOF)
-        # first, try to match token with 2 or more chars
-        t = self.match_pattern()
-        if t:
-            return t
-        # second, we want 1-char tokens
-        te = self.curr_ch()
-        try:
-            ty = single_char_lookup[te]
-        except KeyError:
-            raise TokenStreamException(
-                "Unexpected char %r in column %u." % (self.curr_ch(), self._pos))
-        self.next_ch()
-        return Tok(type=ty, text=te, col=self._pos)
-
-if __name__ == '__main__':
-    try:
-        for t in Lexer(""" 1.23 456 "abcd" R2C2 a1 iv65536 true false if choose a_name 'qname' <> >= <= """):
-            print t
-    except TokenStreamException, e:
-        print "error:", e

tablib/packages/xlwt/ExcelFormulaParser.py

@@ -1,677 +0,0 @@
-### $ANTLR 2.7.7 (20060930): "xlwt/excel-formula.g" -> "ExcelFormulaParser.py"$
-### import antlr and other modules ..
-import sys
-import antlr
-
-version = sys.version.split()[0]
-if version < '2.2.1':
-    False = 0
-if version < '2.3':
-    True = not False
-### header action >>>
-import struct
-import Utils
-from UnicodeUtils import upack1
-from ExcelMagic import *
-
-_RVAdelta =     {"R": 0, "V": 0x20, "A": 0x40}
-_RVAdeltaRef =  {"R": 0, "V": 0x20, "A": 0x40, "D": 0x20}
-_RVAdeltaArea = {"R": 0, "V": 0x20, "A": 0x40, "D": 0}
-
-
-class FormulaParseException(Exception):
-   """
-   An exception indicating that a Formula could not be successfully parsed.
-   """
-### header action <<<
-### preamble action>>>
-
-### preamble action <<<
-
-### import antlr.Token
-from antlr import Token
-### >>>The Known Token Types <<<
-SKIP                = antlr.SKIP
-INVALID_TYPE        = antlr.INVALID_TYPE
-EOF_TYPE            = antlr.EOF_TYPE
-EOF                 = antlr.EOF
-NULL_TREE_LOOKAHEAD = antlr.NULL_TREE_LOOKAHEAD
-MIN_USER_TYPE       = antlr.MIN_USER_TYPE
-TRUE_CONST = 4
-FALSE_CONST = 5
-STR_CONST = 6
-NUM_CONST = 7
-INT_CONST = 8
-FUNC_IF = 9
-FUNC_CHOOSE = 10
-NAME = 11
-QUOTENAME = 12
-EQ = 13
-NE = 14
-GT = 15
-LT = 16
-GE = 17
-LE = 18
-ADD = 19
-SUB = 20
-MUL = 21
-DIV = 22
-POWER = 23
-PERCENT = 24
-LP = 25
-RP = 26
-LB = 27
-RB = 28
-COLON = 29
-COMMA = 30
-SEMICOLON = 31
-REF2D = 32
-REF2D_R1C1 = 33
-BANG = 34
-CONCAT = 35
-
-class Parser(antlr.LLkParser):
-    ### user action >>>
-    ### user action <<<
-
-    def __init__(self, *args, **kwargs):
-        antlr.LLkParser.__init__(self, *args, **kwargs)
-        self.tokenNames = _tokenNames
-        ### __init__ header action >>>
-        self.rpn = ""
-        self.sheet_references = []
-        self.xcall_references = []
-        ### __init__ header action <<<
-
-    def formula(self):
-
-        pass
-        self.expr("V")
-
-    def expr(self,
-        arg_type
-    ):
-
-        pass
-        self.prec0_expr(arg_type)
-        while True:
-            if ((self.LA(1) >= EQ and self.LA(1) <= LE)):
-                pass
-                la1 = self.LA(1)
-                if False:
-                    pass
-                elif la1 and la1 in [EQ]:
-                    pass
-                    self.match(EQ)
-                    op = struct.pack('B', ptgEQ)
-                elif la1 and la1 in [NE]:
-                    pass
-                    self.match(NE)
-                    op = struct.pack('B', ptgNE)
-                elif la1 and la1 in [GT]:
-                    pass
-                    self.match(GT)
-                    op = struct.pack('B', ptgGT)
-                elif la1 and la1 in [LT]:
-                    pass
-                    self.match(LT)
-                    op = struct.pack('B', ptgLT)
-                elif la1 and la1 in [GE]:
-                    pass
-                    self.match(GE)
-                    op = struct.pack('B', ptgGE)
-                elif la1 and la1 in [LE]:
-                    pass
-                    self.match(LE)
-                    op = struct.pack('B', ptgLE)
-                else:
-                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-                self.prec0_expr(arg_type)
-                self.rpn += op
-            else:
-                break
-
-
-    def prec0_expr(self,
-        arg_type
-    ):
-
-        pass
-        self.prec1_expr(arg_type)
-        while True:
-            if (self.LA(1)==CONCAT):
-                pass
-                pass
-                self.match(CONCAT)
-                op = struct.pack('B', ptgConcat)
-                self.prec1_expr(arg_type)
-                self.rpn += op
-            else:
-                break
-
-
-    def prec1_expr(self,
-        arg_type
-    ):
-
-        pass
-        self.prec2_expr(arg_type)
-        while True:
-            if (self.LA(1)==ADD or self.LA(1)==SUB):
-                pass
-                la1 = self.LA(1)
-                if False:
-                    pass
-                elif la1 and la1 in [ADD]:
-                    pass
-                    self.match(ADD)
-                    op = struct.pack('B', ptgAdd)
-                elif la1 and la1 in [SUB]:
-                    pass
-                    self.match(SUB)
-                    op = struct.pack('B', ptgSub)
-                else:
-                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-                self.prec2_expr(arg_type)
-                self.rpn += op;
-                          # print "**prec1_expr4 %s" % arg_type
-            else:
-                break
-
-
-    def prec2_expr(self,
-        arg_type
-    ):
-
-        pass
-        self.prec3_expr(arg_type)
-        while True:
-            if (self.LA(1)==MUL or self.LA(1)==DIV):
-                pass
-                la1 = self.LA(1)
-                if False:
-                    pass
-                elif la1 and la1 in [MUL]:
-                    pass
-                    self.match(MUL)
-                    op = struct.pack('B', ptgMul)
-                elif la1 and la1 in [DIV]:
-                    pass
-                    self.match(DIV)
-                    op = struct.pack('B', ptgDiv)
-                else:
-                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-                self.prec3_expr(arg_type)
-                self.rpn += op
-            else:
-                break
-
-
-    def prec3_expr(self,
-        arg_type
-    ):
-
-        pass
-        self.prec4_expr(arg_type)
-        while True:
-            if (self.LA(1)==POWER):
-                pass
-                pass
-                self.match(POWER)
-                op = struct.pack('B', ptgPower)
-                self.prec4_expr(arg_type)
-                self.rpn += op
-            else:
-                break
-
-
-    def prec4_expr(self,
-        arg_type
-    ):
-
-        pass
-        self.prec5_expr(arg_type)
-        la1 = self.LA(1)
-        if False:
-            pass
-        elif la1 and la1 in [PERCENT]:
-            pass
-            self.match(PERCENT)
-            self.rpn += struct.pack('B', ptgPercent)
-        elif la1 and la1 in [EOF,EQ,NE,GT,LT,GE,LE,ADD,SUB,MUL,DIV,POWER,RP,COMMA,SEMICOLON,CONCAT]:
-            pass
-        else:
-                raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-
-    def prec5_expr(self,
-        arg_type
-    ):
-
-        la1 = self.LA(1)
-        if False:
-            pass
-        elif la1 and la1 in [TRUE_CONST,FALSE_CONST,STR_CONST,NUM_CONST,INT_CONST,FUNC_IF,FUNC_CHOOSE,NAME,QUOTENAME,LP,REF2D]:
-            pass
-            self.primary(arg_type)
-        elif la1 and la1 in [SUB]:
-            pass
-            self.match(SUB)
-            self.primary(arg_type)
-            self.rpn += struct.pack('B', ptgUminus)
-        else:
-                raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-
-    def primary(self,
-        arg_type
-    ):
-
-        str_tok = None
-        int_tok = None
-        num_tok = None
-        ref2d_tok = None
-        ref2d1_tok = None
-        ref2d2_tok = None
-        ref3d_ref2d = None
-        ref3d_ref2d2 = None
-        name_tok = None
-        func_tok = None
-        la1 = self.LA(1)
-        if False:
-            pass
-        elif la1 and la1 in [TRUE_CONST]:
-            pass
-            self.match(TRUE_CONST)
-            self.rpn += struct.pack("2B", ptgBool, 1)
-        elif la1 and la1 in [FALSE_CONST]:
-            pass
-            self.match(FALSE_CONST)
-            self.rpn += struct.pack("2B", ptgBool, 0)
-        elif la1 and la1 in [STR_CONST]:
-            pass
-            str_tok = self.LT(1)
-            self.match(STR_CONST)
-            self.rpn += struct.pack("B", ptgStr) + upack1(str_tok.text[1:-1].replace("\"\"", "\""))
-        elif la1 and la1 in [NUM_CONST]:
-            pass
-            num_tok = self.LT(1)
-            self.match(NUM_CONST)
-            self.rpn += struct.pack("<Bd", ptgNum, float(num_tok.text))
-        elif la1 and la1 in [FUNC_IF]:
-            pass
-            self.match(FUNC_IF)
-            self.match(LP)
-            self.expr("V")
-            la1 = self.LA(1)
-            if False:
-                pass
-            elif la1 and la1 in [SEMICOLON]:
-                pass
-                self.match(SEMICOLON)
-            elif la1 and la1 in [COMMA]:
-                pass
-                self.match(COMMA)
-            else:
-                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-            self.rpn += struct.pack("<BBH", ptgAttr, 0x02, 0) # tAttrIf
-            pos0 = len(self.rpn) - 2
-            self.expr(arg_type)
-            la1 = self.LA(1)
-            if False:
-                pass
-            elif la1 and la1 in [SEMICOLON]:
-                pass
-                self.match(SEMICOLON)
-            elif la1 and la1 in [COMMA]:
-                pass
-                self.match(COMMA)
-            else:
-                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-            self.rpn += struct.pack("<BBH", ptgAttr, 0x08, 0) # tAttrSkip
-            pos1 = len(self.rpn) - 2
-            self.rpn = self.rpn[:pos0] + struct.pack("<H", pos1-pos0) + self.rpn[pos0+2:]
-            self.expr(arg_type)
-            self.match(RP)
-            self.rpn += struct.pack("<BBH", ptgAttr, 0x08, 3) # tAttrSkip
-            self.rpn += struct.pack("<BBH", ptgFuncVarR, 3, 1) # 3 = nargs, 1 = IF func
-            pos2 = len(self.rpn)
-            self.rpn = self.rpn[:pos1] + struct.pack("<H", pos2-(pos1+2)-1) + self.rpn[pos1+2:]
-        elif la1 and la1 in [FUNC_CHOOSE]:
-            pass
-            self.match(FUNC_CHOOSE)
-            arg_type = "R"
-            rpn_chunks = []
-            self.match(LP)
-            self.expr("V")
-            rpn_start = len(self.rpn)
-            ref_markers = [len(self.sheet_references)]
-            while True:
-                if (self.LA(1)==COMMA or self.LA(1)==SEMICOLON):
-                    pass
-                    la1 = self.LA(1)
-                    if False:
-                        pass
-                    elif la1 and la1 in [SEMICOLON]:
-                        pass
-                        self.match(SEMICOLON)
-                    elif la1 and la1 in [COMMA]:
-                        pass
-                        self.match(COMMA)
-                    else:
-                            raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-                    mark = len(self.rpn)
-                    la1 = self.LA(1)
-                    if False:
-                        pass
-                    elif la1 and la1 in [TRUE_CONST,FALSE_CONST,STR_CONST,NUM_CONST,INT_CONST,FUNC_IF,FUNC_CHOOSE,NAME,QUOTENAME,SUB,LP,REF2D]:
-                        pass
-                        self.expr(arg_type)
-                    elif la1 and la1 in [RP,COMMA,SEMICOLON]:
-                        pass
-                        self.rpn += struct.pack("B", ptgMissArg)
-                    else:
-                            raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-                    rpn_chunks.append(self.rpn[mark:])
-                    ref_markers.append(len(self.sheet_references))
-                else:
-                    break
-
-            self.match(RP)
-            self.rpn = self.rpn[:rpn_start]
-            nc = len(rpn_chunks)
-            chunklens = [len(chunk) for chunk in rpn_chunks]
-            skiplens = [0] * nc
-            skiplens[-1] = 3
-            for ic in xrange(nc-1, 0, -1):
-               skiplens[ic-1] = skiplens[ic] + chunklens[ic] + 4
-            jump_pos = [2 * nc + 2]
-            for ic in xrange(nc):
-               jump_pos.append(jump_pos[-1] + chunklens[ic] + 4)
-            chunk_shift = 2 * nc + 6 # size of tAttrChoose
-            for ic in xrange(nc):
-               for refx in xrange(ref_markers[ic], ref_markers[ic+1]):
-                   ref = self.sheet_references[refx]
-                   self.sheet_references[refx] = (ref[0], ref[1], ref[2] + chunk_shift)
-               chunk_shift += 4 # size of tAttrSkip
-            choose_rpn = []
-            choose_rpn.append(struct.pack("<BBH", ptgAttr, 0x04, nc)) # 0x04 is tAttrChoose
-            choose_rpn.append(struct.pack("<%dH" % (nc+1), *jump_pos))
-            for ic in xrange(nc):
-               choose_rpn.append(rpn_chunks[ic])
-               choose_rpn.append(struct.pack("<BBH", ptgAttr, 0x08, skiplens[ic])) # 0x08 is tAttrSkip
-            choose_rpn.append(struct.pack("<BBH", ptgFuncVarV, nc+1, 100)) # 100 is CHOOSE fn
-            self.rpn += "".join(choose_rpn)
-        elif la1 and la1 in [LP]:
-            pass
-            self.match(LP)
-            self.expr(arg_type)
-            self.match(RP)
-            self.rpn += struct.pack("B", ptgParen)
-        else:
-            if (self.LA(1)==INT_CONST) and (_tokenSet_0.member(self.LA(2))):
-                pass
-                int_tok = self.LT(1)
-                self.match(INT_CONST)
-                # print "**int_const", int_tok.text
-                int_value = int(int_tok.text)
-                if int_value <= 65535:
-                   self.rpn += struct.pack("<BH", ptgInt, int_value)
-                else:
-                   self.rpn += struct.pack("<Bd", ptgNum, float(int_value))
-            elif (self.LA(1)==REF2D) and (_tokenSet_0.member(self.LA(2))):
-                pass
-                ref2d_tok = self.LT(1)
-                self.match(REF2D)
-                # print "**ref2d %s %s" % (ref2d_tok.text, arg_type)
-                r, c = Utils.cell_to_packed_rowcol(ref2d_tok.text)
-                ptg = ptgRefR + _RVAdeltaRef[arg_type]
-                self.rpn += struct.pack("<B2H", ptg, r, c)
-            elif (self.LA(1)==REF2D) and (self.LA(2)==COLON):
-                pass
-                ref2d1_tok = self.LT(1)
-                self.match(REF2D)
-                self.match(COLON)
-                ref2d2_tok = self.LT(1)
-                self.match(REF2D)
-                r1, c1 = Utils.cell_to_packed_rowcol(ref2d1_tok.text)
-                r2, c2 = Utils.cell_to_packed_rowcol(ref2d2_tok.text)
-                ptg = ptgAreaR + _RVAdeltaArea[arg_type]
-                self.rpn += struct.pack("<B4H", ptg, r1, r2, c1, c2)
-            elif (self.LA(1)==INT_CONST or self.LA(1)==NAME or self.LA(1)==QUOTENAME) and (self.LA(2)==COLON or self.LA(2)==BANG):
-                pass
-                sheet1=self.sheet()
-                sheet2 = sheet1
-                la1 = self.LA(1)
-                if False:
-                    pass
-                elif la1 and la1 in [COLON]:
-                    pass
-                    self.match(COLON)
-                    sheet2=self.sheet()
-                elif la1 and la1 in [BANG]:
-                    pass
-                else:
-                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-                self.match(BANG)
-                ref3d_ref2d = self.LT(1)
-                self.match(REF2D)
-                ptg = ptgRef3dR + _RVAdeltaRef[arg_type]
-                rpn_ref2d = ""
-                r1, c1 = Utils.cell_to_packed_rowcol(ref3d_ref2d.text)
-                rpn_ref2d = struct.pack("<3H", 0x0000, r1, c1)
-                la1 = self.LA(1)
-                if False:
-                    pass
-                elif la1 and la1 in [COLON]:
-                    pass
-                    self.match(COLON)
-                    ref3d_ref2d2 = self.LT(1)
-                    self.match(REF2D)
-                    ptg = ptgArea3dR + _RVAdeltaArea[arg_type]
-                    r2, c2 = Utils.cell_to_packed_rowcol(ref3d_ref2d2.text)
-                    rpn_ref2d = struct.pack("<5H", 0x0000, r1, r2, c1, c2)
-                elif la1 and la1 in [EOF,EQ,NE,GT,LT,GE,LE,ADD,SUB,MUL,DIV,POWER,PERCENT,RP,COMMA,SEMICOLON,CONCAT]:
-                    pass
-                else:
-                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-                self.rpn += struct.pack("<B", ptg)
-                self.sheet_references.append((sheet1, sheet2, len(self.rpn)))
-                self.rpn += rpn_ref2d
-            elif (self.LA(1)==NAME) and (_tokenSet_0.member(self.LA(2))):
-                pass
-                name_tok = self.LT(1)
-                self.match(NAME)
-                raise Exception("[formula] found unexpected NAME token (%r)" % name_tok.txt)
-                # #### TODO: handle references to defined names here
-            elif (self.LA(1)==NAME) and (self.LA(2)==LP):
-                pass
-                func_tok = self.LT(1)
-                self.match(NAME)
-                func_toku = func_tok.text.upper()
-                if func_toku in all_funcs_by_name:
-                   (opcode,
-                   min_argc,
-                   max_argc,
-                   func_type,
-                   arg_type_str) = all_funcs_by_name[func_toku]
-                   arg_type_list = list(arg_type_str)
-                else:
-                   raise Exception("[formula] unknown function (%s)" % func_tok.text)
-                # print "**func_tok1 %s %s" % (func_toku, func_type)
-                xcall = opcode < 0
-                if xcall:
-                   # The name of the add-in function is passed as the 1st arg
-                   # of the hidden XCALL function
-                   self.xcall_references.append((func_toku, len(self.rpn) + 1))
-                   self.rpn += struct.pack("<BHHH",
-                       ptgNameXR,
-                       0xadde, # ##PATCHME## index to REF entry in EXTERNSHEET record
-                       0xefbe, # ##PATCHME## one-based index to EXTERNNAME record
-                       0x0000) # unused
-                self.match(LP)
-                arg_count=self.expr_list(arg_type_list, min_argc, max_argc)
-                self.match(RP)
-                if arg_count > max_argc or arg_count < min_argc:
-                   raise Exception, "%d parameters for function: %s" % (arg_count, func_tok.text)
-                if xcall:
-                   func_ptg = ptgFuncVarR + _RVAdelta[func_type]
-                   self.rpn += struct.pack("<2BH", func_ptg, arg_count + 1, 255) # 255 is magic XCALL function
-                elif min_argc == max_argc:
-                   func_ptg = ptgFuncR + _RVAdelta[func_type]
-                   self.rpn += struct.pack("<BH", func_ptg, opcode)
-                elif arg_count == 1 and func_tok.text.upper() == "SUM":
-                   self.rpn += struct.pack("<BBH", ptgAttr, 0x10, 0) # tAttrSum
-                else:
-                   func_ptg = ptgFuncVarR + _RVAdelta[func_type]
-                   self.rpn += struct.pack("<2BH", func_ptg, arg_count, opcode)
-            else:
-                raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-
-    def sheet(self):
-        ref = None
-
-        sheet_ref_name = None
-        sheet_ref_int = None
-        sheet_ref_quote = None
-        la1 = self.LA(1)
-        if False:
-            pass
-        elif la1 and la1 in [NAME]:
-            pass
-            sheet_ref_name = self.LT(1)
-            self.match(NAME)
-            ref = sheet_ref_name.text
-        elif la1 and la1 in [INT_CONST]:
-            pass
-            sheet_ref_int = self.LT(1)
-            self.match(INT_CONST)
-            ref = sheet_ref_int.text
-        elif la1 and la1 in [QUOTENAME]:
-            pass
-            sheet_ref_quote = self.LT(1)
-            self.match(QUOTENAME)
-            ref = sheet_ref_quote.text[1:-1].replace("''", "'")
-        else:
-                raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-        return ref
-
-    def expr_list(self,
-        arg_type_list, min_argc, max_argc
-    ):
-        arg_cnt = None
-
-        arg_cnt = 0
-        arg_type = arg_type_list[arg_cnt]
-        # print "**expr_list1[%d] req=%s" % (arg_cnt, arg_type)
-        la1 = self.LA(1)
-        if False:
-            pass
-        elif la1 and la1 in [TRUE_CONST,FALSE_CONST,STR_CONST,NUM_CONST,INT_CONST,FUNC_IF,FUNC_CHOOSE,NAME,QUOTENAME,SUB,LP,REF2D]:
-            pass
-            self.expr(arg_type)
-            arg_cnt += 1
-            while True:
-                if (self.LA(1)==COMMA or self.LA(1)==SEMICOLON):
-                    pass
-                    if arg_cnt < len(arg_type_list):
-                       arg_type = arg_type_list[arg_cnt]
-                    else:
-                       arg_type = arg_type_list[-1]
-                    if arg_type == "+":
-                       arg_type = arg_type_list[-2]
-                    # print "**expr_list2[%d] req=%s" % (arg_cnt, arg_type)
-                    la1 = self.LA(1)
-                    if False:
-                        pass
-                    elif la1 and la1 in [SEMICOLON]:
-                        pass
-                        self.match(SEMICOLON)
-                    elif la1 and la1 in [COMMA]:
-                        pass
-                        self.match(COMMA)
-                    else:
-                            raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-                    la1 = self.LA(1)
-                    if False:
-                        pass
-                    elif la1 and la1 in [TRUE_CONST,FALSE_CONST,STR_CONST,NUM_CONST,INT_CONST,FUNC_IF,FUNC_CHOOSE,NAME,QUOTENAME,SUB,LP,REF2D]:
-                        pass
-                        self.expr(arg_type)
-                    elif la1 and la1 in [RP,COMMA,SEMICOLON]:
-                        pass
-                        self.rpn += struct.pack("B", ptgMissArg)
-                    else:
-                            raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-                    arg_cnt += 1
-                else:
-                    break
-
-        elif la1 and la1 in [RP]:
-            pass
-        else:
-                raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-        return arg_cnt
-
-
-_tokenNames = [
-    "<0>",
-    "EOF",
-    "<2>",
-    "NULL_TREE_LOOKAHEAD",
-    "TRUE_CONST",
-    "FALSE_CONST",
-    "STR_CONST",
-    "NUM_CONST",
-    "INT_CONST",
-    "FUNC_IF",
-    "FUNC_CHOOSE",
-    "NAME",
-    "QUOTENAME",
-    "EQ",
-    "NE",
-    "GT",
-    "LT",
-    "GE",
-    "LE",
-    "ADD",
-    "SUB",
-    "MUL",
-    "DIV",
-    "POWER",
-    "PERCENT",
-    "LP",
-    "RP",
-    "LB",
-    "RB",
-    "COLON",
-    "COMMA",
-    "SEMICOLON",
-    "REF2D",
-    "REF2D_R1C1",
-    "BANG",
-    "CONCAT"
-]
-
-
-### generate bit set
-def mk_tokenSet_0():
-    ### var1
-    data = [ 37681618946L, 0L]
-    return data
-_tokenSet_0 = antlr.BitSet(mk_tokenSet_0())
-

tablib/packages/xlwt/ExcelMagic.py

@@ -1,862 +0,0 @@
-# -*- coding: ascii -*-
-"""
-lots of Excel Magic Numbers
-"""
-
-# Boundaries BIFF8+
-
-MAX_ROW = 65536
-MAX_COL = 256
-
-
-biff_records = {
-    0x0000: "DIMENSIONS",
-    0x0001: "BLANK",
-    0x0002: "INTEGER",
-    0x0003: "NUMBER",
-    0x0004: "LABEL",
-    0x0005: "BOOLERR",
-    0x0006: "FORMULA",
-    0x0007: "STRING",
-    0x0008: "ROW",
-    0x0009: "BOF",
-    0x000A: "EOF",
-    0x000B: "INDEX",
-    0x000C: "CALCCOUNT",
-    0x000D: "CALCMODE",
-    0x000E: "PRECISION",
-    0x000F: "REFMODE",
-    0x0010: "DELTA",
-    0x0011: "ITERATION",
-    0x0012: "PROTECT",
-    0x0013: "PASSWORD",
-    0x0014: "HEADER",
-    0x0015: "FOOTER",
-    0x0016: "EXTERNCOUNT",
-    0x0017: "EXTERNSHEET",
-    0x0018: "NAME",
-    0x0019: "WINDOWPROTECT",
-    0x001A: "VERTICALPAGEBREAKS",
-    0x001B: "HORIZONTALPAGEBREAKS",
-    0x001C: "NOTE",
-    0x001D: "SELECTION",
-    0x001E: "FORMAT",
-    0x001F: "FORMATCOUNT",
-    0x0020: "COLUMNDEFAULT",
-    0x0021: "ARRAY",
-    0x0022: "1904",
-    0x0023: "EXTERNNAME",
-    0x0024: "COLWIDTH",
-    0x0025: "DEFAULTROWHEIGHT",
-    0x0026: "LEFTMARGIN",
-    0x0027: "RIGHTMARGIN",
-    0x0028: "TOPMARGIN",
-    0x0029: "BOTTOMMARGIN",
-    0x002A: "PRINTHEADERS",
-    0x002B: "PRINTGRIDLINES",
-    0x002F: "FILEPASS",
-    0x0031: "FONT",
-    0x0036: "TABLE",
-    0x003C: "CONTINUE",
-    0x003D: "WINDOW1",
-    0x003E: "WINDOW2",
-    0x0040: "BACKUP",
-    0x0041: "PANE",
-    0x0042: "CODEPAGE",
-    0x0043: "XF",
-    0x0044: "IXFE",
-    0x0045: "EFONT",
-    0x004D: "PLS",
-    0x0050: "DCON",
-    0x0051: "DCONREF",
-    0x0053: "DCONNAME",
-    0x0055: "DEFCOLWIDTH",
-    0x0056: "BUILTINFMTCNT",
-    0x0059: "XCT",
-    0x005A: "CRN",
-    0x005B: "FILESHARING",
-    0x005C: "WRITEACCESS",
-    0x005D: "OBJ",
-    0x005E: "UNCALCED",
-    0x005F: "SAFERECALC",
-    0x0060: "TEMPLATE",
-    0x0063: "OBJPROTECT",
-    0x007D: "COLINFO",
-    0x007E: "RK",
-    0x007F: "IMDATA",
-    0x0080: "GUTS",
-    0x0081: "WSBOOL",
-    0x0082: "GRIDSET",
-    0x0083: "HCENTER",
-    0x0084: "VCENTER",
-    0x0085: "BOUNDSHEET",
-    0x0086: "WRITEPROT",
-    0x0087: "ADDIN",
-    0x0088: "EDG",
-    0x0089: "PUB",
-    0x008C: "COUNTRY",
-    0x008D: "HIDEOBJ",
-    0x008E: "BUNDLESOFFSET",
-    0x008F: "BUNDLEHEADER",
-    0x0090: "SORT",
-    0x0091: "SUB",
-    0x0092: "PALETTE",
-    0x0093: "STYLE",
-    0x0094: "LHRECORD",
-    0x0095: "LHNGRAPH",
-    0x0096: "SOUND",
-    0x0098: "LPR",
-    0x0099: "STANDARDWIDTH",
-    0x009A: "FNGROUPNAME",
-    0x009B: "FILTERMODE",
-    0x009C: "FNGROUPCOUNT",
-    0x009D: "AUTOFILTERINFO",
-    0x009E: "AUTOFILTER",
-    0x00A0: "SCL",
-    0x00A1: "SETUP",
-    0x00A9: "COORDLIST",
-    0x00AB: "GCW",
-    0x00AE: "SCENMAN",
-    0x00AF: "SCENARIO",
-    0x00B0: "SXVIEW",
-    0x00B1: "SXVD",
-    0x00B2: "SXVI",
-    0x00B4: "SXIVD",
-    0x00B5: "SXLI",
-    0x00B6: "SXPI",
-    0x00B8: "DOCROUTE",
-    0x00B9: "RECIPNAME",
-    0x00BC: "SHRFMLA",
-    0x00BD: "MULRK",
-    0x00BE: "MULBLANK",
-    0x00C1: "MMS",
-    0x00C2: "ADDMENU",
-    0x00C3: "DELMENU",
-    0x00C5: "SXDI",
-    0x00C6: "SXDB",
-    0x00C7: "SXFIELD",
-    0x00C8: "SXINDEXLIST",
-    0x00C9: "SXDOUBLE",
-    0x00CD: "SXSTRING",
-    0x00CE: "SXDATETIME",
-    0x00D0: "SXTBL",
-    0x00D1: "SXTBRGITEM",
-    0x00D2: "SXTBPG",
-    0x00D3: "OBPROJ",
-    0x00D5: "SXIDSTM",
-    0x00D6: "RSTRING",
-    0x00D7: "DBCELL",
-    0x00DA: "BOOKBOOL",
-    0x00DC: "SXEXT|PARAMQRY",
-    0x00DD: "SCENPROTECT",
-    0x00DE: "OLESIZE",
-    0x00DF: "UDDESC",
-    0x00E0: "XF",
-    0x00E1: "INTERFACEHDR",
-    0x00E2: "INTERFACEEND",
-    0x00E3: "SXVS",
-    0x00E5: "MERGEDCELLS",
-    0x00E9: "BITMAP",
-    0x00EB: "MSODRAWINGGROUP",
-    0x00EC: "MSODRAWING",
-    0x00ED: "MSODRAWINGSELECTION",
-    0x00F0: "SXRULE",
-    0x00F1: "SXEX",
-    0x00F2: "SXFILT",
-    0x00F6: "SXNAME",
-    0x00F7: "SXSELECT",
-    0x00F8: "SXPAIR",
-    0x00F9: "SXFMLA",
-    0x00FB: "SXFORMAT",
-    0x00FC: "SST",
-    0x00FD: "LABELSST",
-    0x00FF: "EXTSST",
-    0x0100: "SXVDEX",
-    0x0103: "SXFORMULA",
-    0x0122: "SXDBEX",
-    0x0137: "CHTRINSERT",
-    0x0138: "CHTRINFO",
-    0x013B: "CHTRCELLCONTENT",
-    0x013D: "TABID",
-    0x0140: "CHTRMOVERANGE",
-    0x014D: "CHTRINSERTTAB",
-    0x015F: "LABELRANGES",
-    0x0160: "USESELFS",
-    0x0161: "DSF",
-    0x0162: "XL5MODIFY",
-    0x0196: "CHTRHEADER",
-    0x01A9: "USERBVIEW",
-    0x01AA: "USERSVIEWBEGIN",
-    0x01AB: "USERSVIEWEND",
-    0x01AD: "QSI",
-    0x01AE: "SUPBOOK",
-    0x01AF: "PROT4REV",
-    0x01B0: "CONDFMT",
-    0x01B1: "CF",
-    0x01B2: "DVAL",
-    0x01B5: "DCONBIN",
-    0x01B6: "TXO",
-    0x01B7: "REFRESHALL",
-    0x01B8: "HLINK",
-    0x01BA: "CODENAME",
-    0x01BB: "SXFDBTYPE",
-    0x01BC: "PROT4REVPASS",
-    0x01BE: "DV",
-    0x01C0: "XL9FILE",
-    0x01C1: "RECALCID",
-    0x0200: "DIMENSIONS",
-    0x0201: "BLANK",
-    0x0203: "NUMBER",
-    0x0204: "LABEL",
-    0x0205: "BOOLERR",
-    0x0206: "FORMULA",
-    0x0207: "STRING",
-    0x0208: "ROW",
-    0x0209: "BOF",
-    0x020B: "INDEX",
-    0x0218: "NAME",
-    0x0221: "ARRAY",
-    0x0223: "EXTERNNAME",
-    0x0225: "DEFAULTROWHEIGHT",
-    0x0231: "FONT",
-    0x0236: "TABLE",
-    0x023E: "WINDOW2",
-    0x0243: "XF",
-    0x027E: "RK",
-    0x0293: "STYLE",
-    0x0406: "FORMULA",
-    0x0409: "BOF",
-    0x041E: "FORMAT",
-    0x0443: "XF",
-    0x04BC: "SHRFMLA",
-    0x0800: "SCREENTIP",
-    0x0803: "WEBQRYSETTINGS",
-    0x0804: "WEBQRYTABLES",
-    0x0809: "BOF",
-    0x0862: "SHEETLAYOUT",
-    0x0867: "SHEETPROTECTION",
-    0x1001: "UNITS",
-    0x1002: "ChartChart",
-    0x1003: "ChartSeries",
-    0x1006: "ChartDataformat",
-    0x1007: "ChartLineformat",
-    0x1009: "ChartMarkerformat",
-    0x100A: "ChartAreaformat",
-    0x100B: "ChartPieformat",
-    0x100C: "ChartAttachedlabel",
-    0x100D: "ChartSeriestext",
-    0x1014: "ChartChartformat",
-    0x1015: "ChartLegend",
-    0x1016: "ChartSerieslist",
-    0x1017: "ChartBar",
-    0x1018: "ChartLine",
-    0x1019: "ChartPie",
-    0x101A: "ChartArea",
-    0x101B: "ChartScatter",
-    0x101C: "ChartChartline",
-    0x101D: "ChartAxis",
-    0x101E: "ChartTick",
-    0x101F: "ChartValuerange",
-    0x1020: "ChartCatserrange",
-    0x1021: "ChartAxislineformat",
-    0x1022: "ChartFormatlink",
-    0x1024: "ChartDefaulttext",
-    0x1025: "ChartText",
-    0x1026: "ChartFontx",
-    0x1027: "ChartObjectLink",
-    0x1032: "ChartFrame",
-    0x1033: "BEGIN",
-    0x1034: "END",
-    0x1035: "ChartPlotarea",
-    0x103A: "Chart3D",
-    0x103C: "ChartPicf",
-    0x103D: "ChartDropbar",
-    0x103E: "ChartRadar",
-    0x103F: "ChartSurface",
-    0x1040: "ChartRadararea",
-    0x1041: "ChartAxisparent",
-    0x1043: "ChartLegendxn",
-    0x1044: "ChartShtprops",
-    0x1045: "ChartSertocrt",
-    0x1046: "ChartAxesused",
-    0x1048: "ChartSbaseref",
-    0x104A: "ChartSerparent",
-    0x104B: "ChartSerauxtrend",
-    0x104E: "ChartIfmt",
-    0x104F: "ChartPos",
-    0x1050: "ChartAlruns",
-    0x1051: "ChartAI",
-    0x105B: "ChartSerauxerrbar",
-    0x105D: "ChartSerfmt",
-    0x105F: "Chart3DDataFormat",
-    0x1060: "ChartFbi",
-    0x1061: "ChartBoppop",
-    0x1062: "ChartAxcext",
-    0x1063: "ChartDat",
-    0x1064: "ChartPlotgrowth",
-    0x1065: "ChartSiindex",
-    0x1066: "ChartGelframe",
-    0x1067: "ChartBoppcustom",
-    0xFFFF: ""
-}
-
-
-all_funcs_by_name = {
-    # Includes Analysis ToolPak aka ATP aka add-in aka xcall functions,
-    # distinguished by -ve opcode.
-    # name: (opcode, min # args, max # args, func return type, func arg types)
-    # + in func arg types means more of the same.
-    'ABS'         : ( 24, 1,  1, 'V', 'V'),
-    'ACCRINT'     : ( -1, 6,  7, 'V', 'VVVVVVV'),
-    'ACCRINTM'    : ( -1, 3,  5, 'V', 'VVVVV'),
-    'ACOS'        : ( 99, 1,  1, 'V', 'V'),
-    'ACOSH'       : (233, 1,  1, 'V', 'V'),
-    'ADDRESS'     : (219, 2,  5, 'V', 'VVVVV'),
-    'AMORDEGRC'   : ( -1, 7,  7, 'V', 'VVVVVVV'),
-    'AMORLINC'    : ( -1, 7,  7, 'V', 'VVVVVVV'),
-    'AND'         : ( 36, 1, 30, 'V', 'D+'),
-    'AREAS'       : ( 75, 1,  1, 'V', 'R'),
-    'ASC'         : (214, 1,  1, 'V', 'V'),
-    'ASIN'        : ( 98, 1,  1, 'V', 'V'),
-    'ASINH'       : (232, 1,  1, 'V', 'V'),
-    'ATAN'        : ( 18, 1,  1, 'V', 'V'),
-    'ATAN2'       : ( 97, 2,  2, 'V', 'VV'),
-    'ATANH'       : (234, 1,  1, 'V', 'V'),
-    'AVEDEV'      : (269, 1, 30, 'V', 'D+'),
-    'AVERAGE'     : (  5, 1, 30, 'V', 'D+'),
-    'AVERAGEA'    : (361, 1, 30, 'V', 'D+'),
-    'BAHTTEXT'    : (368, 1,  1, 'V', 'V'),
-    'BESSELI'     : ( -1, 2,  2, 'V', 'VV'),
-    'BESSELJ'     : ( -1, 2,  2, 'V', 'VV'),
-    'BESSELK'     : ( -1, 2,  2, 'V', 'VV'),
-    'BESSELY'     : ( -1, 2,  2, 'V', 'VV'),
-    'BETADIST'    : (270, 3,  5, 'V', 'VVVVV'),
-    'BETAINV'     : (272, 3,  5, 'V', 'VVVVV'),
-    'BIN2DEC'     : ( -1, 1,  1, 'V', 'V'),
-    'BIN2HEX'     : ( -1, 1,  2, 'V', 'VV'),
-    'BIN2OCT'     : ( -1, 1,  2, 'V', 'VV'),
-    'BINOMDIST'   : (273, 4,  4, 'V', 'VVVV'),
-    'CEILING'     : (288, 2,  2, 'V', 'VV'),
-    'CELL'        : (125, 1,  2, 'V', 'VR'),
-    'CHAR'        : (111, 1,  1, 'V', 'V'),
-    'CHIDIST'     : (274, 2,  2, 'V', 'VV'),
-    'CHIINV'      : (275, 2,  2, 'V', 'VV'),
-    'CHITEST'     : (306, 2,  2, 'V', 'AA'),
-    'CHOOSE'      : (100, 2, 30, 'R', 'VR+'),
-    'CLEAN'       : (162, 1,  1, 'V', 'V'),
-    'CODE'        : (121, 1,  1, 'V', 'V'),
-    'COLUMN'      : (  9, 0,  1, 'V', 'R'),
-    'COLUMNS'     : ( 77, 1,  1, 'V', 'R'),
-    'COMBIN'      : (276, 2,  2, 'V', 'VV'),
-    'COMPLEX'     : ( -1, 2,  3, 'V', 'VVV'),
-    'CONCATENATE' : (336, 1, 30, 'V', 'V+'),
-    'CONFIDENCE'  : (277, 3,  3, 'V', 'VVV'),
-    'CONVERT'     : ( -1, 3,  3, 'V', 'VVV'),
-    'CORREL'      : (307, 2,  2, 'V', 'AA'),
-    'COS'         : ( 16, 1,  1, 'V', 'V'),
-    'COSH'        : (230, 1,  1, 'V', 'V'),
-    'COUNT'       : (  0, 1, 30, 'V', 'D+'),
-    'COUNTA'      : (169, 1, 30, 'V', 'D+'),
-    'COUNTBLANK'  : (347, 1,  1, 'V', 'R'),
-    'COUNTIF'     : (346, 2,  2, 'V', 'RV'),
-    'COUPDAYBS'   : ( -1, 3,  5, 'V', 'VVVVV'),
-    'COUPDAYS'    : ( -1, 3,  5, 'V', 'VVVVV'),
-    'COUPDAYSNC'  : ( -1, 3,  5, 'V', 'VVVVV'),
-    'COUPNCD'     : ( -1, 3,  5, 'V', 'VVVVV'),
-    'COUPNUM'     : ( -1, 3,  5, 'V', 'VVVVV'),
-    'COUPPCD'     : ( -1, 3,  5, 'V', 'VVVVV'),
-    'COVAR'       : (308, 2,  2, 'V', 'AA'),
-    'CRITBINOM'   : (278, 3,  3, 'V', 'VVV'),
-    'CUMIPMT'     : ( -1, 6,  6, 'V', 'VVVVVV'),
-    'CUMPRINC'    : ( -1, 6,  6, 'V', 'VVVVVV'),
-    'DATE'        : ( 65, 3,  3, 'V', 'VVV'),
-    'DATEDIF'     : (351, 3,  3, 'V', 'VVV'),
-    'DATEVALUE'   : (140, 1,  1, 'V', 'V'),
-    'DAVERAGE'    : ( 42, 3,  3, 'V', 'RRR'),
-    'DAY'         : ( 67, 1,  1, 'V', 'V'),
-    'DAYS360'     : (220, 2,  3, 'V', 'VVV'),
-    'DB'          : (247, 4,  5, 'V', 'VVVVV'),
-    'DBCS'        : (215, 1,  1, 'V', 'V'),
-    'DCOUNT'      : ( 40, 3,  3, 'V', 'RRR'),
-    'DCOUNTA'     : (199, 3,  3, 'V', 'RRR'),
-    'DDB'         : (144, 4,  5, 'V', 'VVVVV'),
-    'DEC2BIN'     : ( -1, 1,  2, 'V', 'VV'),
-    'DEC2HEX'     : ( -1, 1,  2, 'V', 'VV'),
-    'DEC2OCT'     : ( -1, 1,  2, 'V', 'VV'),
-    'DEGREES'     : (343, 1,  1, 'V', 'V'),
-    'DELTA'       : ( -1, 1,  2, 'V', 'VV'),
-    'DEVSQ'       : (318, 1, 30, 'V', 'D+'),
-    'DGET'        : (235, 3,  3, 'V', 'RRR'),
-    'DISC'        : ( -1, 4,  5, 'V', 'VVVVV'),
-    'DMAX'        : ( 44, 3,  3, 'V', 'RRR'),
-    'DMIN'        : ( 43, 3,  3, 'V', 'RRR'),
-    'DOLLAR'      : ( 13, 1,  2, 'V', 'VV'),
-    'DOLLARDE'    : ( -1, 2,  2, 'V', 'VV'),
-    'DOLLARFR'    : ( -1, 2,  2, 'V', 'VV'),
-    'DPRODUCT'    : (189, 3,  3, 'V', 'RRR'),
-    'DSTDEV'      : ( 45, 3,  3, 'V', 'RRR'),
-    'DSTDEVP'     : (195, 3,  3, 'V', 'RRR'),
-    'DSUM'        : ( 41, 3,  3, 'V', 'RRR'),
-    'DURATION'    : ( -1, 5,  6, 'V', 'VVVVVV'),
-    'DVAR'        : ( 47, 3,  3, 'V', 'RRR'),
-    'DVARP'       : (196, 3,  3, 'V', 'RRR'),
-    'EDATE'       : ( -1, 2,  2, 'V', 'VV'),
-    'EFFECT'      : ( -1, 2,  2, 'V', 'VV'),
-    'EOMONTH'     : ( -1, 1,  2, 'V', 'VV'),
-    'ERF'         : ( -1, 1,  2, 'V', 'VV'),
-    'ERFC'        : ( -1, 1,  1, 'V', 'V'),
-    'ERROR.TYPE'  : (261, 1,  1, 'V', 'V'),
-    'EVEN'        : (279, 1,  1, 'V', 'V'),
-    'EXACT'       : (117, 2,  2, 'V', 'VV'),
-    'EXP'         : ( 21, 1,  1, 'V', 'V'),
-    'EXPONDIST'   : (280, 3,  3, 'V', 'VVV'),
-    'FACT'        : (184, 1,  1, 'V', 'V'),
-    'FACTDOUBLE'  : ( -1, 1,  1, 'V', 'V'),
-    'FALSE'       : ( 35, 0,  0, 'V', '-'),
-    'FDIST'       : (281, 3,  3, 'V', 'VVV'),
-    'FIND'        : (124, 2,  3, 'V', 'VVV'),
-    'FINDB'       : (205, 2,  3, 'V', 'VVV'),
-    'FINV'        : (282, 3,  3, 'V', 'VVV'),
-    'FISHER'      : (283, 1,  1, 'V', 'V'),
-    'FISHERINV'   : (284, 1,  1, 'V', 'V'),
-    'FIXED'       : ( 14, 2,  3, 'V', 'VVV'),
-    'FLOOR'       : (285, 2,  2, 'V', 'VV'),
-    'FORECAST'    : (309, 3,  3, 'V', 'VAA'),
-    'FREQUENCY'   : (252, 2,  2, 'A', 'RR'),
-    'FTEST'       : (310, 2,  2, 'V', 'AA'),
-    'FV'          : ( 57, 3,  5, 'V', 'VVVVV'),
-    'FVSCHEDULE'  : ( -1, 2,  2, 'V', 'VA'),
-    'GAMMADIST'   : (286, 4,  4, 'V', 'VVVV'),
-    'GAMMAINV'    : (287, 3,  3, 'V', 'VVV'),
-    'GAMMALN'     : (271, 1,  1, 'V', 'V'),
-    'GCD'         : ( -1, 1, 29, 'V', 'V+'),
-    'GEOMEAN'     : (319, 1, 30, 'V', 'D+'),
-    'GESTEP'      : ( -1, 1,  2, 'V', 'VV'),
-    'GETPIVOTDATA': (358, 2, 30, 'A', 'VAV+'),
-    'GROWTH'      : ( 52, 1,  4, 'A', 'RRRV'),
-    'HARMEAN'     : (320, 1, 30, 'V', 'D+'),
-    'HEX2BIN'     : ( -1, 1,  2, 'V', 'VV'),
-    'HEX2DEC'     : ( -1, 1,  1, 'V', 'V'),
-    'HEX2OCT'     : ( -1, 1,  2, 'V', 'VV'),
-    'HLOOKUP'     : (101, 3,  4, 'V', 'VRRV'),
-    'HOUR'        : ( 71, 1,  1, 'V', 'V'),
-    'HYPERLINK'   : (359, 1,  2, 'V', 'VV'),
-    'HYPGEOMDIST' : (289, 4,  4, 'V', 'VVVV'),
-    'IF'          : (  1, 2,  3, 'R', 'VRR'),
-    'IMABS'       : ( -1, 1,  1, 'V', 'V'),
-    'IMAGINARY'   : ( -1, 1,  1, 'V', 'V'),
-    'IMARGUMENT'  : ( -1, 1,  1, 'V', 'V'),
-    'IMCONJUGATE' : ( -1, 1,  1, 'V', 'V'),
-    'IMCOS'       : ( -1, 1,  1, 'V', 'V'),
-    'IMDIV'       : ( -1, 2,  2, 'V', 'VV'),
-    'IMEXP'       : ( -1, 1,  1, 'V', 'V'),
-    'IMLN'        : ( -1, 1,  1, 'V', 'V'),
-    'IMLOG10'     : ( -1, 1,  1, 'V', 'V'),
-    'IMLOG2'      : ( -1, 1,  1, 'V', 'V'),
-    'IMPOWER'     : ( -1, 2,  2, 'V', 'VV'),
-    'IMPRODUCT'   : ( -1, 2,  2, 'V', 'VV'),
-    'IMREAL'      : ( -1, 1,  1, 'V', 'V'),
-    'IMSIN'       : ( -1, 1,  1, 'V', 'V'),
-    'IMSQRT'      : ( -1, 1,  1, 'V', 'V'),
-    'IMSUB'       : ( -1, 2,  2, 'V', 'VV'),
-    'IMSUM'       : ( -1, 1, 29, 'V', 'V+'),
-    'INDEX'       : ( 29, 2,  4, 'R', 'RVVV'),
-    'INDIRECT'    : (148, 1,  2, 'R', 'VV'),
-    'INFO'        : (244, 1,  1, 'V', 'V'),
-    'INT'         : ( 25, 1,  1, 'V', 'V'),
-    'INTERCEPT'   : (311, 2,  2, 'V', 'AA'),
-    'INTRATE'     : ( -1, 4,  5, 'V', 'VVVVV'),
-    'IPMT'        : (167, 4,  6, 'V', 'VVVVVV'),
-    'IRR'         : ( 62, 1,  2, 'V', 'RV'),
-    'ISBLANK'     : (129, 1,  1, 'V', 'V'),
-    'ISERR'       : (126, 1,  1, 'V', 'V'),
-    'ISERROR'     : (  3, 1,  1, 'V', 'V'),
-    'ISEVEN'      : ( -1, 1,  1, 'V', 'V'),
-    'ISLOGICAL'   : (198, 1,  1, 'V', 'V'),
-    'ISNA'        : (  2, 1,  1, 'V', 'V'),
-    'ISNONTEXT'   : (190, 1,  1, 'V', 'V'),
-    'ISNUMBER'    : (128, 1,  1, 'V', 'V'),
-    'ISODD'       : ( -1, 1,  1, 'V', 'V'),
-    'ISPMT'       : (350, 4,  4, 'V', 'VVVV'),
-    'ISREF'       : (105, 1,  1, 'V', 'R'),
-    'ISTEXT'      : (127, 1,  1, 'V', 'V'),
-    'KURT'        : (322, 1, 30, 'V', 'D+'),
-    'LARGE'       : (325, 2,  2, 'V', 'RV'),
-    'LCM'         : ( -1, 1, 29, 'V', 'V+'),
-    'LEFT'        : (115, 1,  2, 'V', 'VV'),
-    'LEFTB'       : (208, 1,  2, 'V', 'VV'),
-    'LEN'         : ( 32, 1,  1, 'V', 'V'),
-    'LENB'        : (211, 1,  1, 'V', 'V'),
-    'LINEST'      : ( 49, 1,  4, 'A', 'RRVV'),
-    'LN'          : ( 22, 1,  1, 'V', 'V'),
-    'LOG'         : (109, 1,  2, 'V', 'VV'),
-    'LOG10'       : ( 23, 1,  1, 'V', 'V'),
-    'LOGEST'      : ( 51, 1,  4, 'A', 'RRVV'),
-    'LOGINV'      : (291, 3,  3, 'V', 'VVV'),
-    'LOGNORMDIST' : (290, 3,  3, 'V', 'VVV'),
-    'LOOKUP'      : ( 28, 2,  3, 'V', 'VRR'),
-    'LOWER'       : (112, 1,  1, 'V', 'V'),
-    'MATCH'       : ( 64, 2,  3, 'V', 'VRR'),
-    'MAX'         : (  7, 1, 30, 'V', 'D+'),
-    'MAXA'        : (362, 1, 30, 'V', 'D+'),
-    'MDETERM'     : (163, 1,  1, 'V', 'A'),
-    'MDURATION'   : ( -1, 5,  6, 'V', 'VVVVVV'),
-    'MEDIAN'      : (227, 1, 30, 'V', 'D+'),
-    'MID'         : ( 31, 3,  3, 'V', 'VVV'),
-    'MIDB'        : (210, 3,  3, 'V', 'VVV'),
-    'MIN'         : (  6, 1, 30, 'V', 'D+'),
-    'MINA'        : (363, 1, 30, 'V', 'D+'),
-    'MINUTE'      : ( 72, 1,  1, 'V', 'V'),
-    'MINVERSE'    : (164, 1,  1, 'A', 'A'),
-    'MIRR'        : ( 61, 3,  3, 'V', 'RVV'),
-    'MMULT'       : (165, 2,  2, 'A', 'AA'),
-    'MOD'         : ( 39, 2,  2, 'V', 'VV'),
-    'MODE'        : (330, 1, 30, 'V', 'A+'), ################ weird #################
-    'MONTH'       : ( 68, 1,  1, 'V', 'V'),
-    'MROUND'      : ( -1, 2,  2, 'V', 'VV'),
-    'MULTINOMIAL' : ( -1, 1, 29, 'V', 'V+'),
-    'N'           : (131, 1,  1, 'V', 'R'),
-    'NA'          : ( 10, 0,  0, 'V', '-'),
-    'NEGBINOMDIST': (292, 3,  3, 'V', 'VVV'),
-    'NETWORKDAYS' : ( -1, 2,  3, 'V', 'VVR'),
-    'NOMINAL'     : ( -1, 2,  2, 'V', 'VV'),
-    'NORMDIST'    : (293, 4,  4, 'V', 'VVVV'),
-    'NORMINV'     : (295, 3,  3, 'V', 'VVV'),
-    'NORMSDIST'   : (294, 1,  1, 'V', 'V'),
-    'NORMSINV'    : (296, 1,  1, 'V', 'V'),
-    'NOT'         : ( 38, 1,  1, 'V', 'V'),
-    'NOW'         : ( 74, 0,  0, 'V', '-'),
-    'NPER'        : ( 58, 3,  5, 'V', 'VVVVV'),
-    'NPV'         : ( 11, 2, 30, 'V', 'VD+'),
-    'OCT2BIN'     : ( -1, 1,  2, 'V', 'VV'),
-    'OCT2DEC'     : ( -1, 1,  1, 'V', 'V'),
-    'OCT2HEX'     : ( -1, 1,  2, 'V', 'VV'),
-    'ODD'         : (298, 1,  1, 'V', 'V'),
-    'ODDFPRICE'   : ( -1, 9,  9, 'V', 'VVVVVVVVV'),
-    'ODDFYIELD'   : ( -1, 9,  9, 'V', 'VVVVVVVVV'),
-    'ODDLPRICE'   : ( -1, 8,  8, 'V', 'VVVVVVVV'),
-    'ODDLYIELD'   : ( -1, 8,  8, 'V', 'VVVVVVVV'),
-    'OFFSET'      : ( 78, 3,  5, 'R', 'RVVVV'),
-    'OR'          : ( 37, 1, 30, 'V', 'D+'),
-    'PEARSON'     : (312, 2,  2, 'V', 'AA'),
-    'PERCENTILE'  : (328, 2,  2, 'V', 'RV'),
-    'PERCENTRANK' : (329, 2,  3, 'V', 'RVV'),
-    'PERMUT'      : (299, 2,  2, 'V', 'VV'),
-    'PHONETIC'    : (360, 1,  1, 'V', 'R'),
-    'PI'          : ( 19, 0,  0, 'V', '-'),
-    'PMT'         : ( 59, 3,  5, 'V', 'VVVVV'),
-    'POISSON'     : (300, 3,  3, 'V', 'VVV'),
-    'POWER'       : (337, 2,  2, 'V', 'VV'),
-    'PPMT'        : (168, 4,  6, 'V', 'VVVVVV'),
-    'PRICE'       : ( -1, 6,  7, 'V', 'VVVVVVV'),
-    'PRICEDISC'   : ( -1, 4,  5, 'V', 'VVVVV'),
-    'PRICEMAT'    : ( -1, 5,  6, 'V', 'VVVVVV'),
-    'PROB'        : (317, 3,  4, 'V', 'AAVV'),
-    'PRODUCT'     : (183, 1, 30, 'V', 'D+'),
-    'PROPER'      : (114, 1,  1, 'V', 'V'),
-    'PV'          : ( 56, 3,  5, 'V', 'VVVVV'),
-    'QUARTILE'    : (327, 2,  2, 'V', 'RV'),
-    'QUOTIENT'    : ( -1, 2,  2, 'V', 'VV'),
-    'RADIANS'     : (342, 1,  1, 'V', 'V'),
-    'RAND'        : ( 63, 0,  0, 'V', '-'),
-    'RANDBETWEEN' : ( -1, 2,  2, 'V', 'VV'),
-    'RANK'        : (216, 2,  3, 'V', 'VRV'),
-    'RATE'        : ( 60, 3,  6, 'V', 'VVVVVV'),
-    'RECEIVED'    : ( -1, 4,  5, 'V', 'VVVVV'),
-    'REPLACE'     : (119, 4,  4, 'V', 'VVVV'),
-    'REPLACEB'    : (207, 4,  4, 'V', 'VVVV'),
-    'REPT'        : ( 30, 2,  2, 'V', 'VV'),
-    'RIGHT'       : (116, 1,  2, 'V', 'VV'),
-    'RIGHTB'      : (209, 1,  2, 'V', 'VV'),
-    'ROMAN'       : (354, 1,  2, 'V', 'VV'),
-    'ROUND'       : ( 27, 2,  2, 'V', 'VV'),
-    'ROUNDDOWN'   : (213, 2,  2, 'V', 'VV'),
-    'ROUNDUP'     : (212, 2,  2, 'V', 'VV'),
-    'ROW'         : (  8, 0,  1, 'V', 'R'),
-    'ROWS'        : ( 76, 1,  1, 'V', 'R'),
-    'RSQ'         : (313, 2,  2, 'V', 'AA'),
-    'RTD'         : (379, 3, 30, 'A', 'VVV+'),
-    'SEARCH'      : ( 82, 2,  3, 'V', 'VVV'),
-    'SEARCHB'     : (206, 2,  3, 'V', 'VVV'),
-    'SECOND'      : ( 73, 1,  1, 'V', 'V'),
-    'SERIESSUM'   : ( -1, 4,  4, 'V', 'VVVA'),
-    'SIGN'        : ( 26, 1,  1, 'V', 'V'),
-    'SIN'         : ( 15, 1,  1, 'V', 'V'),
-    'SINH'        : (229, 1,  1, 'V', 'V'),
-    'SKEW'        : (323, 1, 30, 'V', 'D+'),
-    'SLN'         : (142, 3,  3, 'V', 'VVV'),
-    'SLOPE'       : (315, 2,  2, 'V', 'AA'),
-    'SMALL'       : (326, 2,  2, 'V', 'RV'),
-    'SQRT'        : ( 20, 1,  1, 'V', 'V'),
-    'SQRTPI'      : ( -1, 1,  1, 'V', 'V'),
-    'STANDARDIZE' : (297, 3,  3, 'V', 'VVV'),
-    'STDEV'       : ( 12, 1, 30, 'V', 'D+'),
-    'STDEVA'      : (366, 1, 30, 'V', 'D+'),
-    'STDEVP'      : (193, 1, 30, 'V', 'D+'),
-    'STDEVPA'     : (364, 1, 30, 'V', 'D+'),
-    'STEYX'       : (314, 2,  2, 'V', 'AA'),
-    'SUBSTITUTE'  : (120, 3,  4, 'V', 'VVVV'),
-    'SUBTOTAL'    : (344, 2, 30, 'V', 'VR+'),
-    'SUM'         : (  4, 1, 30, 'V', 'D+'),
-    'SUMIF'       : (345, 2,  3, 'V', 'RVR'),
-    'SUMPRODUCT'  : (228, 1, 30, 'V', 'A+'),
-    'SUMSQ'       : (321, 1, 30, 'V', 'D+'),
-    'SUMX2MY2'    : (304, 2,  2, 'V', 'AA'),
-    'SUMX2PY2'    : (305, 2,  2, 'V', 'AA'),
-    'SUMXMY2'     : (303, 2,  2, 'V', 'AA'),
-    'SYD'         : (143, 4,  4, 'V', 'VVVV'),
-    'T'           : (130, 1,  1, 'V', 'R'),
-    'TAN'         : ( 17, 1,  1, 'V', 'V'),
-    'TANH'        : (231, 1,  1, 'V', 'V'),
-    'TBILLEQ'     : ( -1, 3,  3, 'V', 'VVV'),
-    'TBILLPRICE'  : ( -1, 3,  3, 'V', 'VVV'),
-    'TBILLYIELD'  : ( -1, 3,  3, 'V', 'VVV'),
-    'TDIST'       : (301, 3,  3, 'V', 'VVV'),
-    'TEXT'        : ( 48, 2,  2, 'V', 'VV'),
-    'TIME'        : ( 66, 3,  3, 'V', 'VVV'),
-    'TIMEVALUE'   : (141, 1,  1, 'V', 'V'),
-    'TINV'        : (332, 2,  2, 'V', 'VV'),
-    'TODAY'       : (221, 0,  0, 'V', '-'),
-    'TRANSPOSE'   : ( 83, 1,  1, 'A', 'A'),
-    'TREND'       : ( 50, 1,  4, 'A', 'RRRV'),
-    'TRIM'        : (118, 1,  1, 'V', 'V'),
-    'TRIMMEAN'    : (331, 2,  2, 'V', 'RV'),
-    'TRUE'        : ( 34, 0,  0, 'V', '-'),
-    'TRUNC'       : (197, 1,  2, 'V', 'VV'),
-    'TTEST'       : (316, 4,  4, 'V', 'AAVV'),
-    'TYPE'        : ( 86, 1,  1, 'V', 'V'),
-    'UPPER'       : (113, 1,  1, 'V', 'V'),
-    'USDOLLAR'    : (204, 1,  2, 'V', 'VV'),
-    'VALUE'       : ( 33, 1,  1, 'V', 'V'),
-    'VAR'         : ( 46, 1, 30, 'V', 'D+'),
-    'VARA'        : (367, 1, 30, 'V', 'D+'),
-    'VARP'        : (194, 1, 30, 'V', 'D+'),
-    'VARPA'       : (365, 1, 30, 'V', 'D+'),
-    'VDB'         : (222, 5,  7, 'V', 'VVVVVVV'),
-    'VLOOKUP'     : (102, 3,  4, 'V', 'VRRV'),
-    'WEEKDAY'     : ( 70, 1,  2, 'V', 'VV'),
-    'WEEKNUM'     : ( -1, 1,  2, 'V', 'VV'),
-    'WEIBULL'     : (302, 4,  4, 'V', 'VVVV'),
-    'WORKDAY'     : ( -1, 2,  3, 'V', 'VVR'),
-    'XIRR'        : ( -1, 2,  3, 'V', 'AAV'),
-    'XNPV'        : ( -1, 3,  3, 'V', 'VAA'),
-    'YEAR'        : ( 69, 1,  1, 'V', 'V'),
-    'YEARFRAC'    : ( -1, 2,  3, 'V', 'VVV'),
-    'YIELD'       : ( -1, 6,  7, 'V', 'VVVVVVV'),
-    'YIELDDISC'   : ( -1, 4,  5, 'V', 'VVVVV'),
-    'YIELDMAT'    : ( -1, 5,  6, 'V', 'VVVVVV'),
-    'ZTEST'       : (324, 2,  3, 'V', 'RVV'),
-    }
-
-# Formulas Parse things
-
-ptgExp          = 0x01
-ptgTbl          = 0x02
-ptgAdd          = 0x03
-ptgSub          = 0x04
-ptgMul          = 0x05
-ptgDiv          = 0x06
-ptgPower        = 0x07
-ptgConcat       = 0x08
-ptgLT           = 0x09
-ptgLE           = 0x0a
-ptgEQ           = 0x0b
-ptgGE           = 0x0c
-ptgGT           = 0x0d
-ptgNE           = 0x0e
-ptgIsect        = 0x0f
-ptgUnion        = 0x10
-ptgRange        = 0x11
-ptgUplus        = 0x12
-ptgUminus       = 0x13
-ptgPercent      = 0x14
-ptgParen        = 0x15
-ptgMissArg      = 0x16
-ptgStr          = 0x17
-ptgExtend       = 0x18
-ptgAttr         = 0x19
-ptgSheet        = 0x1a
-ptgEndSheet     = 0x1b
-ptgErr          = 0x1c
-ptgBool         = 0x1d
-ptgInt          = 0x1e
-ptgNum          = 0x1f
-
-ptgArrayR       = 0x20
-ptgFuncR        = 0x21
-ptgFuncVarR     = 0x22
-ptgNameR        = 0x23
-ptgRefR         = 0x24
-ptgAreaR        = 0x25
-ptgMemAreaR     = 0x26
-ptgMemErrR      = 0x27
-ptgMemNoMemR    = 0x28
-ptgMemFuncR     = 0x29
-ptgRefErrR      = 0x2a
-ptgAreaErrR     = 0x2b
-ptgRefNR        = 0x2c
-ptgAreaNR       = 0x2d
-ptgMemAreaNR    = 0x2e
-ptgMemNoMemNR   = 0x2f
-ptgNameXR       = 0x39
-ptgRef3dR       = 0x3a
-ptgArea3dR      = 0x3b
-ptgRefErr3dR    = 0x3c
-ptgAreaErr3dR   = 0x3d
-
-ptgArrayV       = 0x40
-ptgFuncV        = 0x41
-ptgFuncVarV     = 0x42
-ptgNameV        = 0x43
-ptgRefV         = 0x44
-ptgAreaV        = 0x45
-ptgMemAreaV     = 0x46
-ptgMemErrV      = 0x47
-ptgMemNoMemV    = 0x48
-ptgMemFuncV     = 0x49
-ptgRefErrV      = 0x4a
-ptgAreaErrV     = 0x4b
-ptgRefNV        = 0x4c
-ptgAreaNV       = 0x4d
-ptgMemAreaNV    = 0x4e
-ptgMemNoMemNV   = 0x4f
-ptgFuncCEV      = 0x58
-ptgNameXV       = 0x59
-ptgRef3dV       = 0x5a
-ptgArea3dV      = 0x5b
-ptgRefErr3dV    = 0x5c
-ptgAreaErr3dV   = 0x5d
-
-ptgArrayA       = 0x60
-ptgFuncA        = 0x61
-ptgFuncVarA     = 0x62
-ptgNameA        = 0x63
-ptgRefA         = 0x64
-ptgAreaA        = 0x65
-ptgMemAreaA     = 0x66
-ptgMemErrA      = 0x67
-ptgMemNoMemA    = 0x68
-ptgMemFuncA     = 0x69
-ptgRefErrA      = 0x6a
-ptgAreaErrA     = 0x6b
-ptgRefNA        = 0x6c
-ptgAreaNA       = 0x6d
-ptgMemAreaNA    = 0x6e
-ptgMemNoMemNA   = 0x6f
-ptgFuncCEA      = 0x78
-ptgNameXA       = 0x79
-ptgRef3dA       = 0x7a
-ptgArea3dA      = 0x7b
-ptgRefErr3dA    = 0x7c
-ptgAreaErr3dA   = 0x7d
-
-
-PtgNames = {
-    ptgExp         : "ptgExp",
-    ptgTbl         : "ptgTbl",
-    ptgAdd         : "ptgAdd",
-    ptgSub         : "ptgSub",
-    ptgMul         : "ptgMul",
-    ptgDiv         : "ptgDiv",
-    ptgPower       : "ptgPower",
-    ptgConcat      : "ptgConcat",
-    ptgLT          : "ptgLT",
-    ptgLE          : "ptgLE",
-    ptgEQ          : "ptgEQ",
-    ptgGE          : "ptgGE",
-    ptgGT          : "ptgGT",
-    ptgNE          : "ptgNE",
-    ptgIsect       : "ptgIsect",
-    ptgUnion       : "ptgUnion",
-    ptgRange       : "ptgRange",
-    ptgUplus       : "ptgUplus",
-    ptgUminus      : "ptgUminus",
-    ptgPercent     : "ptgPercent",
-    ptgParen       : "ptgParen",
-    ptgMissArg     : "ptgMissArg",
-    ptgStr         : "ptgStr",
-    ptgExtend      : "ptgExtend",
-    ptgAttr        : "ptgAttr",
-    ptgSheet       : "ptgSheet",
-    ptgEndSheet    : "ptgEndSheet",
-    ptgErr         : "ptgErr",
-    ptgBool        : "ptgBool",
-    ptgInt         : "ptgInt",
-    ptgNum         : "ptgNum",
-    ptgArrayR      : "ptgArrayR",
-    ptgFuncR       : "ptgFuncR",
-    ptgFuncVarR    : "ptgFuncVarR",
-    ptgNameR       : "ptgNameR",
-    ptgRefR        : "ptgRefR",
-    ptgAreaR       : "ptgAreaR",
-    ptgMemAreaR    : "ptgMemAreaR",
-    ptgMemErrR     : "ptgMemErrR",
-    ptgMemNoMemR   : "ptgMemNoMemR",
-    ptgMemFuncR    : "ptgMemFuncR",
-    ptgRefErrR     : "ptgRefErrR",
-    ptgAreaErrR    : "ptgAreaErrR",
-    ptgRefNR       : "ptgRefNR",
-    ptgAreaNR      : "ptgAreaNR",
-    ptgMemAreaNR   : "ptgMemAreaNR",
-    ptgMemNoMemNR  : "ptgMemNoMemNR",
-    ptgNameXR      : "ptgNameXR",
-    ptgRef3dR      : "ptgRef3dR",
-    ptgArea3dR     : "ptgArea3dR",
-    ptgRefErr3dR   : "ptgRefErr3dR",
-    ptgAreaErr3dR  : "ptgAreaErr3dR",
-    ptgArrayV      : "ptgArrayV",
-    ptgFuncV       : "ptgFuncV",
-    ptgFuncVarV    : "ptgFuncVarV",
-    ptgNameV       : "ptgNameV",
-    ptgRefV        : "ptgRefV",
-    ptgAreaV       : "ptgAreaV",
-    ptgMemAreaV    : "ptgMemAreaV",
-    ptgMemErrV     : "ptgMemErrV",
-    ptgMemNoMemV   : "ptgMemNoMemV",
-    ptgMemFuncV    : "ptgMemFuncV",
-    ptgRefErrV     : "ptgRefErrV",
-    ptgAreaErrV    : "ptgAreaErrV",
-    ptgRefNV       : "ptgRefNV",
-    ptgAreaNV      : "ptgAreaNV",
-    ptgMemAreaNV   : "ptgMemAreaNV",
-    ptgMemNoMemNV  : "ptgMemNoMemNV",
-    ptgFuncCEV     : "ptgFuncCEV",
-    ptgNameXV      : "ptgNameXV",
-    ptgRef3dV      : "ptgRef3dV",
-    ptgArea3dV     : "ptgArea3dV",
-    ptgRefErr3dV   : "ptgRefErr3dV",
-    ptgAreaErr3dV  : "ptgAreaErr3dV",
-    ptgArrayA      : "ptgArrayA",
-    ptgFuncA       : "ptgFuncA",
-    ptgFuncVarA    : "ptgFuncVarA",
-    ptgNameA       : "ptgNameA",
-    ptgRefA        : "ptgRefA",
-    ptgAreaA       : "ptgAreaA",
-    ptgMemAreaA    : "ptgMemAreaA",
-    ptgMemErrA     : "ptgMemErrA",
-    ptgMemNoMemA   : "ptgMemNoMemA",
-    ptgMemFuncA    : "ptgMemFuncA",
-    ptgRefErrA     : "ptgRefErrA",
-    ptgAreaErrA    : "ptgAreaErrA",
-    ptgRefNA       : "ptgRefNA",
-    ptgAreaNA      : "ptgAreaNA",
-    ptgMemAreaNA   : "ptgMemAreaNA",
-    ptgMemNoMemNA  : "ptgMemNoMemNA",
-    ptgFuncCEA     : "ptgFuncCEA",
-    ptgNameXA      : "ptgNameXA",
-    ptgRef3dA      : "ptgRef3dA",
-    ptgArea3dA     : "ptgArea3dA",
-    ptgRefErr3dA   : "ptgRefErr3dA",
-    ptgAreaErr3dA  : "ptgAreaErr3dA"
-}
-
-
-error_msg_by_code = {
-    0x00: u"#NULL!",  # intersection of two cell ranges is empty
-    0x07: u"#DIV/0!", # division by zero
-    0x0F: u"#VALUE!", # wrong type of operand
-    0x17: u"#REF!",   # illegal or deleted cell reference
-    0x1D: u"#NAME?",  # wrong function or range name
-    0x24: u"#NUM!",   # value range overflow
-    0x2A: u"#N/A!"    # argument or function not available
-}

tablib/packages/xlwt/Formatting.py

@@ -1,261 +0,0 @@
-#!/usr/bin/env python
-'''
-The  XF  record is able to store explicit cell formatting attributes or the
-attributes  of  a cell style. Explicit formatting includes the reference to
-a  cell  style  XF  record. This allows to extend a defined cell style with
-some  explicit  attributes.  The  formatting  attributes  are  divided into
-6 groups:
-
-Group           Attributes
--------------------------------------
-Number format   Number format index (index to FORMAT record)
-Font            Font index (index to FONT record)
-Alignment       Horizontal and vertical alignment, text wrap, indentation,
-                orientation/rotation, text direction
-Border          Border line styles and colours
-Background      Background area style and colours
-Protection      Cell locked, formula hidden
-
-For  each  group  a flag in the cell XF record specifies whether to use the
-attributes  contained  in  that  XF  record  or  in  the  referenced  style
-XF  record. In style XF records, these flags specify whether the attributes
-will  overwrite  explicit  cell  formatting  when  the  style is applied to
-a  cell. Changing a cell style (without applying this style to a cell) will
-change  all  cells which already use that style and do not contain explicit
-cell  attributes for the changed style attributes. If a cell XF record does
-not  contain  explicit  attributes  in a group (if the attribute group flag
-is not set), it repeats the attributes of its style XF record.
-
-'''
-
-import BIFFRecords
-
-class Font(object):
-
-    ESCAPEMENT_NONE         = 0x00
-    ESCAPEMENT_SUPERSCRIPT  = 0x01
-    ESCAPEMENT_SUBSCRIPT    = 0x02
-
-    UNDERLINE_NONE          = 0x00
-    UNDERLINE_SINGLE        = 0x01
-    UNDERLINE_SINGLE_ACC    = 0x21
-    UNDERLINE_DOUBLE        = 0x02
-    UNDERLINE_DOUBLE_ACC    = 0x22
-
-    FAMILY_NONE         = 0x00
-    FAMILY_ROMAN        = 0x01
-    FAMILY_SWISS        = 0x02
-    FAMILY_MODERN       = 0x03
-    FAMILY_SCRIPT       = 0x04
-    FAMILY_DECORATIVE   = 0x05
-
-    CHARSET_ANSI_LATIN          = 0x00
-    CHARSET_SYS_DEFAULT         = 0x01
-    CHARSET_SYMBOL              = 0x02
-    CHARSET_APPLE_ROMAN         = 0x4D
-    CHARSET_ANSI_JAP_SHIFT_JIS  = 0x80
-    CHARSET_ANSI_KOR_HANGUL     = 0x81
-    CHARSET_ANSI_KOR_JOHAB      = 0x82
-    CHARSET_ANSI_CHINESE_GBK    = 0x86
-    CHARSET_ANSI_CHINESE_BIG5   = 0x88
-    CHARSET_ANSI_GREEK          = 0xA1
-    CHARSET_ANSI_TURKISH        = 0xA2
-    CHARSET_ANSI_VIETNAMESE     = 0xA3
-    CHARSET_ANSI_HEBREW         = 0xB1
-    CHARSET_ANSI_ARABIC         = 0xB2
-    CHARSET_ANSI_BALTIC         = 0xBA
-    CHARSET_ANSI_CYRILLIC       = 0xCC
-    CHARSET_ANSI_THAI           = 0xDE
-    CHARSET_ANSI_LATIN_II       = 0xEE
-    CHARSET_OEM_LATIN_I         = 0xFF
-
-    def __init__(self):
-        # twip = 1/20 of a point = 1/1440 of a inch
-        # usually resolution == 96 pixels per 1 inch
-        # (rarely 120 pixels per 1 inch or another one)
-
-        self.height = 0x00C8 # 200: this is font with height 10 points
-        self.italic = False
-        self.struck_out = False
-        self.outline = False
-        self.shadow = False
-        self.colour_index = 0x7FFF
-        self.bold = False
-        self._weight = 0x0190 # 0x02BC gives bold font
-        self.escapement = self.ESCAPEMENT_NONE
-        self.underline = self.UNDERLINE_NONE
-        self.family = self.FAMILY_NONE
-        self.charset = self.CHARSET_SYS_DEFAULT
-        self.name = 'Arial'
-
-    def get_biff_record(self):
-        height = self.height
-
-        options = 0x00
-        if self.bold:
-            options |= 0x01
-            self._weight = 0x02BC
-        if self.italic:
-            options |= 0x02
-        if self.underline != self.UNDERLINE_NONE:
-            options |= 0x04
-        if self.struck_out:
-            options |= 0x08
-        if self.outline:
-            options |= 0x010
-        if self.shadow:
-            options |= 0x020
-
-        colour_index = self.colour_index
-        weight = self._weight
-        escapement = self.escapement
-        underline = self.underline
-        family = self.family
-        charset = self.charset
-        name = self.name
-
-        return BIFFRecords.FontRecord(height, options, colour_index, weight, escapement,
-                    underline, family, charset,
-                    name)
-
-    def _search_key(self):
-        return (
-            self.height,
-            self.italic,
-            self.struck_out,
-            self.outline,
-            self.shadow,
-            self.colour_index,
-            self.bold,
-            self._weight,
-            self.escapement,
-            self.underline,
-            self.family,
-            self.charset,
-            self.name,
-            )
-
-class Alignment(object):
-    HORZ_GENERAL                = 0x00
-    HORZ_LEFT                   = 0x01
-    HORZ_CENTER                 = 0x02
-    HORZ_RIGHT                  = 0x03
-    HORZ_FILLED                 = 0x04
-    HORZ_JUSTIFIED              = 0x05 # BIFF4-BIFF8X
-    HORZ_CENTER_ACROSS_SEL      = 0x06 # Centred across selection (BIFF4-BIFF8X)
-    HORZ_DISTRIBUTED            = 0x07 # Distributed (BIFF8X)
-
-    VERT_TOP                    = 0x00
-    VERT_CENTER                 = 0x01
-    VERT_BOTTOM                 = 0x02
-    VERT_JUSTIFIED              = 0x03 # Justified (BIFF5-BIFF8X)
-    VERT_DISTRIBUTED            = 0x04 # Distributed (BIFF8X)
-
-    DIRECTION_GENERAL           = 0x00 # BIFF8X
-    DIRECTION_LR                = 0x01
-    DIRECTION_RL                = 0x02
-
-    ORIENTATION_NOT_ROTATED     = 0x00
-    ORIENTATION_STACKED         = 0x01
-    ORIENTATION_90_CC           = 0x02
-    ORIENTATION_90_CW           = 0x03
-
-    ROTATION_0_ANGLE            = 0x00
-    ROTATION_STACKED            = 0xFF
-
-    WRAP_AT_RIGHT               = 0x01
-    NOT_WRAP_AT_RIGHT           = 0x00
-
-    SHRINK_TO_FIT               = 0x01
-    NOT_SHRINK_TO_FIT           = 0x00
-
-    def __init__(self):
-        self.horz = self.HORZ_GENERAL
-        self.vert = self.VERT_BOTTOM
-        self.dire = self.DIRECTION_GENERAL
-        self.orie = self.ORIENTATION_NOT_ROTATED
-        self.rota = self.ROTATION_0_ANGLE
-        self.wrap = self.NOT_WRAP_AT_RIGHT
-        self.shri = self.NOT_SHRINK_TO_FIT
-        self.inde = 0
-        self.merg = 0
-
-    def _search_key(self):
-        return (
-            self.horz, self.vert, self.dire, self.orie, self.rota,
-            self.wrap, self.shri, self.inde, self.merg,
-            )
-
-class Borders(object):
-    NO_LINE = 0x00
-    THIN    = 0x01
-    MEDIUM  = 0x02
-    DASHED  = 0x03
-    DOTTED  = 0x04
-    THICK   = 0x05
-    DOUBLE  = 0x06
-    HAIR    = 0x07
-    #The following for BIFF8
-    MEDIUM_DASHED               = 0x08
-    THIN_DASH_DOTTED            = 0x09
-    MEDIUM_DASH_DOTTED          = 0x0A
-    THIN_DASH_DOT_DOTTED        = 0x0B
-    MEDIUM_DASH_DOT_DOTTED      = 0x0C
-    SLANTED_MEDIUM_DASH_DOTTED  = 0x0D
-
-    NEED_DIAG1      = 0x01
-    NEED_DIAG2      = 0x01
-    NO_NEED_DIAG1   = 0x00
-    NO_NEED_DIAG2   = 0x00
-
-    def __init__(self):
-        self.left   = self.NO_LINE
-        self.right  = self.NO_LINE
-        self.top    = self.NO_LINE
-        self.bottom = self.NO_LINE
-        self.diag   = self.NO_LINE
-
-        self.left_colour   = 0x40
-        self.right_colour  = 0x40
-        self.top_colour    = 0x40
-        self.bottom_colour = 0x40
-        self.diag_colour   = 0x40
-
-        self.need_diag1 = self.NO_NEED_DIAG1
-        self.need_diag2 = self.NO_NEED_DIAG2
-
-    def _search_key(self):
-        return (
-             self.left, self.right, self.top, self.bottom, self.diag,
-             self.left_colour, self.right_colour, self.top_colour,
-             self.bottom_colour, self.diag_colour,
-             self.need_diag1, self.need_diag2,
-            )
-
-class Pattern(object):
-    # patterns 0x00 - 0x12
-    NO_PATTERN      = 0x00
-    SOLID_PATTERN   = 0x01
-
-    def __init__(self):
-        self.pattern = self.NO_PATTERN
-        self.pattern_fore_colour = 0x40
-        self.pattern_back_colour = 0x41
-
-    def _search_key(self):
-        return (
-            self.pattern,
-            self.pattern_fore_colour,
-            self.pattern_back_colour,
-            )
-
-class Protection(object):
-    def __init__(self):
-        self.cell_locked = 1
-        self.formula_hidden = 0
-
-    def _search_key(self):
-        return (
-            self.cell_locked,
-            self.formula_hidden,
-            )

tablib/packages/xlwt/Row.py

@@ -1,253 +0,0 @@
-# -*- coding: windows-1252 -*-
-
-import BIFFRecords
-import Style
-from Cell import StrCell, BlankCell, NumberCell, FormulaCell, MulBlankCell, BooleanCell, ErrorCell, \
-    _get_cells_biff_data_mul
-import ExcelFormula
-import datetime as dt
-try:
-    from decimal import Decimal
-except ImportError:
-    # Python 2.3: decimal not supported; create dummy Decimal class
-    class Decimal(object):
-        pass
-
-
-class Row(object):
-    __slots__ = [# private variables
-                 "__idx",
-                 "__parent",
-                 "__parent_wb",
-                 "__cells",
-                 "__min_col_idx",
-                 "__max_col_idx",
-                 "__xf_index",
-                 "__has_default_xf_index",
-                 "__height_in_pixels",
-                 # public variables
-                 "height",
-                 "has_default_height",
-                 "height_mismatch",
-                 "level",
-                 "collapse",
-                 "hidden",
-                 "space_above",
-                 "space_below"]
-
-    def __init__(self, rowx, parent_sheet):
-        if not (isinstance(rowx, int) and 0 <= rowx <= 65535):
-            raise ValueError("row index (%r) not an int in range(65536)" % rowx)
-        self.__idx = rowx
-        self.__parent = parent_sheet
-        self.__parent_wb = parent_sheet.get_parent()
-        self.__cells = {}
-        self.__min_col_idx = 0
-        self.__max_col_idx = 0
-        self.__xf_index = 0x0F
-        self.__has_default_xf_index = 0
-        self.__height_in_pixels = 0x11
-
-        self.height = 0x00FF
-        self.has_default_height = 0x00
-        self.height_mismatch = 0
-        self.level = 0
-        self.collapse = 0
-        self.hidden = 0
-        self.space_above = 0
-        self.space_below = 0
-
-
-    def __adjust_height(self, style):
-        twips = style.font.height
-        points = float(twips)/20.0
-        # Cell height in pixels can be calcuted by following approx. formula:
-        # cell height in pixels = font height in points * 83/50 + 2/5
-        # It works when screen resolution is 96 dpi
-        pix = int(round(points*83.0/50.0 + 2.0/5.0))
-        if pix > self.__height_in_pixels:
-            self.__height_in_pixels = pix
-
-
-    def __adjust_bound_col_idx(self, *args):
-        for arg in args:
-            iarg = int(arg)
-            if not ((0 <= iarg <= 255) and arg == iarg):
-                raise ValueError("column index (%r) not an int in range(256)" % arg)
-            sheet = self.__parent
-            if iarg < self.__min_col_idx:
-                self.__min_col_idx = iarg
-            if iarg > self.__max_col_idx:
-                self.__max_col_idx = iarg
-            if iarg < sheet.first_used_col:
-                sheet.first_used_col = iarg
-            if iarg > sheet.last_used_col:
-                sheet.last_used_col = iarg
-
-    def __excel_date_dt(self, date):
-        if isinstance(date, dt.date) and (not isinstance(date, dt.datetime)):
-            epoch = dt.date(1899, 12, 31)
-        elif isinstance(date, dt.time):
-            date = dt.datetime.combine(dt.datetime(1900, 1, 1), date)
-            epoch = dt.datetime(1900, 1, 1, 0, 0, 0)
-        else:
-            epoch = dt.datetime(1899, 12, 31, 0, 0, 0)
-        delta = date - epoch
-        xldate = delta.days + float(delta.seconds) / (24*60*60)
-        # Add a day for Excel's missing leap day in 1900
-        if xldate > 59:
-            xldate += 1
-        return xldate
-
-    def get_height_in_pixels(self):
-        return self.__height_in_pixels
-
-
-    def set_style(self, style):
-        self.__adjust_height(style)
-        self.__xf_index = self.__parent_wb.add_style(style)
-        self.__has_default_xf_index = 1
-
-
-    def get_xf_index(self):
-        return self.__xf_index
-
-
-    def get_cells_count(self):
-        return len(self.__cells)
-
-
-    def get_min_col(self):
-        return self.__min_col_idx
-
-
-    def get_max_col(self):
-        return self.__max_col_idx
-
-
-    def get_row_biff_data(self):
-        height_options = (self.height & 0x07FFF)
-        height_options |= (self.has_default_height & 0x01) << 15
-
-        options =  (self.level & 0x07) << 0
-        options |= (self.collapse & 0x01) << 4
-        options |= (self.hidden & 0x01) << 5
-        options |= (self.height_mismatch & 0x01) << 6
-        options |= (self.__has_default_xf_index & 0x01) << 7
-        options |= (0x01 & 0x01) << 8
-        options |= (self.__xf_index & 0x0FFF) << 16
-        options |= (self.space_above & 1) << 28
-        options |= (self.space_below & 1) << 29
-
-        return BIFFRecords.RowRecord(self.__idx, self.__min_col_idx,
-            self.__max_col_idx, height_options, options).get()
-
-    def insert_cell(self, col_index, cell_obj):
-        if col_index in self.__cells:
-            if not self.__parent._cell_overwrite_ok:
-                msg = "Attempt to overwrite cell: sheetname=%r rowx=%d colx=%d" \
-                    % (self.__parent.name, self.__idx, col_index)
-                raise Exception(msg)
-            prev_cell_obj = self.__cells[col_index]
-            sst_idx = getattr(prev_cell_obj, 'sst_idx', None)
-            if sst_idx is not None:
-                self.__parent_wb.del_str(sst_idx)
-        self.__cells[col_index] = cell_obj
-
-    def insert_mulcells(self, colx1, colx2, cell_obj):
-        self.insert_cell(colx1, cell_obj)
-        for col_index in xrange(colx1+1, colx2+1):
-            self.insert_cell(col_index, None)
-
-    def get_cells_biff_data(self):
-        cell_items = [item for item in self.__cells.iteritems() if item[1] is not None]
-        cell_items.sort() # in column order
-        return _get_cells_biff_data_mul(self.__idx, cell_items)
-        # previously:
-        # return ''.join([cell.get_biff_data() for colx, cell in cell_items])
-
-    def get_index(self):
-        return self.__idx
-
-    def set_cell_text(self, colx, value, style=Style.default_style):
-        self.__adjust_height(style)
-        self.__adjust_bound_col_idx(colx)
-        xf_index = self.__parent_wb.add_style(style)
-        self.insert_cell(colx, StrCell(self.__idx, colx, xf_index, self.__parent_wb.add_str(value)))
-
-    def set_cell_blank(self, colx, style=Style.default_style):
-        self.__adjust_height(style)
-        self.__adjust_bound_col_idx(colx)
-        xf_index = self.__parent_wb.add_style(style)
-        self.insert_cell(colx, BlankCell(self.__idx, colx, xf_index))
-
-    def set_cell_mulblanks(self, first_colx, last_colx, style=Style.default_style):
-        assert 0 <= first_colx <= last_colx <= 255
-        self.__adjust_height(style)
-        self.__adjust_bound_col_idx(first_colx, last_colx)
-        xf_index = self.__parent_wb.add_style(style)
-        # ncols = last_colx - first_colx + 1
-        self.insert_mulcells(first_colx, last_colx, MulBlankCell(self.__idx, first_colx, last_colx, xf_index))
-
-    def set_cell_number(self, colx, number, style=Style.default_style):
-        self.__adjust_height(style)
-        self.__adjust_bound_col_idx(colx)
-        xf_index = self.__parent_wb.add_style(style)
-        self.insert_cell(colx, NumberCell(self.__idx, colx, xf_index, number))
-
-    def set_cell_date(self, colx, datetime_obj, style=Style.default_style):
-        self.__adjust_height(style)
-        self.__adjust_bound_col_idx(colx)
-        xf_index = self.__parent_wb.add_style(style)
-        self.insert_cell(colx,
-            NumberCell(self.__idx, colx, xf_index, self.__excel_date_dt(datetime_obj)))
-
-    def set_cell_formula(self, colx, formula, style=Style.default_style, calc_flags=0):
-        self.__adjust_height(style)
-        self.__adjust_bound_col_idx(colx)
-        xf_index = self.__parent_wb.add_style(style)
-        self.__parent_wb.add_sheet_reference(formula)
-        self.insert_cell(colx, FormulaCell(self.__idx, colx, xf_index, formula, calc_flags=0))
-
-    def set_cell_boolean(self, colx, value, style=Style.default_style):
-        self.__adjust_height(style)
-        self.__adjust_bound_col_idx(colx)
-        xf_index = self.__parent_wb.add_style(style)
-        self.insert_cell(colx, BooleanCell(self.__idx, colx, xf_index, bool(value)))
-
-    def set_cell_error(self, colx, error_string_or_code, style=Style.default_style):
-        self.__adjust_height(style)
-        self.__adjust_bound_col_idx(colx)
-        xf_index = self.__parent_wb.add_style(style)
-        self.insert_cell(colx, ErrorCell(self.__idx, colx, xf_index, error_string_or_code))
-
-    def write(self, col, label, style=Style.default_style):
-        self.__adjust_height(style)
-        self.__adjust_bound_col_idx(col)
-        style_index = self.__parent_wb.add_style(style)
-        if isinstance(label, basestring):
-            if len(label) > 0:
-                self.insert_cell(col,
-                    StrCell(self.__idx, col, style_index, self.__parent_wb.add_str(label))
-                    )
-            else:
-                self.insert_cell(col, BlankCell(self.__idx, col, style_index))
-        elif isinstance(label, bool): # bool is subclass of int; test bool first
-            self.insert_cell(col, BooleanCell(self.__idx, col, style_index, label))
-        elif isinstance(label, (float, int, long, Decimal)):
-            self.insert_cell(col, NumberCell(self.__idx, col, style_index, label))
-        elif isinstance(label, (dt.datetime, dt.date, dt.time)):
-            date_number = self.__excel_date_dt(label)
-            self.insert_cell(col, NumberCell(self.__idx, col, style_index, date_number))
-        elif label is None:
-            self.insert_cell(col, BlankCell(self.__idx, col, style_index))
-        elif isinstance(label, ExcelFormula.Formula):
-            self.__parent_wb.add_sheet_reference(label)
-            self.insert_cell(col, FormulaCell(self.__idx, col, style_index, label))
-        else:
-            raise Exception("Unexpected data type %r" % type(label))
-
-    write_blanks = set_cell_mulblanks
-
-
-

tablib/packages/xlwt/Style.py

@@ -1,592 +0,0 @@
-# -*- coding: windows-1252 -*-
-
-import Formatting
-from BIFFRecords import *
-
-FIRST_USER_DEFINED_NUM_FORMAT_IDX = 164
-
-class XFStyle(object):
-
-    def __init__(self):
-        self.num_format_str  = 'General'
-        self.font            = Formatting.Font()
-        self.alignment       = Formatting.Alignment()
-        self.borders         = Formatting.Borders()
-        self.pattern         = Formatting.Pattern()
-        self.protection      = Formatting.Protection()
-
-default_style = XFStyle()
-
-class StyleCollection(object):
-    _std_num_fmt_list = [
-            'general',
-            '0',
-            '0.00',
-            '#,##0',
-            '#,##0.00',
-            '"$"#,##0_);("$"#,##',
-            '"$"#,##0_);[Red]("$"#,##',
-            '"$"#,##0.00_);("$"#,##',
-            '"$"#,##0.00_);[Red]("$"#,##',
-            '0%',
-            '0.00%',
-            '0.00E+00',
-            '# ?/?',
-            '# ??/??',
-            'M/D/YY',
-            'D-MMM-YY',
-            'D-MMM',
-            'MMM-YY',
-            'h:mm AM/PM',
-            'h:mm:ss AM/PM',
-            'h:mm',
-            'h:mm:ss',
-            'M/D/YY h:mm',
-            '_(#,##0_);(#,##0)',
-            '_(#,##0_);[Red](#,##0)',
-            '_(#,##0.00_);(#,##0.00)',
-            '_(#,##0.00_);[Red](#,##0.00)',
-            '_("$"* #,##0_);_("$"* (#,##0);_("$"* "-"_);_(@_)',
-            '_(* #,##0_);_(* (#,##0);_(* "-"_);_(@_)',
-            '_("$"* #,##0.00_);_("$"* (#,##0.00);_("$"* "-"??_);_(@_)',
-            '_(* #,##0.00_);_(* (#,##0.00);_(* "-"??_);_(@_)',
-            'mm:ss',
-            '[h]:mm:ss',
-            'mm:ss.0',
-            '##0.0E+0',
-            '@'
-    ]
-
-    def __init__(self, style_compression=0):
-        self.style_compression = style_compression
-        self.stats = [0, 0, 0, 0, 0, 0]
-        self._font_id2x = {}
-        self._font_x2id = {}
-        self._font_val2x = {}
-
-        for x in (0, 1, 2, 3, 5): # The font with index 4 is omitted in all BIFF versions
-            font = Formatting.Font()
-            search_key = font._search_key()
-            self._font_id2x[font] = x
-            self._font_x2id[x] = font
-            self._font_val2x[search_key] = x
-
-        self._xf_id2x = {}
-        self._xf_x2id = {}
-        self._xf_val2x = {}
-
-        self._num_formats = {}
-        for fmtidx, fmtstr in zip(range(0, 23), StyleCollection._std_num_fmt_list[0:23]):
-            self._num_formats[fmtstr] = fmtidx
-        for fmtidx, fmtstr in zip(range(37, 50), StyleCollection._std_num_fmt_list[23:]):
-            self._num_formats[fmtstr] = fmtidx
-
-        self.default_style = XFStyle()
-        self._default_xf = self._add_style(self.default_style)[0]
-
-    def add(self, style):
-        if style == None:
-            return 0x10
-        return self._add_style(style)[1]
-
-    def _add_style(self, style):
-        num_format_str = style.num_format_str
-        if num_format_str in self._num_formats:
-            num_format_idx = self._num_formats[num_format_str]
-        else:
-            num_format_idx = (
-                FIRST_USER_DEFINED_NUM_FORMAT_IDX
-                + len(self._num_formats)
-                - len(StyleCollection._std_num_fmt_list)
-                )
-            self._num_formats[num_format_str] = num_format_idx
-
-        font = style.font
-        if font in self._font_id2x:
-            font_idx = self._font_id2x[font]
-            self.stats[0] += 1
-        elif self.style_compression:
-            search_key = font._search_key()
-            font_idx = self._font_val2x.get(search_key)
-            if font_idx is not None:
-                self._font_id2x[font] = font_idx
-                self.stats[1] += 1
-            else:
-                font_idx = len(self._font_x2id) + 1 # Why plus 1? Font 4 is missing
-                self._font_id2x[font] = font_idx
-                self._font_val2x[search_key] = font_idx
-                self._font_x2id[font_idx] = font
-                self.stats[2] += 1
-        else:
-            font_idx = len(self._font_id2x) + 1
-            self._font_id2x[font] = font_idx
-            self.stats[2] += 1
-
-        gof = (style.alignment, style.borders, style.pattern, style.protection)
-        xf = (font_idx, num_format_idx) + gof
-        if xf in self._xf_id2x:
-            xf_index = self._xf_id2x[xf]
-            self.stats[3] += 1
-        elif self.style_compression == 2:
-            xf_key = (font_idx, num_format_idx) + tuple([obj._search_key() for obj in gof])
-            xf_index = self._xf_val2x.get(xf_key)
-            if xf_index is not None:
-                self._xf_id2x[xf] = xf_index
-                self.stats[4] += 1
-            else:
-                xf_index = 0x10 + len(self._xf_x2id)
-                self._xf_id2x[xf] = xf_index
-                self._xf_val2x[xf_key] = xf_index
-                self._xf_x2id[xf_index] = xf
-                self.stats[5] += 1
-        else:
-            xf_index = 0x10 + len(self._xf_id2x)
-            self._xf_id2x[xf] = xf_index
-            self.stats[5] += 1
-
-        if xf_index >= 0xFFF:
-            # 12 bits allowed, 0xFFF is a sentinel value
-            raise ValueError("More than 4094 XFs (styles)")
-
-        return xf, xf_index
-
-    def get_biff_data(self):
-        result = ''
-        result += self._all_fonts()
-        result += self._all_num_formats()
-        result += self._all_cell_styles()
-        result += self._all_styles()
-        return result
-
-    def _all_fonts(self):
-        result = ''
-        if self.style_compression:
-            alist = self._font_x2id.items()
-        else:
-            alist = [(x, o) for o, x in self._font_id2x.items()]
-        alist.sort()
-        for font_idx, font in alist:
-            result += font.get_biff_record().get()
-        return result
-
-    def _all_num_formats(self):
-        result = ''
-        alist = [
-            (v, k)
-            for k, v in self._num_formats.items()
-            if v >= FIRST_USER_DEFINED_NUM_FORMAT_IDX
-            ]
-        alist.sort()
-        for fmtidx, fmtstr in alist:
-            result += NumberFormatRecord(fmtidx, fmtstr).get()
-        return result
-
-    def _all_cell_styles(self):
-        result = ''
-        for i in range(0, 16):
-            result += XFRecord(self._default_xf, 'style').get()
-        if self.style_compression == 2:
-            alist = self._xf_x2id.items()
-        else:
-            alist = [(x, o) for o, x in self._xf_id2x.items()]
-        alist.sort()
-        for xf_idx, xf in alist:
-            result += XFRecord(xf).get()
-        return result
-
-    def _all_styles(self):
-        return StyleRecord().get()
-
-# easyxf and its supporting objects ###################################
-
-class EasyXFException(Exception):
-    pass
-
-class EasyXFCallerError(EasyXFException):
-    pass
-
-class EasyXFAuthorError(EasyXFException):
-    pass
-
-class IntULim(object):
-    # If astring represents a valid unsigned integer ('123', '0xabcd', etc)
-    # and it is <= limit, return the int value; otherwise return None.
-
-    def __init__(self, limit):
-        self.limit = limit
-
-    def __call__(self, astring):
-        try:
-            value = int(astring, 0)
-        except ValueError:
-            return None
-        if not 0 <= value <= self.limit:
-            return None
-        return value
-
-bool_map = {
-    # Text values for all Boolean attributes
-    '1': 1, 'yes': 1, 'true':  1, 'on':  1,
-    '0': 0, 'no':  0, 'false': 0, 'off': 0,
-    }
-
-border_line_map = {
-    # Text values for these borders attributes:
-    # left, right, top, bottom and diag
-    'no_line':  0x00,
-    'thin':     0x01,
-    'medium':   0x02,
-    'dashed':   0x03,
-    'dotted':   0x04,
-    'thick':    0x05,
-    'double':   0x06,
-    'hair':     0x07,
-    'medium_dashed':                0x08,
-    'thin_dash_dotted':             0x09,
-    'medium_dash_dotted':           0x0a,
-    'thin_dash_dot_dotted':         0x0b,
-    'medium_dash_dot_dotted':       0x0c,
-    'slanted_medium_dash_dotted':   0x0d,
-    }
-
-charset_map = {
-    # Text values for font.charset
-    'ansi_latin':           0x00,
-    'sys_default':          0x01,
-    'symbol':               0x02,
-    'apple_roman':          0x4d,
-    'ansi_jap_shift_jis':   0x80,
-    'ansi_kor_hangul':      0x81,
-    'ansi_kor_johab':       0x82,
-    'ansi_chinese_gbk':     0x86,
-    'ansi_chinese_big5':    0x88,
-    'ansi_greek':           0xa1,
-    'ansi_turkish':         0xa2,
-    'ansi_vietnamese':      0xa3,
-    'ansi_hebrew':          0xb1,
-    'ansi_arabic':          0xb2,
-    'ansi_baltic':          0xba,
-    'ansi_cyrillic':        0xcc,
-    'ansi_thai':            0xde,
-    'ansi_latin_ii':        0xee,
-    'oem_latin_i':          0xff,
-    }
-
-
-# Text values for colour indices. "grey" is a synonym of "gray".
-# The names are those given by Microsoft Excel 2003 to the colours
-# in the default palette. There is no great correspondence with
-# any W3C name-to-RGB mapping.
-_colour_map_text = """\
-aqua 0x31
-black 0x08
-blue 0x0C
-blue_gray 0x36
-bright_green 0x0B
-brown 0x3C
-coral 0x1D
-cyan_ega 0x0F
-dark_blue 0x12
-dark_blue_ega 0x12
-dark_green 0x3A
-dark_green_ega 0x11
-dark_purple 0x1C
-dark_red 0x10
-dark_red_ega 0x10
-dark_teal 0x38
-dark_yellow 0x13
-gold 0x33
-gray_ega 0x17
-gray25 0x16
-gray40 0x37
-gray50 0x17
-gray80 0x3F
-green 0x11
-ice_blue 0x1F
-indigo 0x3E
-ivory 0x1A
-lavender 0x2E
-light_blue 0x30
-light_green 0x2A
-light_orange 0x34
-light_turquoise 0x29
-light_yellow 0x2B
-lime 0x32
-magenta_ega 0x0E
-ocean_blue 0x1E
-olive_ega 0x13
-olive_green 0x3B
-orange 0x35
-pale_blue 0x2C
-periwinkle 0x18
-pink 0x0E
-plum 0x3D
-purple_ega 0x14
-red 0x0A
-rose 0x2D
-sea_green 0x39
-silver_ega 0x16
-sky_blue 0x28
-tan 0x2F
-teal 0x15
-teal_ega 0x15
-turquoise 0x0F
-violet 0x14
-white 0x09
-yellow 0x0D"""
-
-colour_map = {}
-for _line in _colour_map_text.splitlines():
-    _name, _num = _line.split()
-    _num = int(_num, 0)
-    colour_map[_name] = _num
-    if 'gray' in _name:
-        colour_map[_name.replace('gray', 'grey')] = _num
-del _colour_map_text, _line, _name, _num
-
-
-pattern_map = {
-    # Text values for pattern.pattern
-    # xlwt/doc/pattern_examples.xls showcases all of these patterns.
-    'no_fill':              0,
-    'none':                 0,
-    'solid':                1,
-    'solid_fill':           1,
-    'solid_pattern':        1,
-    'fine_dots':            2,
-    'alt_bars':             3,
-    'sparse_dots':          4,
-    'thick_horz_bands':     5,
-    'thick_vert_bands':     6,
-    'thick_backward_diag':  7,
-    'thick_forward_diag':   8,
-    'big_spots':            9,
-    'bricks':               10,
-    'thin_horz_bands':      11,
-    'thin_vert_bands':      12,
-    'thin_backward_diag':   13,
-    'thin_forward_diag':    14,
-    'squares':              15,
-    'diamonds':             16,
-    }
-
-def any_str_func(s):
-    return s.strip()
-
-def colour_index_func(s, maxval=0x7F):
-    try:
-        value = int(s, 0)
-    except ValueError:
-        return None
-    if not (0 <= value <= maxval):
-        return None
-    return value
-
-colour_index_func_7 = colour_index_func
-
-def colour_index_func_15(s):
-    return colour_index_func(s, maxval=0x7FFF)
-
-def rotation_func(s):
-    try:
-        value = int(s, 0)
-    except ValueError:
-        return None
-    if not (-90 <= value <= 90):
-        raise EasyXFCallerError("rotation %d: should be -90 to +90 degrees" % value)
-    if value < 0:
-        value = 90 - value # encode as 91 to 180 (clockwise)
-    return value
-
-xf_dict = {
-    'align': 'alignment', # synonym
-    'alignment': {
-        'dire': {
-            'general': 0,
-            'lr': 1,
-            'rl': 2,
-            },
-        'direction': 'dire',
-        'horiz': 'horz',
-        'horizontal': 'horz',
-        'horz': {
-            'general': 0,
-            'left': 1,
-            'center': 2,
-            'centre': 2, # "align: horiz centre" means xf.alignment.horz is set to 2
-            'right': 3,
-            'filled': 4,
-            'justified': 5,
-            'center_across_selection': 6,
-            'centre_across_selection': 6,
-            'distributed': 7,
-            },
-        'inde': IntULim(15), # restriction: 0 <= value <= 15
-        'indent': 'inde',
-        'rota': [{'stacked': 255, 'none': 0, }, rotation_func],
-        'rotation': 'rota',
-        'shri': bool_map,
-        'shrink': 'shri',
-        'shrink_to_fit': 'shri',
-        'vert': {
-            'top': 0,
-            'center': 1,
-            'centre': 1,
-            'bottom': 2,
-            'justified': 3,
-            'distributed': 4,
-            },
-         'vertical': 'vert',
-         'wrap': bool_map,
-         },
-    'border': 'borders',
-    'borders': {
-        'left':     [border_line_map, IntULim(0x0d)],
-        'right':    [border_line_map, IntULim(0x0d)],
-        'top':      [border_line_map, IntULim(0x0d)],
-        'bottom':   [border_line_map, IntULim(0x0d)],
-        'diag':     [border_line_map, IntULim(0x0d)],
-        'top_colour':       [colour_map, colour_index_func_7],
-        'bottom_colour':    [colour_map, colour_index_func_7],
-        'left_colour':      [colour_map, colour_index_func_7],
-        'right_colour':     [colour_map, colour_index_func_7],
-        'diag_colour':      [colour_map, colour_index_func_7],
-        'top_color':        'top_colour',
-        'bottom_color':     'bottom_colour',
-        'left_color':       'left_colour',
-        'right_color':      'right_colour',
-        'diag_color':       'diag-colour',
-        'need_diag_1':  bool_map,
-        'need_diag_2':  bool_map,
-        },
-    'font': {
-        'bold': bool_map,
-        'charset': charset_map,
-        'color':  'colour_index',
-        'color_index':  'colour_index',
-        'colour':  'colour_index',
-        'colour_index': [colour_map, colour_index_func_15],
-        'escapement': {'none': 0, 'superscript': 1, 'subscript': 2},
-        'family': {'none': 0, 'roman': 1, 'swiss': 2, 'modern': 3, 'script': 4, 'decorative': 5, },
-        'height': IntULim(0xFFFF), # practical limits are much narrower e.g. 160 to 1440 (8pt to 72pt)
-        'italic': bool_map,
-        'name': any_str_func,
-        'outline': bool_map,
-        'shadow': bool_map,
-        'struck_out': bool_map,
-        'underline': [bool_map, {'none': 0, 'single': 1, 'single_acc': 0x21, 'double': 2, 'double_acc': 0x22, }],
-        },
-    'pattern': {
-        'back_color':   'pattern_back_colour',
-        'back_colour':  'pattern_back_colour',
-        'fore_color':   'pattern_fore_colour',
-        'fore_colour':  'pattern_fore_colour',
-        'pattern': [pattern_map, IntULim(16)],
-        'pattern_back_color':   'pattern_back_colour',
-        'pattern_back_colour':  [colour_map, colour_index_func_7],
-        'pattern_fore_color':   'pattern_fore_colour',
-        'pattern_fore_colour':  [colour_map, colour_index_func_7],
-        },
-    'protection': {
-        'cell_locked' :   bool_map,
-        'formula_hidden': bool_map,
-        },
-    }
-
-def _esplit(s, split_char, esc_char="\\"):
-    escaped = False
-    olist = ['']
-    for c in s:
-        if escaped:
-            olist[-1] += c
-            escaped = False
-        elif c == esc_char:
-            escaped = True
-        elif c == split_char:
-            olist.append('')
-        else:
-            olist[-1] += c
-    return olist
-
-def _parse_strg_to_obj(strg, obj, parse_dict,
-    field_sep=",", line_sep=";", intro_sep=":", esc_char="\\", debug=False):
-    for line in _esplit(strg, line_sep, esc_char):
-        line = line.strip()
-        if not line:
-            break
-        split_line = _esplit(line, intro_sep, esc_char)
-        if len(split_line) != 2:
-            raise EasyXFCallerError('line %r should have exactly 1 "%c"' % (line, intro_sep))
-        section, item_str = split_line
-        section = section.strip().lower()
-        for counter in range(2):
-            result = parse_dict.get(section)
-            if result is None:
-                raise EasyXFCallerError('section %r is unknown' % section)
-            if isinstance(result, dict):
-                break
-            if not isinstance(result, str):
-                raise EasyXFAuthorError(
-                    'section %r should map to dict or str object; found %r' % (section, type(result)))
-            # synonym
-            old_section = section
-            section = result
-        else:
-            raise EasyXFAuthorError('Attempt to define synonym of synonym (%r: %r)' % (old_section, result))
-        section_dict = result
-        section_obj = getattr(obj, section, None)
-        if section_obj is None:
-            raise EasyXFAuthorError('instance of %s class has no attribute named %s' % (obj.__class__.__name__, section))
-        for kv_str in _esplit(item_str, field_sep, esc_char):
-            guff = kv_str.split()
-            if not guff:
-                continue
-            k = guff[0].lower().replace('-', '_')
-            v = ' '.join(guff[1:])
-            if not v:
-                raise EasyXFCallerError("no value supplied for %s.%s" % (section, k))
-            for counter in xrange(2):
-                result = section_dict.get(k)
-                if result is None:
-                    raise EasyXFCallerError('%s.%s is not a known attribute' % (section, k))
-                if not isinstance(result, basestring):
-                    break
-                # synonym
-                old_k = k
-                k = result
-            else:
-                raise EasyXFAuthorError('Attempt to define synonym of synonym (%r: %r)' % (old_k, result))
-            value_info = result
-            if not isinstance(value_info, list):
-                value_info = [value_info]
-            for value_rule in value_info:
-                if isinstance(value_rule, dict):
-                    # dict maps strings to integer field values
-                    vl = v.lower().replace('-', '_')
-                    if vl in value_rule:
-                        value = value_rule[vl]
-                        break
-                elif callable(value_rule):
-                    value = value_rule(v)
-                    if value is not None:
-                        break
-                else:
-                    raise EasyXFAuthorError("unknown value rule for attribute %r: %r" % (k, value_rule))
-            else:
-                raise EasyXFCallerError("unexpected value %r for %s.%s" % (v, section, k))
-            try:
-                orig = getattr(section_obj, k)
-            except AttributeError:
-                raise EasyXFAuthorError('%s.%s in dictionary but not in supplied object' % (section, k))
-            if debug: print "+++ %s.%s = %r # %s; was %r" % (section, k, value, v, orig)
-            setattr(section_obj, k, value)
-
-def easyxf(strg_to_parse="", num_format_str=None,
-    field_sep=",", line_sep=";", intro_sep=":", esc_char="\\", debug=False):
-    xfobj = XFStyle()
-    if num_format_str is not None:
-        xfobj.num_format_str = num_format_str
-    if strg_to_parse:
-        _parse_strg_to_obj(strg_to_parse, xfobj, xf_dict,
-            field_sep=field_sep, line_sep=line_sep, intro_sep=intro_sep, esc_char=esc_char, debug=debug)
-    return xfobj

tablib/packages/xlwt/UnicodeUtils.py

@@ -1,81 +0,0 @@
-# -*- coding: windows-1252 -*-
-
-'''
-From BIFF8 on, strings are always stored using UTF-16LE  text encoding. The
-character  array  is  a  sequence  of  16-bit  values4.  Additionally it is
-possible  to  use  a  compressed  format, which omits the high bytes of all
-characters, if they are all zero.
-
-The following tables describe the standard format of the entire string, but
-in many records the strings differ from this format. This will be mentioned
-separately. It is possible (but not required) to store Rich-Text formatting
-information  and  Asian  phonetic information inside a Unicode string. This
-results  in  four  different  ways  to  store a string. The character array
-is not zero-terminated.
-
-The  string  consists  of  the  character count (as usual an 8-bit value or
-a  16-bit value), option flags, the character array and optional formatting
-information.  If the string is empty, sometimes the option flags field will
-not occur. This is mentioned at the respective place.
-
-Offset  Size    Contents
-0       1 or 2  Length of the string (character count, ln)
-1 or 2  1       Option flags:
-                  Bit   Mask Contents
-                  0     01H  Character compression (ccompr):
-                               0 = Compressed (8-bit characters)
-                               1 = Uncompressed (16-bit characters)
-                  2     04H  Asian phonetic settings (phonetic):
-                               0 = Does not contain Asian phonetic settings
-                               1 = Contains Asian phonetic settings
-                  3     08H  Rich-Text settings (richtext):
-                               0 = Does not contain Rich-Text settings
-                               1 = Contains Rich-Text settings
-[2 or 3] 2      (optional, only if richtext=1) Number of Rich-Text formatting runs (rt)
-[var.]   4      (optional, only if phonetic=1) Size of Asian phonetic settings block (in bytes, sz)
-var.     ln or 
-         2·ln   Character array (8-bit characters or 16-bit characters, dependent on ccompr)
-[var.]   4·rt   (optional, only if richtext=1) List of rt formatting runs 
-[var.]   sz     (optional, only if phonetic=1) Asian Phonetic Settings Block 
-'''
-
-
-from struct import pack
-
-def upack2(s, encoding='ascii'):
-    # If not unicode, make it so.
-    if isinstance(s, unicode):
-        us = s
-    else:
-        us = unicode(s, encoding)
-    # Limit is based on number of content characters
-    # (not on number of bytes in packed result)
-    len_us = len(us)
-    if len_us > 65535:
-        raise Exception('String longer than 65535 characters')
-    try:
-        encs = us.encode('latin1')
-        # Success here means all chars are in U+0000 to U+00FF
-        # inclusive, meaning that we can use "compressed format".
-        flag = 0
-    except UnicodeEncodeError:
-        encs = us.encode('utf_16_le')
-        flag = 1
-    return pack('<HB', len_us, flag) + encs
-
-def upack1(s, encoding='ascii'):
-    # Same as upack2(), but with a one-byte length field.
-    if isinstance(s, unicode):
-        us = s
-    else:
-        us = unicode(s, encoding)
-    len_us = len(us)
-    if len_us > 255:
-        raise Exception('String longer than 255 characters')
-    try:
-        encs = us.encode('latin1')
-        flag = 0
-    except UnicodeEncodeError:
-        encs = us.encode('utf_16_le')
-        flag = 1
-    return pack('<BB', len_us, flag) + encs

tablib/packages/xlwt/Utils.py

@@ -1,196 +0,0 @@
-# pyXLWriter: A library for generating Excel Spreadsheets
-# Copyright (c) 2004 Evgeny Filatov <fufff@users.sourceforge.net>
-# Copyright (c) 2002-2004 John McNamara (Perl Spreadsheet::WriteExcel)
-#
-# This library is free software; you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
-# General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this library; if not, write to the Free Software Foundation,
-# Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-#----------------------------------------------------------------------------
-# This module was written/ported from PERL Spreadsheet::WriteExcel module
-# The author of the PERL Spreadsheet::WriteExcel module is John McNamara
-# <jmcnamara@cpan.org>
-#----------------------------------------------------------------------------
-# See the README.txt distributed with pyXLWriter for more details.
-
-# Portions are (C) Roman V. Kiseliov, 2005
-
-
-# Utilities for work with reference to cells and with sheetnames
-
-
-__rev_id__ = """$Id: Utils.py 3844 2009-05-20 01:02:54Z sjmachin $"""
-
-import re
-from struct import pack
-from ExcelMagic import MAX_ROW, MAX_COL
-
-
-_re_cell_ex = re.compile(r"(\$?)([A-I]?[A-Z])(\$?)(\d+)", re.IGNORECASE)
-_re_row_range = re.compile(r"\$?(\d+):\$?(\d+)")
-_re_col_range = re.compile(r"\$?([A-I]?[A-Z]):\$?([A-I]?[A-Z])", re.IGNORECASE)
-_re_cell_range = re.compile(r"\$?([A-I]?[A-Z]\$?\d+):\$?([A-I]?[A-Z]\$?\d+)", re.IGNORECASE)
-_re_cell_ref = re.compile(r"\$?([A-I]?[A-Z]\$?\d+)", re.IGNORECASE)
-
-
-def col_by_name(colname):
-    """
-    """
-    col = 0
-    pow = 1
-    for i in xrange(len(colname)-1, -1, -1):
-        ch = colname[i]
-        col += (ord(ch) - ord('A') + 1) * pow
-        pow *= 26
-    return col - 1
-
-
-def cell_to_rowcol(cell):
-    """Convert an Excel cell reference string in A1 notation
-    to numeric row/col notation.
-
-    Returns: row, col, row_abs, col_abs
-
-    """
-    m = _re_cell_ex.match(cell)
-    if not m:
-        raise Exception("Ill-formed single_cell reference: %s" % cell)
-    col_abs, col, row_abs, row = m.groups()
-    row_abs = bool(row_abs)
-    col_abs = bool(col_abs)
-    row = int(row) - 1
-    col = col_by_name(col.upper())
-    return row, col, row_abs, col_abs
-
-
-def cell_to_rowcol2(cell):
-    """Convert an Excel cell reference string in A1 notation
-    to numeric row/col notation.
-
-    Returns: row, col
-
-    """
-    m = _re_cell_ex.match(cell)
-    if not m:
-        raise Exception("Error in cell format")
-    col_abs, col, row_abs, row = m.groups()
-    # Convert base26 column string to number
-    # All your Base are belong to us.
-    row = int(row) - 1
-    col = col_by_name(col.upper())
-    return row, col
-
-
-def rowcol_to_cell(row, col, row_abs=False, col_abs=False):
-    """Convert numeric row/col notation to an Excel cell reference string in
-    A1 notation.
-
-    """
-    assert 0 <= row < MAX_ROW # MAX_ROW counts from 1
-    assert 0 <= col < MAX_COL # MAX_COL counts from 1
-    d = col // 26
-    m = col % 26
-    chr1 = ""    # Most significant character in AA1
-    if row_abs:
-        row_abs = '$'
-    else:
-        row_abs = ''
-    if col_abs:
-        col_abs = '$'
-    else:
-        col_abs = ''
-    if d > 0:
-        chr1 = chr(ord('A') + d  - 1)
-    chr2 = chr(ord('A') + m)
-    # Zero index to 1-index
-    return col_abs + chr1 + chr2 + row_abs + str(row + 1)
-
-def rowcol_pair_to_cellrange(row1, col1, row2, col2,
-    row1_abs=False, col1_abs=False, row2_abs=False, col2_abs=False):
-    """Convert two (row,column) pairs
-    into a cell range string in A1:B2 notation.
-
-    Returns: cell range string
-    """
-    assert row1 <= row2
-    assert col1 <= col2
-    return (
-        rowcol_to_cell(row1, col1, row1_abs, col1_abs)
-        + ":"
-        + rowcol_to_cell(row2, col2, row2_abs, col2_abs)
-        )
-
-def cellrange_to_rowcol_pair(cellrange):
-    """Convert cell range string in A1 notation to numeric row/col
-    pair.
-
-    Returns: row1, col1, row2, col2
-
-    """
-    cellrange = cellrange.upper()
-    # Convert a row range: '1:3'
-    res = _re_row_range.match(cellrange)
-    if res:
-        row1 = int(res.group(1)) - 1
-        col1 = 0
-        row2 = int(res.group(2)) - 1
-        col2 = -1
-        return row1, col1, row2, col2
-    # Convert a column range: 'A:A' or 'B:G'.
-    # A range such as A:A is equivalent to A1:A16384, so add rows as required
-    res = _re_col_range.match(cellrange)
-    if res:
-        col1 = col_by_name(res.group(1).upper())
-        row1 = 0
-        col2 = col_by_name(res.group(2).upper())
-        row2 = -1
-        return row1, col1, row2, col2
-    # Convert a cell range: 'A1:B7'
-    res = _re_cell_range.match(cellrange)
-    if res:
-        row1, col1 = cell_to_rowcol2(res.group(1))
-        row2, col2 = cell_to_rowcol2(res.group(2))
-        return row1, col1, row2, col2
-    # Convert a cell reference: 'A1' or 'AD2000'
-    res = _re_cell_ref.match(cellrange)
-    if res:
-        row1, col1 = cell_to_rowcol2(res.group(1))
-        return row1, col1, row1, col1
-    raise Exception("Unknown cell reference %s" % (cell))
-
-
-def cell_to_packed_rowcol(cell):
-    """ pack row and column into the required 4 byte format """
-    row, col, row_abs, col_abs = cell_to_rowcol(cell)
-    if col >= MAX_COL:
-        raise Exception("Column %s greater than IV in formula" % cell)
-    if row >= MAX_ROW: # this for BIFF8. for BIFF7 available 2^14
-        raise Exception("Row %s greater than %d in formula" % (cell, MAX_ROW))
-    col |= int(not row_abs) << 15
-    col |= int(not col_abs) << 14
-    return row, col
-
-# === sheetname functions ===
-
-def valid_sheet_name(sheet_name):
-    if sheet_name == u"" or sheet_name[0] == u"'" or len(sheet_name) > 31:
-        return False
-    for c in sheet_name:
-        if c in u"[]:\\?/*\x00":
-            return False
-    return True
-
-def quote_sheet_name(unquoted_sheet_name):
-    if not valid_sheet_name(unquoted_sheet_name):
-        raise Exception(
-            'attempt to quote an invalid worksheet name %r' % unquoted_sheet_name)
-    return u"'" + unquoted_sheet_name.replace(u"'", u"''") + u"'"