Prechádzať zdrojové kódy

[core] Downgrade tablib from 0.14.0 to 0.12.1

Ying Chen 4 rokov pred
rodič
commit
cbd1b4fe30
75 zmenil súbory, kde vykonal 3014 pridanie a 3438 odobranie
  1. 36 0
      desktop/core/ext-py/tablib-0.12.1/AUTHORS
  2. 257 0
      desktop/core/ext-py/tablib-0.12.1/HISTORY.rst
  3. 1 2
      desktop/core/ext-py/tablib-0.12.1/LICENSE
  4. 1 0
      desktop/core/ext-py/tablib-0.12.1/MANIFEST.in
  5. 32 0
      desktop/core/ext-py/tablib-0.12.1/NOTICE
  6. 448 0
      desktop/core/ext-py/tablib-0.12.1/PKG-INFO
  7. 169 0
      desktop/core/ext-py/tablib-0.12.1/README.rst
  8. 0 0
      desktop/core/ext-py/tablib-0.12.1/setup.cfg
  9. 86 0
      desktop/core/ext-py/tablib-0.12.1/setup.py
  10. 8 0
      desktop/core/ext-py/tablib-0.12.1/tablib/__init__.py
  11. 48 0
      desktop/core/ext-py/tablib-0.12.1/tablib/compat.py
  12. 73 45
      desktop/core/ext-py/tablib-0.12.1/tablib/core.py
  13. 2 6
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/__init__.py
  14. 11 13
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_csv.py
  15. 8 1
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_dbf.py
  16. 7 1
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_df.py
  17. 10 5
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_html.py
  18. 10 7
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_json.py
  19. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_latex.py
  20. 2 13
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_ods.py
  21. 2 2
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_tsv.py
  22. 138 0
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_xls.py
  23. 26 21
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_xlsx.py
  24. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/formats/_yaml.py
  25. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/__init__.py
  26. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/__init__.py
  27. 4 4
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/dbf.py
  28. 6 6
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/dbfnew.py
  29. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/fields.py
  30. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/header.py
  31. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/record.py
  32. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/utils.py
  33. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/__init__.py
  34. 3 2
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/dbf.py
  35. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/dbfnew.py
  36. 1 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/fields.py
  37. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/header.py
  38. 1 1
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/record.py
  39. 0 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/utils.py
  40. 482 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/markup.py
  41. 484 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/markup3.py
  42. 127 0
      desktop/core/ext-py/tablib-0.12.1/tablib/packages/ordereddict.py
  43. 531 319
      desktop/core/ext-py/tablib-0.12.1/test_tablib.py
  44. 0 10
      desktop/core/ext-py/tablib-0.14.0/.coveragerc
  45. 0 10
      desktop/core/ext-py/tablib-0.14.0/.github/CONTRIBUTING.md
  46. 0 40
      desktop/core/ext-py/tablib-0.14.0/.gitignore
  47. 0 6
      desktop/core/ext-py/tablib-0.14.0/.isort.cfg
  48. 0 22
      desktop/core/ext-py/tablib-0.14.0/.travis.yml
  49. 0 30
      desktop/core/ext-py/tablib-0.14.0/AUTHORS
  50. 0 273
      desktop/core/ext-py/tablib-0.14.0/HISTORY.md
  51. 0 6
      desktop/core/ext-py/tablib-0.14.0/MANIFEST.in
  52. 0 479
      desktop/core/ext-py/tablib-0.14.0/PKG-INFO
  53. 0 177
      desktop/core/ext-py/tablib-0.14.0/README.md
  54. 0 130
      desktop/core/ext-py/tablib-0.14.0/docs/Makefile
  55. 0 18
      desktop/core/ext-py/tablib-0.14.0/docs/Pipfile
  56. 0 11
      desktop/core/ext-py/tablib-0.14.0/docs/_templates/sidebarintro.html
  57. 0 4
      desktop/core/ext-py/tablib-0.14.0/docs/_templates/sidebarlogo.html
  58. 0 64
      desktop/core/ext-py/tablib-0.14.0/docs/api.rst
  59. 0 227
      desktop/core/ext-py/tablib-0.14.0/docs/conf.py
  60. 0 207
      desktop/core/ext-py/tablib-0.14.0/docs/development.rst
  61. 0 116
      desktop/core/ext-py/tablib-0.14.0/docs/index.rst
  62. 0 67
      desktop/core/ext-py/tablib-0.14.0/docs/install.rst
  63. 0 84
      desktop/core/ext-py/tablib-0.14.0/docs/intro.rst
  64. 0 118
      desktop/core/ext-py/tablib-0.14.0/docs/krstyle.sty
  65. 0 395
      desktop/core/ext-py/tablib-0.14.0/docs/tutorial.rst
  66. 0 4
      desktop/core/ext-py/tablib-0.14.0/pytest.ini
  67. 0 57
      desktop/core/ext-py/tablib-0.14.0/setup.py
  68. 0 13
      desktop/core/ext-py/tablib-0.14.0/src/tablib/__init__.py
  69. 0 36
      desktop/core/ext-py/tablib-0.14.0/src/tablib/compat.py
  70. 0 39
      desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_jira.py
  71. 0 273
      desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_rst.py
  72. 0 0
      desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy3/__init__.py
  73. 0 24
      desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/statistics.py
  74. 0 10
      desktop/core/ext-py/tablib-0.14.0/tests/requirements.txt
  75. 0 40
      desktop/core/ext-py/tablib-0.14.0/tox.ini

+ 36 - 0
desktop/core/ext-py/tablib-0.12.1/AUTHORS

@@ -0,0 +1,36 @@
+Tablib is written and maintained by Kenneth Reitz and
+various contributors:
+
+Development Lead
+````````````````
+
+- Kenneth Reitz <me@kennethreitz.org>
+
+
+Core Contributors
+`````````````````
+
+- Iuri de Silvio <iurisilvio@gmail.com>
+
+Patches and Suggestions
+```````````````````````
+
+- Luke Lee
+- Josh Ourisman
+- Luca Beltrame
+- Benjamin Wohlwend
+- Erik Youngren
+- Mark Rogers
+- Mark Walling
+- Mike Waldner
+- Joel Friedly
+- Jakub Janoszek
+- Marc Abramowitz
+- Alex Gaynor
+- James Douglass
+- Tommy Anthony
+- Rabin Nankhwa
+- Marco Dallagiacoma
+- Mathias Loesch
+- Tushar Makkar
+- Andrii Soldatenko

+ 257 - 0
desktop/core/ext-py/tablib-0.12.1/HISTORY.rst

@@ -0,0 +1,257 @@
+History
+-------
+
+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.
+

+ 1 - 2
desktop/core/ext-py/tablib-0.14.0/LICENSE → desktop/core/ext-py/tablib-0.12.1/LICENSE

@@ -1,5 +1,4 @@
 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
@@ -17,4 +16,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.

+ 1 - 0
desktop/core/ext-py/tablib-0.12.1/MANIFEST.in

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

+ 32 - 0
desktop/core/ext-py/tablib-0.12.1/NOTICE

@@ -0,0 +1,32 @@
+Tablib includes some vendorized python libraries: ordereddict, markup.
+
+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.

+ 448 - 0
desktop/core/ext-py/tablib-0.12.1/PKG-INFO

@@ -0,0 +1,448 @@
+Metadata-Version: 1.1
+Name: tablib
+Version: 0.12.1
+Summary: Format agnostic tabular data library (XLS, JSON, YAML, CSV)
+Home-page: http://python-tablib.org
+Author: Kenneth Reitz
+Author-email: me@kennethreitz.org
+License: MIT
+Description: Tablib: format-agnostic tabular dataset library
+        ===============================================
+        
+        .. image:: https://travis-ci.org/kennethreitz/tablib.svg?branch=master
+            :target: https://travis-ci.org/kennethreitz/tablib
+        
+        ::
+        
+        	_____         ______  ___________ ______
+        	__  /_______ ____  /_ ___  /___(_)___  /_
+        	_  __/_  __ `/__  __ \__  / __  / __  __ \
+        	/ /_  / /_/ / _  /_/ /_  /  _  /  _  /_/ /
+        	\__/  \__,_/  /_.___/ /_/   /_/   /_.___/
+        
+        
+        
+        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)
+        - TSV (Sets)
+        - OSD (Sets)
+        - CSV (Sets)
+        - DBF (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, DBF, and CSV; they can be exported to XLSX, XLS, ODS, JSON, YAML, DBF, CSV, TSV, and HTML.
+        
+        `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 XLSX, XLS, ODS, 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.export('json'))
+        	[
+        	  {
+        	    "last_name": "Adams",
+        	    "age": 90,
+        	    "first_name": "John"
+        	  },
+        	  {
+        	    "last_name": "Ford",
+        	    "age": 83,
+        	    "first_name": "Henry"
+        	  }
+        	]
+        
+        
+        YAML!
+        +++++
+        ::
+        
+        	>>> print(data.export('yaml'))
+        	- {age: 90, first_name: John, last_name: Adams}
+        	- {age: 83, first_name: Henry, last_name: Ford}
+        
+        CSV...
+        ++++++
+        ::
+        
+        	>>> print(data.export('csv'))
+        	first_name,last_name,age
+        	John,Adams,90
+        	Henry,Ford,83
+        
+        EXCEL!
+        ++++++
+        ::
+        
+        	>>> with open('people.xls', 'wb') as f:
+        	...     f.write(data.export('xls'))
+        
+        DBF!
+        ++++
+        ::
+        
+            >>> with open('people.dbf', 'wb') as f:
+            ...     f.write(data.export('dbf'))
+            
+        Pandas DataFrame!
+        +++++++++++++++++
+        :: 
+        
+            >>> print(data.export('df')):
+                  first_name last_name  age
+            0       John     Adams   90
+            1      Henry      Ford   83
+        
+        It's that easy.
+        
+        
+        Installation
+        ------------
+        
+        To install tablib, simply: ::
+        
+        	$ pip install tablib
+        
+        Make sure to check out `Tablib on PyPi <https://pypi.python.org/pypi/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_.
+        
+        
+        
+        
+        .. _`the repository`: http://github.com/kennethreitz/tablib
+        .. _AUTHORS: http://github.com/kennethreitz/tablib/blob/master/AUTHORS
+        
+        
+        History
+        -------
+        
+        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.
+        
+        
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6

+ 169 - 0
desktop/core/ext-py/tablib-0.12.1/README.rst

@@ -0,0 +1,169 @@
+Tablib: format-agnostic tabular dataset library
+===============================================
+
+.. image:: https://travis-ci.org/kennethreitz/tablib.svg?branch=master
+    :target: https://travis-ci.org/kennethreitz/tablib
+
+::
+
+	_____         ______  ___________ ______
+	__  /_______ ____  /_ ___  /___(_)___  /_
+	_  __/_  __ `/__  __ \__  / __  / __  __ \
+	/ /_  / /_/ / _  /_/ /_  /  _  /  _  /_/ /
+	\__/  \__,_/  /_.___/ /_/   /_/   /_.___/
+
+
+
+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)
+- TSV (Sets)
+- OSD (Sets)
+- CSV (Sets)
+- DBF (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, DBF, and CSV; they can be exported to XLSX, XLS, ODS, JSON, YAML, DBF, CSV, TSV, and HTML.
+
+`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 XLSX, XLS, ODS, 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.export('json'))
+	[
+	  {
+	    "last_name": "Adams",
+	    "age": 90,
+	    "first_name": "John"
+	  },
+	  {
+	    "last_name": "Ford",
+	    "age": 83,
+	    "first_name": "Henry"
+	  }
+	]
+
+
+YAML!
++++++
+::
+
+	>>> print(data.export('yaml'))
+	- {age: 90, first_name: John, last_name: Adams}
+	- {age: 83, first_name: Henry, last_name: Ford}
+
+CSV...
+++++++
+::
+
+	>>> print(data.export('csv'))
+	first_name,last_name,age
+	John,Adams,90
+	Henry,Ford,83
+
+EXCEL!
+++++++
+::
+
+	>>> with open('people.xls', 'wb') as f:
+	...     f.write(data.export('xls'))
+
+DBF!
+++++
+::
+
+    >>> with open('people.dbf', 'wb') as f:
+    ...     f.write(data.export('dbf'))
+    
+Pandas DataFrame!
++++++++++++++++++
+:: 
+
+    >>> print(data.export('df')):
+          first_name last_name  age
+    0       John     Adams   90
+    1      Henry      Ford   83
+
+It's that easy.
+
+
+Installation
+------------
+
+To install tablib, simply: ::
+
+	$ pip install tablib
+
+Make sure to check out `Tablib on PyPi <https://pypi.python.org/pypi/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_.
+
+
+
+
+.. _`the repository`: http://github.com/kennethreitz/tablib
+.. _AUTHORS: http://github.com/kennethreitz/tablib/blob/master/AUTHORS

+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/setup.cfg → desktop/core/ext-py/tablib-0.12.1/setup.cfg


+ 86 - 0
desktop/core/ext-py/tablib-0.12.1/setup.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import re
+import sys
+
+try:
+    from setuptools import setup
+except ImportError:
+    from distutils.core import setup
+
+if sys.argv[-1] == 'publish':
+    os.system("python setup.py sdist upload")
+    sys.exit()
+
+if sys.argv[-1] == 'speedups':
+    try:
+        __import__('pip')
+    except ImportError:
+        print('Pip required.')
+        sys.exit(1)
+
+    os.system('pip install ujson')
+    sys.exit()
+
+if sys.argv[-1] == 'test':
+    try:
+        __import__('py')
+    except ImportError:
+        print('py.test required.')
+        sys.exit(1)
+
+    errors = os.system('py.test test_tablib.py')
+    sys.exit(bool(errors))
+
+packages = [
+    'tablib', 'tablib.formats',
+    'tablib.packages',
+    'tablib.packages.dbfpy',
+    'tablib.packages.dbfpy3'
+]
+
+install = [
+    'odfpy',
+    'openpyxl',
+    'unicodecsv',
+    'xlrd',
+    'xlwt',
+    'pyyaml',
+]
+
+
+with open('tablib/core.py', 'r') as fd:
+    version = re.search(r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]',
+                        fd.read(), re.MULTILINE).group(1)
+
+setup(
+    name='tablib',
+    version=version,
+    description='Format agnostic tabular data library (XLS, JSON, YAML, CSV)',
+    long_description=(open('README.rst').read() + '\n\n' +
+        open('HISTORY.rst').read()),
+    author='Kenneth Reitz',
+    author_email='me@kennethreitz.org',
+    url='http://python-tablib.org',
+    packages=packages,
+    license='MIT',
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'Natural Language :: English',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3.3',
+        'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
+    ],
+    tests_require=['pytest'],
+    install_requires=install,
+    extras_require={
+        'pandas': ['pandas'],
+    },
+)

+ 8 - 0
desktop/core/ext-py/tablib-0.12.1/tablib/__init__.py

@@ -0,0 +1,8 @@
+""" Tablib. """
+
+from tablib.core import (
+    Databook, Dataset, detect_format, import_set, import_book,
+    InvalidDatasetType, InvalidDimensions, UnsupportedFormat,
+    __version__
+)
+

+ 48 - 0
desktop/core/ext-py/tablib-0.12.1/tablib/compat.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+"""
+tablib.compat
+~~~~~~~~~~~~~
+
+Tablib compatiblity module.
+
+"""
+
+import sys
+
+is_py3 = (sys.version_info[0] > 2)
+
+
+
+try:
+    from collections import OrderedDict
+except ImportError:
+    from tablib.packages.ordereddict import OrderedDict
+
+
+if is_py3:
+    from io import BytesIO
+    from tablib.packages import markup3 as markup
+    import tablib.packages.dbfpy3 as dbfpy
+
+    import csv
+    from io import StringIO
+    # py3 mappings
+
+    ifilter = filter
+    unicode = str
+    bytes = bytes
+    basestring = str
+    xrange = range
+
+else:
+    from cStringIO import StringIO as BytesIO
+    from cStringIO import StringIO
+    from tablib.packages import markup
+    from itertools import ifilter
+
+    import unicodecsv as csv
+    import tablib.packages.dbfpy as dbfpy
+
+    unicode = unicode
+    xrange = xrange

+ 73 - 45
desktop/core/ext-py/tablib-0.14.0/src/tablib/core.py → desktop/core/ext-py/tablib-0.12.1/tablib/core.py

@@ -5,23 +5,24 @@
 
     This module implements the central Tablib objects.
 
-    :copyright: (c) 2016 by Kenneth Reitz. 2019 Jazzband.
+    :copyright: (c) 2016 by Kenneth Reitz.
     :license: MIT, see LICENSE for more details.
 """
 
-from collections import OrderedDict
 from copy import copy
 from operator import itemgetter
 
 from tablib import formats
 
-from tablib.compat import unicode
+from tablib.compat import OrderedDict, unicode
 
 
 __title__ = 'tablib'
+__version__ = '0.12.1'
+__build__ = 0x001201
 __author__ = 'Kenneth Reitz'
 __license__ = 'MIT'
-__copyright__ = 'Copyright 2017 Kenneth Reitz. 2019 Jazzband.'
+__copyright__ = 'Copyright 2017 Kenneth Reitz'
 __docformat__ = 'restructuredtext'
 
 
@@ -104,6 +105,8 @@ class Row(object):
             return bool(len(set(tag) & set(self.tags)))
 
 
+
+
 class Dataset(object):
     """The :class:`Dataset` object is the heart of Tablib. It provides all core
     functionality.
@@ -138,7 +141,7 @@ class Dataset(object):
 
         data = tablib.Dataset(*data, headers=headers)
 
-    :param \\*args: (optional) list of rows to populate Dataset
+    :param \*args: (optional) list of rows to populate Dataset
     :param headers: (optional) list strings for Dataset header row
     :param title: (optional) string to use as title of the Dataset
 
@@ -169,11 +172,13 @@ class Dataset(object):
 
         self._register_formats()
 
+
     def __len__(self):
         return self.height
 
+
     def __getitem__(self, key):
-        if isinstance(key, (str, unicode)):
+        if isinstance(key, str) or isinstance(key, unicode):
             if key in self.headers:
                 pos = self.headers.index(key) # get 'key' index from each data
                 return [row[pos] for row in self._data]
@@ -190,8 +195,9 @@ class Dataset(object):
         self._validate(value)
         self._data[key] = Row(value)
 
+
     def __delitem__(self, key):
-        if isinstance(key, (str, unicode)):
+        if isinstance(key, str) or isinstance(key, unicode):
 
             if key in self.headers:
 
@@ -207,6 +213,7 @@ class Dataset(object):
         else:
             del self._data[key]
 
+
     def __repr__(self):
         try:
             return '<%s dataset>' % (self.title.lower())
@@ -259,6 +266,7 @@ class Dataset(object):
             except AttributeError:
                 cls._formats[fmt.title] = (None, None)
 
+
     def _validate(self, row=None, col=None, safety=False):
         """Assures size of every row in dataset is of proper proportions."""
         if row:
@@ -278,6 +286,7 @@ class Dataset(object):
                 raise InvalidDimensions
             return False
 
+
     def _package(self, dicts=True, ordered=True):
         """Packages Dataset into lists of dictionaries for transmission."""
         # TODO: Dicts default to false?
@@ -302,6 +311,7 @@ class Dataset(object):
                     except IndexError:
                         raise InvalidDatasetIndex
 
+
         if self.headers:
             if dicts:
                 data = [dict_pack(list(zip(self.headers, data_row))) for data_row in _data]
@@ -312,6 +322,8 @@ class Dataset(object):
 
         return data
 
+
+
     def _get_headers(self):
         """An *optional* list of strings to be used for header rows and attribute names.
 
@@ -320,6 +332,7 @@ class Dataset(object):
         """
         return self.__headers
 
+
     def _set_headers(self, collection):
         """Validating headers setter."""
         self._validate(collection)
@@ -333,6 +346,7 @@ class Dataset(object):
 
     headers = property(_get_headers, _set_headers)
 
+
     def _get_dict(self):
         """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,
@@ -346,6 +360,7 @@ class Dataset(object):
         """
         return self._package()
 
+
     def _set_dict(self, pickle):
         """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
@@ -378,6 +393,7 @@ class Dataset(object):
 
     dict = property(_get_dict, _set_dict)
 
+
     def _clean_col(self, col):
         """Prepares the given column for insert/append."""
 
@@ -395,6 +411,7 @@ class Dataset(object):
 
         return col
 
+
     @property
     def height(self):
         """The number of rows currently in the :class:`Dataset`.
@@ -402,6 +419,7 @@ class Dataset(object):
         """
         return len(self._data)
 
+
     @property
     def width(self):
         """The number of columns currently in the :class:`Dataset`.
@@ -416,11 +434,12 @@ class Dataset(object):
             except TypeError:
                 return 0
 
+
     def load(self, in_stream, format=None, **kwargs):
         """
         Import `in_stream` to the :class:`Dataset` object using the `format`.
 
-        :param \\*\\*kwargs: (optional) custom configuration to the format `import_set`.
+        :param \*\*kwargs: (optional) custom configuration to the format `import_set`.
         """
 
         if not format:
@@ -433,11 +452,13 @@ class Dataset(object):
         import_set(self, in_stream, **kwargs)
         return self
 
+
+
     def export(self, format, **kwargs):
         """
         Export :class:`Dataset` object to `format`.
 
-        :param \\*\\*kwargs: (optional) custom configuration to the format `export_set`.
+        :param \*\*kwargs: (optional) custom configuration to the format `export_set`.
         """
         export_set, import_set = self._formats.get(format, (None, None))
         if not export_set:
@@ -505,9 +526,9 @@ class Dataset(object):
 
         Import assumes (for now) that headers exist.
 
-        .. admonition:: Binary Warning for Python 2
+        .. admonition:: Binary Warning
 
-             :class:`Dataset.csv` uses \\r\\n line endings by default so, in Python 2, make
+             :class:`Dataset.csv` uses \\r\\n line endings by default, so make
              sure to write in binary mode::
 
                  with open('output.csv', 'wb') as f:
@@ -515,21 +536,10 @@ class Dataset(object):
 
              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.
-
-        .. admonition:: Line endings for Python 3
-
-             :class:`Dataset.csv` uses \\r\\n line endings by default so, in Python 3, 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(data.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.
         """
         pass
 
+
     @property
     def tsv():
         """A TSV representation of the :class:`Dataset` object. The top row will contain
@@ -606,7 +616,7 @@ class Dataset(object):
 
             # To import data from an existing DBF file:
             data = tablib.Dataset()
-            data.dbf = open('existing_table.dbf', mode='rb').read()
+            data.dbf = open('existing_table.dbf').read()
 
             # to import data from an ASCII-encoded bytestring:
             data = tablib.Dataset()
@@ -621,6 +631,7 @@ class Dataset(object):
         """
         pass
 
+
     @property
     def latex():
         """A LaTeX booktabs representation of the :class:`Dataset` object. If a
@@ -630,13 +641,6 @@ class Dataset(object):
         """
         pass
 
-    @property
-    def jira():
-        """A Jira table representation of the :class:`Dataset` object.
-
-        .. note:: This method can be used for export only.
-        """
-        pass
 
     # ----
     # Rows
@@ -654,6 +658,7 @@ class Dataset(object):
         self._validate(row)
         self._data.insert(index, Row(row, tags=tags))
 
+
     def rpush(self, row, tags=list()):
         """Adds a row to the end of the :class:`Dataset`.
         See :class:`Dataset.insert` for additional documentation.
@@ -661,6 +666,7 @@ class Dataset(object):
 
         self.insert(self.height, row=row, tags=tags)
 
+
     def lpush(self, row, tags=list()):
         """Adds a row to the top of the :class:`Dataset`.
         See :class:`Dataset.insert` for additional documentation.
@@ -668,6 +674,7 @@ class Dataset(object):
 
         self.insert(0, row=row, tags=tags)
 
+
     def append(self, row, tags=list()):
         """Adds a row to the :class:`Dataset`.
         See :class:`Dataset.insert` for additional documentation.
@@ -683,6 +690,7 @@ class Dataset(object):
         for row in rows:
             self.append(row, tags)
 
+
     def lpop(self):
         """Removes and returns the first row of the :class:`Dataset`."""
 
@@ -691,6 +699,7 @@ class Dataset(object):
 
         return cache
 
+
     def rpop(self):
         """Removes and returns the last row of the :class:`Dataset`."""
 
@@ -699,11 +708,13 @@ class Dataset(object):
 
         return cache
 
+
     def pop(self):
         """Removes and returns the last row of the :class:`Dataset`."""
 
         return self.rpop()
 
+
     # -------
     # Columns
     # -------
@@ -758,6 +769,7 @@ class Dataset(object):
 
             self.headers.insert(index, header)
 
+
         if self.height and self.width:
 
             for i, row in enumerate(self._data):
@@ -767,6 +779,8 @@ class Dataset(object):
         else:
             self._data = [Row([row]) for row in col]
 
+
+
     def rpush_col(self, col, header=None):
         """Adds a column to the end of the :class:`Dataset`.
         See :class:`Dataset.insert` for additional documentation.
@@ -774,6 +788,7 @@ class Dataset(object):
 
         self.insert_col(self.width, col, header=header)
 
+
     def lpush_col(self, col, header=None):
         """Adds a column to the top of the :class:`Dataset`.
         See :class:`Dataset.insert` for additional documentation.
@@ -781,12 +796,14 @@ class Dataset(object):
 
         self.insert_col(0, col, header=header)
 
+
     def insert_separator(self, index, text='-'):
         """Adds a separator to :class:`Dataset` at given index."""
 
         sep = (index, text)
         self._separators.append(sep)
 
+
     def append_separator(self, text='-'):
         """Adds a :ref:`separator <separators>` to the :class:`Dataset`."""
 
@@ -798,6 +815,7 @@ class Dataset(object):
 
         self.insert_separator(index, text)
 
+
     def append_col(self, col, header=None):
         """Adds a column to the :class:`Dataset`.
         See :class:`Dataset.insert_col` for additional documentation.
@@ -805,26 +823,27 @@ class Dataset(object):
 
         self.rpush_col(col, header)
 
+
     def get_col(self, index):
         """Returns the column from the :class:`Dataset` at the given index."""
 
         return [row[index] for row in self._data]
 
+
     # ----
     # Misc
     # ----
 
     def add_formatter(self, col, handler):
-        """Adds a formatter to the :class:`Dataset`.
+        """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.
+           :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, unicode):
+        if isinstance(col, str):
             if col in self.headers:
                 col = self.headers.index(col) # get 'key' index from each data
             else:
@@ -837,6 +856,7 @@ class Dataset(object):
 
         return True
 
+
     def filter(self, tag):
         """Returns a new instance of the :class:`Dataset`, excluding any rows
         that do not contain the given :ref:`tags <tags>`.
@@ -846,6 +866,7 @@ class Dataset(object):
 
         return _dset
 
+
     def sort(self, col, reverse=False):
         """Sort a :class:`Dataset` by a specific column, given string (for
         header) or integer (for column index). The order can be reversed by
@@ -855,7 +876,7 @@ class Dataset(object):
         sorted.
         """
 
-        if isinstance(col, (str, unicode)):
+        if isinstance(col, str) or isinstance(col, unicode):
 
             if not self.headers:
                 raise HeadersNeeded
@@ -881,8 +902,10 @@ class Dataset(object):
                     row = item
                 _dset.append(row=row)
 
+
         return _dset
 
+
     def transpose(self):
         """Transpose a :class:`Dataset`, turning rows into columns and vice
         versa, returning a new ``Dataset`` instance. The first row of the
@@ -911,6 +934,7 @@ class Dataset(object):
             _dset.append(row=row_data)
         return _dset
 
+
     def stack(self, other):
         """Stack two :class:`Dataset` instances together by
         joining at the row level, and return new combined
@@ -933,6 +957,7 @@ class Dataset(object):
 
         return _dset
 
+
     def stack_cols(self, other):
         """Stack two :class:`Dataset` instances together by
         joining at the column level, and return a new
@@ -966,17 +991,20 @@ class Dataset(object):
 
         return _dset
 
+
     def remove_duplicates(self):
         """Removes all duplicate rows from the :class:`Dataset` object
         while maintaining the original order."""
         seen = set()
         self._data[:] = [row for row in self._data if not (tuple(row) in seen or seen.add(tuple(row)))]
 
+
     def wipe(self):
         """Removes all content and headers from the :class:`Dataset` object."""
         self._data = list()
         self.__headers = None
 
+
     def subset(self, rows=None, cols=None):
         """Returns a new instance of the :class:`Dataset`,
         including only specified rows and columns.
@@ -1017,6 +1045,7 @@ class Dataset(object):
         return _dset
 
 
+
 class Databook(object):
     """A book of :class:`Dataset` objects.
     """
@@ -1042,6 +1071,7 @@ class Databook(object):
         """Removes all :class:`Dataset` objects from the :class:`Databook`."""
         self._datasets = []
 
+
     @classmethod
     def _register_formats(cls):
         """Adds format properties."""
@@ -1067,6 +1097,7 @@ class Databook(object):
         else:
             raise InvalidDatasetType
 
+
     def _package(self, ordered=True):
         """Packages :class:`Databook` for delivery."""
         collector = []
@@ -1083,16 +1114,17 @@ class Databook(object):
             ))
         return collector
 
+
     @property
     def size(self):
         """The number of the :class:`Dataset` objects within :class:`Databook`."""
         return len(self._datasets)
 
-    def load(self, in_stream, format, **kwargs):
+    def load(self, format, in_stream, **kwargs):
         """
         Import `in_stream` to the :class:`Databook` object using the `format`.
 
-        :param \\*\\*kwargs: (optional) custom configuration to the format `import_book`.
+        :param \*\*kwargs: (optional) custom configuration to the format `import_book`.
         """
 
         if not format:
@@ -1109,7 +1141,7 @@ class Databook(object):
         """
         Export :class:`Databook` object to `format`.
 
-        :param \\*\\*kwargs: (optional) custom configuration to the format `export_book`.
+        :param \*\*kwargs: (optional) custom configuration to the format `export_book`.
         """
         export_book, import_book = self._formats.get(format, (None, None))
         if not export_book:
@@ -1127,7 +1159,6 @@ def detect_format(stream):
         except AttributeError:
             pass
 
-
 def import_set(stream, format=None, **kwargs):
     """Return dataset of given stream."""
 
@@ -1147,14 +1178,11 @@ class InvalidDatasetType(Exception):
 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"

+ 2 - 6
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/__init__.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/__init__.py

@@ -5,7 +5,7 @@
 
 from . import _csv as csv
 from . import _json as json
-#from . import _xls as xls
+from . import _xls as xls
 from . import _yaml as yaml
 from . import _tsv as tsv
 from . import _html as html
@@ -14,9 +14,5 @@ from . import _ods as ods
 from . import _dbf as dbf
 from . import _latex as latex
 from . import _df as df
-from . import _rst as rst
-from . import _jira as jira
 
-# xlsx before as xls (xlrd) can also read xlsx
-#available = (json, xlsx, xls, yaml, csv, dbf, tsv, html, jira, latex, ods, df, rst)
-available = (json, xlsx, yaml, csv, dbf, tsv, html, jira, latex, ods, df, rst)
+available = (json, xls, yaml, csv, dbf, tsv, html, latex, xlsx, ods, df)

+ 11 - 13
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_csv.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/_csv.py

@@ -3,34 +3,30 @@
 """ Tablib - *SV Support.
 """
 
-from tablib.compat import csv, StringIO, unicode
+from tablib.compat import is_py3, csv, StringIO
 
 
 title = 'csv'
 extensions = ('csv',)
 
 
-DEFAULT_DELIMITER = unicode(',')
+DEFAULT_ENCODING = 'utf-8'
+DEFAULT_DELIMITER = ','
 
 
-def export_stream_set(dataset, **kwargs):
-    """Returns CSV representation of Dataset as file-like."""
+def export_set(dataset, **kwargs):
+    """Returns CSV representation of Dataset."""
     stream = StringIO()
 
     kwargs.setdefault('delimiter', DEFAULT_DELIMITER)
+    if not is_py3:
+        kwargs.setdefault('encoding', DEFAULT_ENCODING)
 
     _csv = csv.writer(stream, **kwargs)
 
     for row in dataset._package(dicts=False):
         _csv.writerow(row)
 
-    stream.seek(0)
-    return stream
-
-
-def export_set(dataset, **kwargs):
-    """Returns CSV representation of Dataset."""
-    stream = export_stream_set(dataset, **kwargs)
     return stream.getvalue()
 
 
@@ -40,13 +36,15 @@ def import_set(dset, in_stream, headers=True, **kwargs):
     dset.wipe()
 
     kwargs.setdefault('delimiter', DEFAULT_DELIMITER)
+    if not is_py3:
+        kwargs.setdefault('encoding', DEFAULT_ENCODING)
 
     rows = csv.reader(StringIO(in_stream), **kwargs)
     for i, row in enumerate(rows):
 
         if (i == 0) and (headers):
             dset.headers = row
-        elif row:
+        else:
             dset.append(row)
 
 
@@ -55,5 +53,5 @@ def detect(stream, delimiter=DEFAULT_DELIMITER):
     try:
         csv.Sniffer().sniff(stream, delimiters=delimiter)
         return True
-    except Exception:
+    except (csv.Error, TypeError):
         return False

+ 8 - 1
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_dbf.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/_dbf.py

@@ -83,5 +83,12 @@ def detect(stream):
         else:
             _dbf = dbf.Dbf(StringIO(stream), readOnly=True)
         return True
-    except Exception:
+    except (ValueError, struct.error):
+        # When we try to open up a file that's not a DBF, dbfpy raises a
+        # ValueError.
+        # When unpacking a string argument with less than 8 chars, struct.error is
+        # raised.
         return False
+
+
+

+ 7 - 1
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_df.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/_df.py

@@ -1,8 +1,14 @@
 """ Tablib - DataFrame Support.
 """
 
+
 import sys
-from io import BytesIO
+
+
+if sys.version_info[0] > 2:
+    from io import BytesIO
+else:
+    from cStringIO import StringIO as BytesIO
 
 try:
     from pandas import DataFrame

+ 10 - 5
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_html.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/_html.py

@@ -3,13 +3,18 @@
 """ Tablib - HTML export support.
 """
 
-import codecs
 import sys
-from io import BytesIO
 
-from MarkupPy import markup
+if sys.version_info[0] > 2:
+    from io import BytesIO as StringIO
+    from tablib.packages import markup3 as markup
+else:
+    from cStringIO import StringIO
+    from tablib.packages import markup
+
 import tablib
 from tablib.compat import unicode
+import codecs
 
 BOOK_ENDINGS = 'h3'
 
@@ -20,7 +25,7 @@ extensions = ('html', )
 def export_set(dataset):
     """HTML representation of a Dataset."""
 
-    stream = BytesIO()
+    stream = StringIO()
 
     page = markup.page()
     page.table.open()
@@ -51,7 +56,7 @@ def export_set(dataset):
 def export_book(databook):
     """HTML representation of a Databook."""
 
-    stream = BytesIO()
+    stream = StringIO()
 
     # Allow unicode characters in output
     wrapper = codecs.getwriter("utf8")(stream)

+ 10 - 7
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_json.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/_json.py

@@ -3,33 +3,36 @@
 """ Tablib - JSON Support
 """
 import decimal
-import json
-from uuid import UUID
 
 import tablib
 
+try:
+    import ujson as json
+except ImportError:
+    import json
 
 title = 'json'
 extensions = ('json', 'jsn')
 
 
-def serialize_objects_handler(obj):
-    if isinstance(obj, (decimal.Decimal, UUID)):
+def date_handler(obj):
+    if isinstance(obj, decimal.Decimal):
         return str(obj)
     elif hasattr(obj, 'isoformat'):
         return obj.isoformat()
     else:
         return obj
+    # return obj.isoformat() if hasattr(obj, 'isoformat') else obj
 
 
 def export_set(dataset):
     """Returns JSON representation of Dataset."""
-    return json.dumps(dataset.dict, default=serialize_objects_handler)
+    return json.dumps(dataset.dict, default=date_handler)
 
 
 def export_book(databook):
     """Returns JSON representation of Databook."""
-    return json.dumps(databook._package(), default=serialize_objects_handler)
+    return json.dumps(databook._package(), default=date_handler)
 
 
 def import_set(dset, in_stream):
@@ -55,5 +58,5 @@ def detect(stream):
     try:
         json.loads(stream)
         return True
-    except (TypeError, ValueError):
+    except ValueError:
         return False

+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_latex.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/_latex.py


+ 2 - 13
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_ods.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/_ods.py

@@ -3,9 +3,8 @@
 """ Tablib - ODF Support.
 """
 
-from io import BytesIO
 from odf import opendocument, style, table, text
-from tablib.compat import unicode
+from tablib.compat import BytesIO, unicode
 
 title = 'ods'
 extensions = ('ods',)
@@ -39,6 +38,7 @@ def export_book(databook):
         wb.spreadsheet.addElement(ws)
         dset_sheet(dset, ws)
 
+
     stream = BytesIO()
     wb.save(stream)
     return stream.getvalue()
@@ -91,14 +91,3 @@ def dset_sheet(dataset, ws):
                     cell = table.TableCell()
                     cell.addElement(text.P(text=col))
                     odf_row.addElement(cell)
-
-
-def detect(stream):
-    if isinstance(stream, bytes):
-        # load expects a file-like object.
-        stream = BytesIO(stream)
-    try:
-        opendocument.load(stream)
-        return True
-    except Exception:
-        return False

+ 2 - 2
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_tsv.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/_tsv.py

@@ -3,7 +3,6 @@
 """ Tablib - TSV (Tab Separated Values) Support.
 """
 
-from tablib.compat import unicode
 from tablib.formats._csv import (
     export_set as export_set_wrapper,
     import_set as import_set_wrapper,
@@ -13,7 +12,8 @@ from tablib.formats._csv import (
 title = 'tsv'
 extensions = ('tsv',)
 
-DELIMITER = unicode('\t')
+DEFAULT_ENCODING = 'utf-8'
+DELIMITER = '\t'
 
 def export_set(dataset):
     """Returns TSV representation of Dataset."""

+ 138 - 0
desktop/core/ext-py/tablib-0.12.1/tablib/formats/_xls.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+
+""" Tablib - XLS Support.
+"""
+
+import sys
+
+from tablib.compat import BytesIO, xrange
+import tablib
+import xlrd
+import xlwt
+from xlrd.biffh import XLRDError
+
+title = 'xls'
+extensions = ('xls',)
+
+# special styles
+wrap = xlwt.easyxf("alignment: wrap on")
+bold = xlwt.easyxf("font: bold on")
+
+
+def detect(stream):
+    """Returns True if given stream is a readable excel file."""
+    try:
+        xlrd.open_workbook(file_contents=stream)
+        return True
+    except (TypeError, XLRDError):
+        pass 
+    try:
+        xlrd.open_workbook(file_contents=stream.read())
+        return True
+    except (AttributeError, XLRDError):
+        pass
+    try:
+        xlrd.open_workbook(filename=stream)
+        return True
+    except:
+        return False
+
+
+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 import_set(dset, in_stream, headers=True):
+    """Returns databook from XLS stream."""
+
+    dset.wipe()
+
+    xls_book = xlrd.open_workbook(file_contents=in_stream)
+    sheet = xls_book.sheet_by_index(0)
+
+    dset.title = sheet.name
+
+    for i in xrange(sheet.nrows):
+        if (i == 0) and (headers):
+            dset.headers = sheet.row_values(0)
+        else:
+            dset.append(sheet.row_values(i))
+
+def import_book(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 xrange(sheet.nrows):
+            if (i == 0) and (headers):
+                data.headers = sheet.row_values(0)
+            else:
+                data.append(sheet.row_values(i))
+
+        dbook.add_sheet(data)
+
+
+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)

+ 26 - 21
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_xlsx.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/_xlsx.py

@@ -4,7 +4,12 @@
 """
 
 import sys
-from io import BytesIO
+
+
+if sys.version_info[0] > 2:
+    from io import BytesIO
+else:
+    from cStringIO import StringIO as BytesIO
 
 import openpyxl
 import tablib
@@ -22,14 +27,11 @@ extensions = ('xlsx',)
 
 def detect(stream):
     """Returns True if given stream is a readable excel file."""
-    if isinstance(stream, bytes):
-        # load_workbook expects a file-like object.
-        stream = BytesIO(stream)
     try:
-        openpyxl.reader.excel.load_workbook(stream, read_only=True)
+        openpyxl.reader.excel.load_workbook(stream)
         return True
-    except Exception:
-        return False
+    except openpyxl.shared.exc.InvalidFileException:
+        pass
 
 def export_set(dataset, freeze_panes=True):
     """Returns XLSX representation of Dataset."""
@@ -50,13 +52,14 @@ def export_book(databook, freeze_panes=True):
 
     wb = Workbook()
     for sheet in wb.worksheets:
-        wb.remove(sheet)
+        wb.remove_sheet(sheet)
     for i, dset in enumerate(databook._datasets):
         ws = wb.create_sheet()
         ws.title = dset.title if dset.title else 'Sheet%s' % (i)
 
         dset_sheet(dset, ws, freeze_panes=freeze_panes)
 
+
     stream = BytesIO()
     wb.save(stream)
     return stream.getvalue()
@@ -67,8 +70,8 @@ def import_set(dset, in_stream, headers=True):
 
     dset.wipe()
 
-    xls_book = openpyxl.reader.excel.load_workbook(BytesIO(in_stream), read_only=True)
-    sheet = xls_book.active
+    xls_book = openpyxl.reader.excel.load_workbook(BytesIO(in_stream))
+    sheet = xls_book.get_active_sheet()
 
     dset.title = sheet.title
 
@@ -85,7 +88,7 @@ def import_book(dbook, in_stream, headers=True):
 
     dbook.wipe()
 
-    xls_book = openpyxl.reader.excel.load_workbook(BytesIO(in_stream), read_only=True)
+    xls_book = openpyxl.reader.excel.load_workbook(BytesIO(in_stream))
 
     for sheet in xls_book.worksheets:
         data = tablib.Dataset()
@@ -116,29 +119,31 @@ def dset_sheet(dataset, ws, freeze_panes=True):
         row_number = i + 1
         for j, col in enumerate(row):
             col_idx = get_column_letter(j + 1)
-            cell = ws['%s%s' % (col_idx, row_number)]
+            cell = ws.cell('%s%s' % (col_idx, row_number))
 
             # bold headers
             if (row_number == 1) and dataset.headers:
+                # cell.value = unicode('%s' % col, errors='ignore')
+                cell.value = unicode(col)
                 cell.font = bold
                 if freeze_panes:
                     #  Export Freeze only after first Line
                     ws.freeze_panes = 'A2'
-
+                    
             # bold separators
             elif len(row) < dataset.width:
+                cell.value = unicode('%s' % col, errors='ignore')
                 cell.font = bold
 
             # wrap the rest
             else:
                 try:
-                    str_col_value = unicode(col)
+                    if '\n' in col:
+                        cell.value = unicode('%s' % col, errors='ignore')
+                        cell.alignment = wrap_text
+                    else:
+                        cell.value = unicode('%s' % col, errors='ignore')
                 except TypeError:
-                    str_col_value = ''
-                if '\n' in str_col_value:
-                    cell.alignment = wrap_text
+                    cell.value = unicode(col)
+
 
-            try:
-                cell.value = col
-            except (ValueError, TypeError):
-                cell.value = unicode(col)

+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_yaml.py → desktop/core/ext-py/tablib-0.12.1/tablib/formats/_yaml.py


+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/docs/__init__.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/__init__.py


+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/__init__.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/__init__.py


+ 4 - 4
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy/dbf.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/dbf.py

@@ -31,9 +31,9 @@ Examples:
         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()
+                print '%s:\t %s (%s)' % (fldName, rec[fldName],
+                    type(rec[fldName]))
+            print
         dbf.close()
 
 """
@@ -258,7 +258,7 @@ class Dbf(object):
 def demo_read(filename):
     _dbf = Dbf(filename, True)
     for _rec in _dbf:
-        print()
+        print
         print(repr(_rec))
     _dbf.close()
 

+ 6 - 6
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy/dbfnew.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/dbfnew.py

@@ -160,9 +160,9 @@ if __name__ == '__main__':
     dbfn.add_field("date", 'D', 8)
     dbfn.write("tst.dbf")
     # test new dbf
-    print("*** created tst.dbf: ***")
+    print "*** created tst.dbf: ***"
     dbft = Dbf('tst.dbf', readOnly=0)
-    print(repr(dbft))
+    print repr(dbft)
     # add a record
     rec = DbfRecord(dbft)
     rec['name'] = 'something'
@@ -177,13 +177,13 @@ if __name__ == '__main__':
     rec.store()
 
     # show the records
-    print("*** inserted 2 records into tst.dbf: ***")
-    print(repr(dbft))
+    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('%s:\t %s' % (fldName, rec[fldName]))
-        print()
+            print '%s:\t %s' % (fldName, rec[fldName])
+        print
     dbft.close()
 
     # vim: set et sts=4 sw=4 :

+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy/fields.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/fields.py


+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy/header.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/header.py


+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy/record.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/record.py


+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy/utils.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy/utils.py


+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy/__init__.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/__init__.py


+ 3 - 2
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy3/dbf.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/dbf.py

@@ -31,8 +31,9 @@ Examples:
         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 '%s:\t %s (%s)' % (fldName, rec[fldName],
+                    type(rec[fldName]))
+            print
         dbf.close()
 
 """

+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy3/dbfnew.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/dbfnew.py


+ 1 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy3/fields.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/fields.py

@@ -56,6 +56,7 @@ class DbfFieldDef(object):
 
     """
 
+
     __slots__ = ("name", "decimalCount",
         "start", "end", "ignoreErrors")
 

+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy3/header.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/header.py


+ 1 - 1
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy3/record.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/record.py

@@ -220,7 +220,7 @@ class DbfRecord(object):
     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)

+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy3/utils.py → desktop/core/ext-py/tablib-0.12.1/tablib/packages/dbfpy3/utils.py


+ 482 - 0
desktop/core/ext-py/tablib-0.12.1/tablib/packages/markup.py

@@ -0,0 +1,482 @@
+# 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 = u"<%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 in ['http_equiv', 'accept_charset']:
+                    key.replace('_','-')
+                out = u"%s %s=\"%s\"" % ( out, key, escape( value ) )
+            else:
+                out = u"%s %s" % ( out, key )
+        if between is not None:
+            out = u"%s>%s</%s>" % ( out, between, tag )
+        else:
+            if single:
+                out = u"%s />" % out
+            else:
+                out = u"%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__)

+ 484 - 0
desktop/core/ext-py/tablib-0.12.1/tablib/packages/markup3.py

@@ -0,0 +1,484 @@
+# 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__)

+ 127 - 0
desktop/core/ext-py/tablib-0.12.1/tablib/packages/ordereddict.py

@@ -0,0 +1,127 @@
+# 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

Rozdielové dáta súboru neboli zobrazené, pretože súbor je príliš veľký
+ 531 - 319
desktop/core/ext-py/tablib-0.12.1/test_tablib.py


+ 0 - 10
desktop/core/ext-py/tablib-0.14.0/.coveragerc

@@ -1,10 +0,0 @@
-# .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__.:

+ 0 - 10
desktop/core/ext-py/tablib-0.14.0/.github/CONTRIBUTING.md

@@ -1,10 +0,0 @@
-[![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).

+ 0 - 40
desktop/core/ext-py/tablib-0.14.0/.gitignore

@@ -1,40 +0,0 @@
-# application builds
-build/*
-dist/*
-MANIFEST
-
-# python skin
-*.pyc
-*.pyo
-
-# osx noise
-.DS_Store
-profile
-
-# pycharm noise
-.idea
-.idea/*
-
-# vi noise
-*.swp
-docs/_build/*
-coverage.xml
-nosetests.xml
-junit-py25.xml
-junit-py26.xml
-junit-py27.xml
-
-# tox noise
-.tox
-
-# pyenv noise
-.python-version
-tablib.egg-info/*
-
-# Coverage
-.coverage
-htmlcov
-
-# setuptools noise
-.eggs
-*.egg-info

+ 0 - 6
desktop/core/ext-py/tablib-0.14.0/.isort.cfg

@@ -1,6 +0,0 @@
-[settings]
-multi_line_output=3
-include_trailing_comma=True
-force_grid_wrap=0
-use_parentheses=True
-line_length=88

+ 0 - 22
desktop/core/ext-py/tablib-0.14.0/.travis.yml

@@ -1,22 +0,0 @@
-language: python
-python:
-- 2.7
-- 3.6
-- 3.7
-- 3.8
-cache: pip
-dist: xenial
-install: travis_retry pip install tox-travis
-script: tox
-after_success: bash <(curl -s https://codecov.io/bash)
-deploy:
-  provider: pypi
-  user: jazzband
-  server: https://jazzband.co/projects/tablib/upload
-  distributions: sdist bdist_wheel
-  password:
-    secure: svV4fYtodwW+iTyFOm5ISEfhVwcA+6vTskD3x6peznc40TdMV9Ek8nT3Q/NB4lCbXoUw2qR4H6uhLCjesnv/VvVk/qbitCyD8ySlgwOV5n7NzJs8lC8EYaHSjGQjatTwJAokfGVYkPawkI7HXDqtDggLUQBK+Ag8HDW+XBSbQIU=
-  on:
-    tags: true
-    repo: jazzband/tablib
-    python: 3.7

+ 0 - 30
desktop/core/ext-py/tablib-0.14.0/AUTHORS

@@ -1,30 +0,0 @@
-Tablib was originally written by Kenneth Reitz and is now maintained
-by the Jazzband GitHub team.
-
-Here is a list of passed and present much-appreciated contributors:
-
-    Alex Gaynor
-    Andrii Soldatenko
-    Benjamin Wohlwend
-    Bruno Soares
-    Claude Paroz
-    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
-    Rabin Nankhwa
-    Tommy Anthony
-    Tsuyoshi Hombashi
-    Tushar Makkar

+ 0 - 273
desktop/core/ext-py/tablib-0.14.0/HISTORY.md

@@ -1,273 +0,0 @@
-# History
-
-## 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.

+ 0 - 6
desktop/core/ext-py/tablib-0.14.0/MANIFEST.in

@@ -1,6 +0,0 @@
-recursive-include docs *
-recursive-include tests *
-include pytest.ini tox.ini .isort.cfg .coveragerc HISTORY.md README.md LICENSE AUTHORS
-prune docs/_build
-prune *.pyc
-prune __pycache__

+ 0 - 479
desktop/core/ext-py/tablib-0.14.0/PKG-INFO

@@ -1,479 +0,0 @@
-Metadata-Version: 2.1
-Name: tablib
-Version: 0.14.0
-Summary: Format agnostic tabular data library (XLS, JSON, YAML, CSV)
-Home-page: https://tablib.readthedocs.io
-Author: Kenneth Reitz
-Author-email: me@kennethreitz.org
-Maintainer: Jazzband
-Maintainer-email: roadies@jazzband.co
-License: MIT
-Description: # Tablib: format-agnostic tabular dataset library
-        
-        [![Jazzband](https://jazzband.co/static/img/badge.svg)](https://jazzband.co/)
-        [![Build Status](https://travis-ci.org/jazzband/tablib.svg?branch=master)](https://travis-ci.org/jazzband/tablib)
-        [![codecov](https://codecov.io/gh/jazzband/tablib/branch/master/graph/badge.svg)](https://codecov.io/gh/jazzband/tablib)
-        
-            _____         ______  ___________ ______
-            __  /_______ ____  /_ ___  /___(_)___  /_
-            _  __/_  __ `/__  __ \__  / __  / __  __ \
-            / /_  / /_/ / _  /_/ /_  /  _  /  _  /_/ /
-            \__/  \__,_/  /_.___/ /_/   /_/   /_.___/
-        
-        
-        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.)
-        
-        
-        ## 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, DBF, and CSV;
-        they can be exported to XLSX, XLS, ODS, JSON, YAML, DBF, CSV, TSV, and HTML.
-        
-        `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 XLSX, XLS, ODS, JSON, and YAML.
-        
-        
-        ## Usage
-        
-        Populate fresh data files:
-        
-        ```python
-        headers = ('first_name', 'last_name')
-        
-        data = [
-            ('John', 'Adams'),
-            ('George', 'Washington')
-        ]
-        
-        data = tablib.Dataset(*data, headers=headers)
-        ```
-        
-        Intelligently add new rows:
-        
-        ```python
-        >>> data.append(('Henry', 'Ford'))
-        ```
-        
-        Intelligently add new columns:
-        
-        ```python
-        >>> data.append_col((90, 67, 83), header='age')
-        ```
-        
-        Slice rows:
-        
-        ```python
-        >>> print(data[:2])
-        [('John', 'Adams', 90), ('George', 'Washington', 67)]
-        ```
-        
-        Slice columns by header:
-        
-        ```python
-        >>> print(data['first_name'])
-        ['John', 'George', 'Henry']
-        ```
-        
-        Easily delete rows:
-        
-        ```python
-        >>> del data[1]
-        ```
-        
-        
-        ## Exports
-        
-        Drumroll please...........
-        
-        ### JSON!
-        
-        ```python
-        >>> print(data.export('json'))
-        [
-          {
-            "last_name": "Adams",
-            "age": 90,
-            "first_name": "John"
-          },
-          {
-            "last_name": "Ford",
-            "age": 83,
-            "first_name": "Henry"
-          }
-        ]
-        ```
-        
-        ### YAML!
-        
-        ```python
-        >>> print(data.export('yaml'))
-        - {age: 90, first_name: John, last_name: Adams}
-        - {age: 83, first_name: Henry, last_name: Ford}
-        ```
-        
-        ### CSV...
-        
-        ```python
-        >>> print(data.export('csv'))
-        first_name,last_name,age
-        John,Adams,90
-        Henry,Ford,83
-        ```
-        
-        ### EXCEL!
-        
-        ```python
-        >>> with open('people.xls', 'wb') as f:
-        ...     f.write(data.export('xls'))
-        ```
-        
-        ### DBF!
-        
-        ```python
-        >>> with open('people.dbf', 'wb') as f:
-        ...     f.write(data.export('dbf'))
-        ```
-        
-        ### Pandas DataFrame!
-        
-        ```python
-        >>> print(data.export('df')):
-              first_name last_name  age
-        0       John     Adams   90
-        1      Henry      Ford   83
-        ```
-        
-        It's that easy.
-        
-        
-        ## Installation
-        
-        To install tablib, simply:
-        
-        ```console
-        $ pip install tablib[pandas]
-        ```
-        
-        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).
-        
-        
-        # History
-        
-        ## 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.
-        
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Natural Language :: English
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
-Description-Content-Type: text/markdown
-Provides-Extra: pandas

+ 0 - 177
desktop/core/ext-py/tablib-0.14.0/README.md

@@ -1,177 +0,0 @@
-# Tablib: format-agnostic tabular dataset library
-
-[![Jazzband](https://jazzband.co/static/img/badge.svg)](https://jazzband.co/)
-[![Build Status](https://travis-ci.org/jazzband/tablib.svg?branch=master)](https://travis-ci.org/jazzband/tablib)
-[![codecov](https://codecov.io/gh/jazzband/tablib/branch/master/graph/badge.svg)](https://codecov.io/gh/jazzband/tablib)
-
-    _____         ______  ___________ ______
-    __  /_______ ____  /_ ___  /___(_)___  /_
-    _  __/_  __ `/__  __ \__  / __  / __  __ \
-    / /_  / /_/ / _  /_/ /_  /  _  /  _  /_/ /
-    \__/  \__,_/  /_.___/ /_/   /_/   /_.___/
-
-
-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.)
-
-
-## 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, DBF, and CSV;
-they can be exported to XLSX, XLS, ODS, JSON, YAML, DBF, CSV, TSV, and HTML.
-
-`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 XLSX, XLS, ODS, JSON, and YAML.
-
-
-## Usage
-
-Populate fresh data files:
-
-```python
-headers = ('first_name', 'last_name')
-
-data = [
-    ('John', 'Adams'),
-    ('George', 'Washington')
-]
-
-data = tablib.Dataset(*data, headers=headers)
-```
-
-Intelligently add new rows:
-
-```python
->>> data.append(('Henry', 'Ford'))
-```
-
-Intelligently add new columns:
-
-```python
->>> data.append_col((90, 67, 83), header='age')
-```
-
-Slice rows:
-
-```python
->>> print(data[:2])
-[('John', 'Adams', 90), ('George', 'Washington', 67)]
-```
-
-Slice columns by header:
-
-```python
->>> print(data['first_name'])
-['John', 'George', 'Henry']
-```
-
-Easily delete rows:
-
-```python
->>> del data[1]
-```
-
-
-## Exports
-
-Drumroll please...........
-
-### JSON!
-
-```python
->>> print(data.export('json'))
-[
-  {
-    "last_name": "Adams",
-    "age": 90,
-    "first_name": "John"
-  },
-  {
-    "last_name": "Ford",
-    "age": 83,
-    "first_name": "Henry"
-  }
-]
-```
-
-### YAML!
-
-```python
->>> print(data.export('yaml'))
-- {age: 90, first_name: John, last_name: Adams}
-- {age: 83, first_name: Henry, last_name: Ford}
-```
-
-### CSV...
-
-```python
->>> print(data.export('csv'))
-first_name,last_name,age
-John,Adams,90
-Henry,Ford,83
-```
-
-### EXCEL!
-
-```python
->>> with open('people.xls', 'wb') as f:
-...     f.write(data.export('xls'))
-```
-
-### DBF!
-
-```python
->>> with open('people.dbf', 'wb') as f:
-...     f.write(data.export('dbf'))
-```
-
-### Pandas DataFrame!
-
-```python
->>> print(data.export('df')):
-      first_name last_name  age
-0       John     Adams   90
-1      Henry      Ford   83
-```
-
-It's that easy.
-
-
-## Installation
-
-To install tablib, simply:
-
-```console
-$ pip install tablib[pandas]
-```
-
-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).

+ 0 - 130
desktop/core/ext-py/tablib-0.14.0/docs/Makefile

@@ -1,130 +0,0 @@
-# Makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line.
-SPHINXOPTS    =
-SPHINXBUILD   = sphinx-build
-PAPER         =
-BUILDDIR      = _build
-
-# Internal variables.
-PAPEROPT_a4     = -D latex_paper_size=a4
-PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-
-.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest
-
-help:
-	@echo "Please use \`make <target>' where <target> is one of"
-	@echo "  html       to make standalone HTML files"
-	@echo "  dirhtml    to make HTML files named index.html in directories"
-	@echo "  singlehtml to make a single large HTML file"
-	@echo "  pickle     to make pickle files"
-	@echo "  json       to make JSON files"
-	@echo "  htmlhelp   to make HTML files and a HTML help project"
-	@echo "  qthelp     to make HTML files and a qthelp project"
-	@echo "  devhelp    to make HTML files and a Devhelp project"
-	@echo "  epub       to make an epub"
-	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
-	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
-	@echo "  text       to make text files"
-	@echo "  man        to make manual pages"
-	@echo "  changes    to make an overview of all changed/added/deprecated items"
-	@echo "  linkcheck  to check all external links for integrity"
-	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
-
-clean:
-	-rm -rf $(BUILDDIR)/*
-
-html:
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
-
-dirhtml:
-	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
-
-singlehtml:
-	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
-	@echo
-	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
-
-pickle:
-	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
-	@echo
-	@echo "Build finished; now you can process the pickle files."
-
-json:
-	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
-	@echo
-	@echo "Build finished; now you can process the JSON files."
-
-htmlhelp:
-	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
-	@echo
-	@echo "Build finished; now you can run HTML Help Workshop with the" \
-	      ".hhp project file in $(BUILDDIR)/htmlhelp."
-
-qthelp:
-	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
-	@echo
-	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
-	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
-	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Tablib.qhcp"
-	@echo "To view the help file:"
-	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Tablib.qhc"
-
-devhelp:
-	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
-	@echo
-	@echo "Build finished."
-	@echo "To view the help file:"
-	@echo "# mkdir -p $$HOME/.local/share/devhelp/Tablib"
-	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Tablib"
-	@echo "# devhelp"
-
-epub:
-	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
-	@echo
-	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
-
-latex:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo
-	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
-	@echo "Run \`make' in that directory to run these through (pdf)latex" \
-	      "(use \`make latexpdf' here to do that automatically)."
-
-latexpdf:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through pdflatex..."
-	make -C $(BUILDDIR)/latex all-pdf
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-text:
-	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
-	@echo
-	@echo "Build finished. The text files are in $(BUILDDIR)/text."
-
-man:
-	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
-	@echo
-	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
-
-changes:
-	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
-	@echo
-	@echo "The overview file is in $(BUILDDIR)/changes."
-
-linkcheck:
-	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
-	@echo
-	@echo "Link check complete; look for any errors in the above output " \
-	      "or in $(BUILDDIR)/linkcheck/output.txt."
-
-doctest:
-	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
-	@echo "Testing of doctests in the sources finished, look at the " \
-	      "results in $(BUILDDIR)/doctest/output.txt."

+ 0 - 18
desktop/core/ext-py/tablib-0.14.0/docs/Pipfile

@@ -1,18 +0,0 @@
-[[source]]
-name = "pypi"
-url = "https://pypi.org/simple"
-verify_ssl = true
-
-[dev-packages]
-
-[packages]
-"backports.csv" = "*"
-odfpy = "*"
-openpyxl = ">=2.4.0"
-pandas = "*"
-#xlrd = "*"
-#xlwt = "*"
-PyYAML = "*"
-
-[requires]
-python_version = "3.6"

+ 0 - 11
desktop/core/ext-py/tablib-0.14.0/docs/_templates/sidebarintro.html

@@ -1,11 +0,0 @@
-<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>
-</ul>

+ 0 - 4
desktop/core/ext-py/tablib-0.14.0/docs/_templates/sidebarlogo.html

@@ -1,4 +0,0 @@
-<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>

+ 0 - 64
desktop/core/ext-py/tablib-0.14.0/docs/api.rst

@@ -1,64 +0,0 @@
-.. _api:
-
-===
-API
-===
-
-
-.. module:: tablib
-
-This part of the documentation covers all the interfaces of Tablib.  For
-parts where Tablib depends on external libraries, we document the most
-important right here and provide links to the canonical documentation.
-
-
---------------
-Dataset Object
---------------
-
-
-.. autoclass:: Dataset
-   :inherited-members:
-
-
----------------
-Databook Object
----------------
-
-
-.. autoclass:: Databook
-   :inherited-members:
-
-
-
----------
-Functions
----------
-
-
-.. autofunction:: detect_format
-
-.. autofunction:: import_set
-
-
-----------
-Exceptions
-----------
-
-
-.. class:: InvalidDatasetType
-
-    You're trying to add something that doesn't quite look right.
-
-
-.. class:: InvalidDimensions
-
-    You're trying to add something that doesn't quite fit right.
-
-
-.. class:: UnsupportedFormat
-
-    You're trying to add something that doesn't quite taste right.
-
-
-Now, go start some :ref:`Tablib Development <development>`.

+ 0 - 227
desktop/core/ext-py/tablib-0.14.0/docs/conf.py

@@ -1,227 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Tablib documentation build configuration file, created by
-# sphinx-quickstart on Tue Oct  5 15:25:21 2010.
-#
-# This file is execfile()d with the current directory set to its containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-from pkg_resources import get_distribution
-
-# 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('..'))
-# -- General configuration -----------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-# 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']
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix of source filenames.
-source_suffix = '.rst'
-
-# The encoding of source files.
-#source_encoding = 'utf-8-sig'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = u'Tablib'
-copyright = u'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 full version, including alpha/beta/rc tags.
-release = get_distribution('tablib').version
-# The short X.Y version.
-version = '.'.join(release.split('.')[:2])
-# for example take major/minor
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#language = None
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-#today = ''
-# Else, today_fmt is used as the format for a strftime call.
-#today_fmt = '%B %d, %Y'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-exclude_patterns = ['_build']
-
-# The reST default role (used for this markup: `text`) to use for all documents.
-#default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-# add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-# pygments_style = ''
-
-# A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
-
-
-# -- Options for HTML output ---------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-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
-# documentation.
-#html_theme_options = {}
-
-# Add any paths that contain custom themes here, relative to this directory.
-#html_theme_path = []
-
-# The name for this set of Sphinx documents.  If None, it defaults to
-# "<project> v<release> documentation".
-#html_title = None
-
-# A shorter title for the navigation bar.  Default is the same as html_title.
-#html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-#html_logo = None
-
-# The name of an image file (within the static path) to use as favicon of the
-# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-#html_favicon = None
-
-# 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']
-
-# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
-# using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-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.
-#html_additional_pages = {}
-
-# If false, no module index is generated.
-#html_domain_indices = True
-
-# If false, no index is generated.
-#html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#html_split_index = False
-
-# If true, links to the reST sources are added to the pages.
-html_show_sourcelink = True
-
-# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-html_show_sphinx = False
-
-# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#html_show_copyright = True
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-#html_use_opensearch = ''
-
-# This is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = None
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'Tablibdoc'
-
-
-# -- Options for LaTeX output --------------------------------------------------
-
-# The paper size ('letter' or 'a4').
-#latex_paper_size = 'letter'
-
-# The font size ('10pt', '11pt' or '12pt').
-#latex_font_size = '10pt'
-
-# 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'Jazzband', 'manual'),
-]
-
-latex_use_modindex = False
-
-latex_elements = {
-    'papersize':    'a4paper',
-    'pointsize':    '12pt',
-}
-latex_use_parts = True
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-#latex_logo = None
-
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-#latex_use_parts = False
-
-# If true, show page references after internal links.
-#latex_show_pagerefs = False
-
-# If true, show URL addresses after external links.
-#latex_show_urls = False
-
-# Additional stuff for the LaTeX preamble.
-#latex_preamble = ''
-
-# Documents to append as an appendix to all manuals.
-#latex_appendices = []
-
-# If false, no module index is generated.
-#latex_domain_indices = True
-
-
-# -- Options for manual page output --------------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-    ('index', 'tablib', u'Tablib Documentation',
-     [u'Jazzband'], 1)
-]

+ 0 - 207
desktop/core/ext-py/tablib-0.14.0/docs/development.rst

@@ -1,207 +0,0 @@
-.. _development:
-
-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_.
-
-.. _GitHub: https://github.com/jazzband/tablib/
-
-
-
-.. _design:
-
----------------------
-Design Considerations
----------------------
-
-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.
-#. Complex is better than complicated.
-#. Readability counts.
-
-A few other things to keep in mind:
-
-#. Keep your code DRY.
-#. Strive to be as simple (to use) as possible.
-
-.. _scm:
-
---------------
-Source Control
---------------
-
-
-Tablib source is controlled with Git_, the lean, mean, distributed source
-control machine.
-
-The repository is publicly accessible.
-
-.. 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.
-
-``master``
-    Current production release (|version|) on PyPi.
-
-Each release is tagged.
-
-When submitting patches, please place your feature/change in its own branch prior to opening a pull request on GitHub_.
-
-
-.. _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:
-
-------------------
-Adding New Formats
-------------------
-
-Tablib welcomes new format additions! Format suggestions include:
-
-* MySQL Dump
-
-
-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*.
-
-1. Write a new format interface.
-
-    :class:`tablib.core` follows a simple pattern for automatically utilizing your format throughout Tablib.
-    Function names are crucial.
-
-    Example **tablib/formats/_xxx.py**: ::
-
-        title = 'xxx'
-
-        def export_set(dset):
-            ....
-            # returns string representation of given dataset
-
-        def export_book(dbook):
-            ....
-            # returns string representation of given databook
-
-        def import_set(dset, in_stream):
-            ...
-            # populates given Dataset with given datastream
-
-        def import_book(dbook, in_stream):
-            ...
-            # returns Databook instance
-
-        def detect(stream):
-            ...
-            # returns True if given stream is parsable as xxx
-
-   .. 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 functions.
-       Appropriate errors will be raised.
-
-2. Add your new format module to the :class:`tablib.formats.available` tuple.
-
-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>`.
-
-.. _testing:
-
---------------
-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.
-
-When developing a feature for Tablib,
-the easiest way to test your changes for potential issues is to simply run the test suite directly.
-
-.. code-block:: console
-
-    $ tox
-
-----------------------
-Continuous Integration
-----------------------
-
-Every pull request is automatically tested and inspected upon receipt with `Travis CI`_.
-If you broke the build, you will receive an email accordingly.
-
-Anyone may view the build status and history at any time.
-
-    https://travis-ci.org/jazzband/tablib
-
-Additional reports will also be included here in the future, including :pep:`8` checks and stress reports for extremely large datasets.
-
-.. _`Travis CI`: https://travis-ci.org/
-
-
-.. _docs:
-
------------------
-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.
-
-The Docs live in ``tablib/docs``.
-In order to build them, you will first need to install Sphinx.
-
-.. code-block:: console
-
-    $ 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
-
-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 **epub**, **latex**, **json**, *&c* similarly.
-
-.. _`reStructured Text`: http://docutils.sourceforge.net/rst.html
-.. _Sphinx: http://sphinx.pocoo.org
-.. _`GitHub Pages`: https://pages.github.com
-
-----------
-
-Make sure to check out the :ref:`API Documentation <api>`.

+ 0 - 116
desktop/core/ext-py/tablib-0.14.0/docs/index.rst

@@ -1,116 +0,0 @@
-.. 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.
-
-Tablib: Pythonic Tabular Datasets
-=================================
-
-Release v\ |version|. (:ref:`Installation <install>`)
-
-.. Contents:
-..
-.. .. toctree::
-..    :maxdepth: 2
-..
-
-.. Indices and tables
-.. ==================
-..
-.. * :ref:`genindex`
-.. * :ref:`modindex`
-.. * :ref:`search`
-
-
-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!
-
-
-User's Guide
-------------
-
-This part of the documentation, which is mostly prose, begins with some background information about Tablib, then focuses on step-by-step instructions for getting the most out of your datasets.
-
-.. toctree::
-   :maxdepth: 2
-
-   intro
-
-.. toctree::
-   :maxdepth: 2
-
-   install
-
-.. toctree::
-   :maxdepth: 2
-
-   tutorial
-
-.. toctree::
-   :maxdepth: 2
-
-   development
-
-
-API Reference
--------------
-
-If you are looking for information on a specific function, class or
-method, this part of the documentation is for you.
-
-.. toctree::
-   :maxdepth: 2
-
-   api

+ 0 - 67
desktop/core/ext-py/tablib-0.14.0/docs/install.rst

@@ -1,67 +0,0 @@
-.. _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.
-
-
-.. _installing:
-
------------------
-Installing Tablib
------------------
-
-Distribute & Pip
-----------------
-
-Of course, the recommended way to install Tablib is with `pip <https://pip.pypa.io>`_:
-
-.. code-block:: console
-
-    $ pip install tablib[pandas]
-
-
--------------------
-Download the Source
--------------------
-
-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.
-
-.. code-block:: console
-
-    $ python setup.py install
-
-
-To download the full source history from Git, see :ref:`Source Control <scm>`.
-
-.. _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:
-
-* PyPI: https://pypi.org/project/tablib/
-* GitHub: https://github.com/jazzband/tablib/
-
-When a new version is available, upgrading is simple::
-
-    $ pip install tablib --upgrade
-
-
-Now, go get a :ref:`Quick Start <quickstart>`.

+ 0 - 84
desktop/core/ext-py/tablib-0.14.0/docs/intro.rst

@@ -1,84 +0,0 @@
-.. _intro:
-
-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.
-
-
-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.
-#. Complex is better than complicated.
-#. Readability counts.
-
-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, BSD, and
-ISC 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`: https://opensource.org/licenses/gpl-license.php
-.. _`The MIT License`: https://opensource.org/licenses/mit-license.php
-
-
-.. _license:
-
-Tablib 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
-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.
-
-
-.. _pythonsupport:
-
-Pythons Supported
------------------
-
-At this time, the following Python versions are officially supported:
-
-* CPython 2.7
-* CPython 3.5
-* CPython 3.6
-* CPython 3.7
-
-Now, go :ref:`Install Tablib <install>`.

+ 0 - 118
desktop/core/ext-py/tablib-0.14.0/docs/krstyle.sty

@@ -1,118 +0,0 @@
-\definecolor{TitleColor}{rgb}{0,0,0}
-\definecolor{InnerLinkColor}{rgb}{0,0,0}
-
-\renewcommand{\maketitle}{%
-  \begin{titlepage}%
-    \let\footnotesize\small
-    \let\footnoterule\relax
-    \ifsphinxpdfoutput
-      \begingroup
-      % This \def is required to deal with multi-line authors; it
-      % changes \\ to ', ' (comma-space), making it pass muster for
-      % generating document info in the PDF file.
-      \def\\{, }
-      \pdfinfo{
-        /Author (\@author)
-        /Title (\@title)
-      }
-      \endgroup
-    \fi
-    \begin{flushright}%
-      %\sphinxlogo%
-      {\center
-        \vspace*{3cm}
-      	\includegraphics{logo.pdf}
-        \vspace{3cm}
-	\par
-        {\rm\Huge \@title \par}%
-        {\em\LARGE \py@release\releaseinfo \par}
-        {\large
-         \@date \par
-         \py@authoraddress \par
-        }}%
-    \end{flushright}%\par
-    \@thanks
-  \end{titlepage}%
-  \cleardoublepage%
-  \setcounter{footnote}{0}%
-  \let\thanks\relax\let\maketitle\relax
-  %\gdef\@thanks{}\gdef\@author{}\gdef\@title{}
-}
-
-\fancypagestyle{normal}{
-  \fancyhf{}
-  \fancyfoot[LE,RO]{{\thepage}}
-  \fancyfoot[LO]{{\nouppercase{\rightmark}}}
-  \fancyfoot[RE]{{\nouppercase{\leftmark}}}
-  \fancyhead[LE,RO]{{ \@title, \py@release}}
-  \renewcommand{\headrulewidth}{0.4pt}
-  \renewcommand{\footrulewidth}{0.4pt}
-}
-
-\fancypagestyle{plain}{
-  \fancyhf{}
-  \fancyfoot[LE,RO]{{\thepage}}
-  \renewcommand{\headrulewidth}{0pt}
-  \renewcommand{\footrulewidth}{0.4pt}
-}
-
-\titleformat{\section}{\Large}%
-            {\py@TitleColor\thesection}{0.5em}{\py@TitleColor}{\py@NormalColor}
-\titleformat{\subsection}{\large}%
-            {\py@TitleColor\thesubsection}{0.5em}{\py@TitleColor}{\py@NormalColor}
-\titleformat{\subsubsection}{}%
-            {\py@TitleColor\thesubsubsection}{0.5em}{\py@TitleColor}{\py@NormalColor}
-\titleformat{\paragraph}{\large}%
-            {\py@TitleColor}{0em}{\py@TitleColor}{\py@NormalColor}
-
-\ChNameVar{\raggedleft\normalsize}
-\ChNumVar{\raggedleft \bfseries\Large}
-\ChTitleVar{\raggedleft \rm\Huge}
-
-\renewcommand\thepart{\@Roman\c@part}
-\renewcommand\part{%
-   \pagestyle{empty}
-   \if@noskipsec \leavevmode \fi
-   \cleardoublepage
-   \vspace*{6cm}%
-   \@afterindentfalse
-   \secdef\@part\@spart}
-
-\def\@part[#1]#2{%
-    \ifnum \c@secnumdepth >\m@ne
-      \refstepcounter{part}%
-      \addcontentsline{toc}{part}{\thepart\hspace{1em}#1}%
-    \else
-      \addcontentsline{toc}{part}{#1}%
-    \fi
-    {\parindent \z@ %\center
-     \interlinepenalty \@M
-     \normalfont
-     \ifnum \c@secnumdepth >\m@ne
-       \rm\Large \partname~\thepart
-       \par\nobreak
-     \fi
-     \MakeUppercase{\rm\Huge #2}%
-     \markboth{}{}\par}%
-    \nobreak
-    \vskip 8ex
-    \@afterheading}
-\def\@spart#1{%
-    {\parindent \z@ %\center
-     \interlinepenalty \@M
-     \normalfont
-     \huge \bfseries #1\par}%
-     \nobreak
-     \vskip 3ex
-     \@afterheading}
-
-% use inconsolata font
-\usepackage{inconsolata}
-
-% fix single quotes, for inconsolata. (does not work)
-%%\usepackage{textcomp}
-%%\begingroup
-%%  \catcode`'=\active
-%%  \g@addto@macro\@noligs{\let'\textsinglequote}
-%%  \endgroup
-%%\endinput

+ 0 - 395
desktop/core/ext-py/tablib-0.14.0/docs/tutorial.rst

@@ -1,395 +0,0 @@
-.. _quickstart:
-
-==========
-Quickstart
-==========
-
-
-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:
-
-* Tablib is :ref:`installed <install>`
-* Tablib is :ref:`up-to-date <updates>`
-
-
-Let's get started with some simple use cases and examples.
-
-
-
-------------------
-Creating a Dataset
-------------------
-
-
-A :class:`Dataset <tablib.Dataset>` is nothing more than what its name implies—a set of data.
-
-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.
-
-
-
------------
-Adding Rows
------------
-
-
-Let's say you want to collect a simple list of names. ::
-
-    # collection of names
-    names = ['Kenneth Reitz', 'Bessie Monke']
-
-    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`::
-
-    >>> data.dict
-    [('Kenneth', 'Reitz'), ('Bessie', 'Monke')]
-
-
-
---------------
-Adding 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'}]
-
-
-
-
---------------
-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')
-
-Let's view the data now. ::
-
-    >>> data.dict
-    [{'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. ::
-
-   imported_data = Dataset().load(open('data.csv').read())
-
-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.
-
---------------
-Exporting Data
---------------
-
-Tablib's killer feature is the ability to export your :class:`Dataset` objects into a number of formats.
-
-**Comma-Separated Values** ::
-
-    >>> data.export('csv')
-    Last Name,First Name,Age
-    Reitz,Kenneth,22
-    Monke,Bessie,20
-
-**JavaScript Object Notation** ::
-
-    >>> 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.export('yaml')
-    - {Age: 22, First Name: Kenneth, Last Name: Reitz}
-    - {Age: 20, First Name: Bessie, Last Name: Monke}
-
-
-**Microsoft Excel** ::
-
-    >>> data.export('xls')
-    <redacted binary data>
-
-
-**Pandas DataFrame** ::
-
-    >>> data.export('df')
-      First Name Last Name  Age
-    0    Kenneth     Reitz   22
-    1     Bessie     Monke   21
-
-
-------------------------
-Selecting Rows & Columns
-------------------------
-
-
-You can slice and dice your data, just like a standard Python list. ::
-
-    >>> data[0]
-    ('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.
-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']
-    >>> float(sum(ages)) / len(ages)
-    21.0
-
-
-
------------------------
-Removing Rows & Columns
------------------------
-
-It's easier than you could imagine. Delete a column::
-
-    >>> del data['Col Name']
-
-Delete a range of rows::
-
-    >>> del data[0:12]
-
-
-==============
-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>`
-
-And now for something completely different.
-
-
-.. _dyncols:
-
----------------
-Dynamic Columns
----------------
-
-.. versionadded:: 0.8.3
-
-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. ::
-
-    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')
-
-Let's have a look at our data. ::
-
-    >>> 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}
-
-
-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.
-
-For example, we can use the data available in the row to guess the gender of a student. ::
-
-    def guess_gender(row):
-        """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:
-            return 'Female'
-        else:
-            return 'Unknown'
-
-Adding this function to our dataset as a dynamic column would result in: ::
-
-    >>> data.export('yaml')
-    - {Age: 22, First Name: Kenneth, Gender: Male, Last Name: Reitz}
-    - {Age: 20, First Name: Bessie, Gender: Female, Last Name: Monke}
-
-
-.. _tags:
-
-----------------------------
-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 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. ::
-
-    students = tablib.Dataset()
-
-    students.headers = ['first', 'last']
-
-    students.rpush(['Kenneth', 'Reitz'], tags=['male', 'technical'])
-    students.rpush(['Bessie', 'Monke'], tags=['female', 'creative'])
-
-Now that we have extra meta-data on our rows, we can easily filter our :class:`Dataset`. Let's just see Male students. ::
-
-
-    >>> students.filter(['male']).yaml
-    - {first: Kenneth, Last: Reitz}
-
-It's that simple. The original :class:`Dataset` is untouched.
-
-Open an Excel Workbook and read first sheet
--------------------------------------------
-
-To open an Excel 2007 and later workbook with a single sheet (or a workbook with multiple sheets but you just want the first sheet), use the following:
-
-data = tablib.Dataset()
-data.xlsx = open('my_excel_file.xlsx', 'rb').read()
-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.
-
-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))
-
-... and export to Excel just like :class:`Datasets <Dataset>`. ::
-
-    with open('students.xls', 'wb') as f:
-        f.write(book.xls)
-
-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.
-
-
-.. _separators:
-
-----------
-Separators
-----------
-
-.. versionadded:: 0.8.2
-
-When constructing a spreadsheet,
-it's often useful to create a blank row containing information on the upcoming data. So,
-
-::
-
-    daniel_tests = [
-        ('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_separator('Daniel\'s Scores')
-
-    for test_row in daniel_tests:
-       tests.append(test_row)
-
-    # Susie's Tests
-    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.export('xls'))
-
-The resulting **tests.xls** will have the following layout:
-
-
-    Daniel's Scores:
-        * '11/24/09', 'Math 101 Mid-term Exam', 56.
-        * '05/24/10', 'Math 101 Final Exam', 62.
-
-    Suzie's Scores:
-        * '11/24/09', 'Math 101 Mid-term Exam', 56.
-        * '05/24/10', 'Math 101 Final Exam', 62.
-
-
-
-.. 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>`.

+ 0 - 4
desktop/core/ext-py/tablib-0.14.0/pytest.ini

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

+ 0 - 57
desktop/core/ext-py/tablib-0.14.0/setup.py

@@ -1,57 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import os
-import re
-import sys
-
-from setuptools import find_packages, setup
-
-
-install = [
-    'odfpy',
-    'openpyxl>=2.4.0',
-    'backports.csv;python_version<"3.0"',
-    'markuppy',
-#    'xlrd',
-#    'xlwt',
-    'pyyaml',
-]
-
-
-setup(
-    name='tablib',
-    use_scm_version=True,
-    setup_requires=['setuptools_scm'],
-    description='Format agnostic tabular data library (XLS, JSON, YAML, CSV)',
-    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.org',
-    maintainer='Jazzband',
-    maintainer_email='roadies@jazzband.co',
-    url='https://tablib.readthedocs.io',
-    packages=find_packages(where="src"),
-    package_dir={"": "src"},
-    license='MIT',
-    classifiers=[
-        'Development Status :: 5 - Production/Stable',
-        'Intended Audience :: Developers',
-        'Natural Language :: English',
-        'License :: OSI Approved :: MIT License',
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 2',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8',
-    ],
-    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*',
-    install_requires=install,
-    extras_require={
-        'pandas': ['pandas'],
-    },
-)

+ 0 - 13
desktop/core/ext-py/tablib-0.14.0/src/tablib/__init__.py

@@ -1,13 +0,0 @@
-""" Tablib. """
-from pkg_resources import get_distribution, DistributionNotFound
-
-from tablib.core import (
-    Databook, Dataset, detect_format, import_set, import_book,
-    InvalidDatasetType, InvalidDimensions, UnsupportedFormat
-)
-
-try:
-    __version__ = get_distribution(__name__).version
-except DistributionNotFound:
-    # package is not installed
-    __version__ = None

+ 0 - 36
desktop/core/ext-py/tablib-0.14.0/src/tablib/compat.py

@@ -1,36 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-tablib.compat
-~~~~~~~~~~~~~
-
-Tablib compatiblity module.
-
-"""
-
-import sys
-
-is_py3 = (sys.version_info[0] > 2)
-
-
-if is_py3:
-    from io import StringIO
-    from statistics import median
-    from itertools import zip_longest as izip_longest
-    import csv
-    import tablib.packages.dbfpy3 as dbfpy
-
-    unicode = str
-    xrange = range
-
-else:
-    from StringIO import StringIO
-    from tablib.packages.statistics import median
-    from itertools import izip_longest
-    from backports import csv
-    import tablib.packages.dbfpy as dbfpy
-
-    unicode = unicode
-    xrange = xrange
-
-from MarkupPy import markup  # Kept temporarily to avoid breaking existing imports

+ 0 - 39
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_jira.py

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""Tablib - Jira table export support.
-
-   Generates a Jira table from the dataset.
-"""
-from tablib.compat import unicode
-
-title = 'jira'
-
-
-def export_set(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 = _get_header(dataset.headers) if dataset.headers else ''
-    body = _get_body(dataset)
-    return '%s\n%s' % (header, body) if header else body
-
-
-def _get_body(dataset):
-    return '\n'.join([_serialize_row(row) for row in dataset])
-
-
-def _get_header(headers):
-    return _serialize_row(headers, delimiter='||')
-
-
-def _serialize_row(row, delimiter='|'):
-    return '%s%s%s' % (delimiter,
-                       delimiter.join([unicode(item) if item else ' ' for item in row]),
-                       delimiter)

+ 0 - 273
desktop/core/ext-py/tablib-0.14.0/src/tablib/formats/_rst.py

@@ -1,273 +0,0 @@
-# -*- coding: utf-8 -*-
-
-""" Tablib - reStructuredText Support
-"""
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-from textwrap import TextWrapper
-
-from tablib.compat import (
-    median,
-    unicode,
-    izip_longest,
-)
-
-
-title = 'rst'
-extensions = ('rst',)
-
-
-MAX_TABLE_WIDTH = 80  # Roughly. It may be wider to avoid breaking words.
-
-
-JUSTIFY_LEFT = 'left'
-JUSTIFY_CENTER = 'center'
-JUSTIFY_RIGHT = 'right'
-JUSTIFY_VALUES = (JUSTIFY_LEFT, JUSTIFY_CENTER, JUSTIFY_RIGHT)
-
-
-def to_unicode(value):
-    if isinstance(value, bytes):
-        return value.decode('utf-8')
-    return unicode(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()))
-
-
-def _get_column_string_lengths(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_unicode(val)
-            column_lengths[i].append(len(text))
-            word_lens[i] = max(word_lens[i], _max_word_len(text))
-    return column_lengths, word_lens
-
-
-def _row_to_lines(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_unicode(value)
-        cell = wrapper.wrap(text)
-        cells.append(cell)
-    lines = izip_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
-
-
-def _get_column_widths(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 = _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
-
-
-def export_set_as_simple_table(dataset, column_widths=None):
-    """
-    Returns reStructuredText grid table representation of dataset.
-    """
-    lines = []
-    wrapper = TextWrapper()
-    if column_widths is None:
-        column_widths = _get_column_widths(dataset, pad_len=2)
-    border = '  '.join(['=' * w for w in column_widths])
-
-    lines.append(border)
-    if dataset.headers:
-        lines.extend(_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(_row_to_lines(values, column_widths, wrapper, ''))
-    lines.append(border)
-    return '\n'.join(lines)
-
-
-def export_set_as_grid_table(dataset, column_widths=None):
-    """
-    Returns reStructuredText grid table representation of dataset.
-
-
-    >>> from tablib import Dataset
-    >>> from tablib.formats import rst
-    >>> 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)])
-    >>> 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 = _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(_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(_row_to_lines(values, column_widths, wrapper))
-        lines.append(row_sep)
-    return '\n'.join(lines)
-
-
-def _use_simple_table(head0, col0, width0):
-    """
-    Use a simple table if the text in the first column is never wrapped
-
-
-    >>> _use_simple_table('menu', ['egg', 'bacon'], 10)
-    True
-    >>> _use_simple_table(None, ['lobster thermidor', 'spam'], 10)
-    False
-
-    """
-    if head0 is not None:
-        head0 = to_unicode(head0)
-        if len(head0) > width0:
-            return False
-    for cell in col0:
-        cell = to_unicode(cell)
-        if len(cell) > width0:
-            return False
-    return True
-
-
-def export_set(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', MAX_TABLE_WIDTH)
-    column_widths = _get_column_widths(dataset, max_table_width)
-
-    use_simple_table = _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 export_set_as_simple_table(dataset, column_widths)
-    else:
-        return export_set_as_grid_table(dataset, column_widths)
-
-
-def export_book(databook):
-    """
-    reStructuredText representation of a Databook.
-
-    Tables are separated by a blank line. All tables use the grid
-    format.
-    """
-    return '\n\n'.join(export_set(dataset, force_grid=True)
-                       for dataset in databook._datasets)

+ 0 - 0
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/dbfpy3/__init__.py


+ 0 - 24
desktop/core/ext-py/tablib-0.14.0/src/tablib/packages/statistics.py

@@ -1,24 +0,0 @@
-from __future__ import division
-
-
-def median(data):
-    """
-    Return the median (middle value) of numeric data, using the common
-    "mean of middle two" method. If data is empty, ValueError is raised.
-
-    Mimics the behaviour of Python3's statistics.median
-
-    >>> median([1, 3, 5])
-    3
-    >>> median([1, 3, 5, 7])
-    4.0
-
-    """
-    data = sorted(data)
-    n = len(data)
-    if not n:
-        raise ValueError("No median for empty data")
-    i = n // 2
-    if n % 2:
-        return data[i]
-    return (data[i - 1] + data[i]) / 2

+ 0 - 10
desktop/core/ext-py/tablib-0.14.0/tests/requirements.txt

@@ -1,10 +0,0 @@
-pytest
-pytest-cov
-backports.csv; python_version < '3.0'
-MarkupPy
-odfpy
-openpyxl>=2.4.0
-pandas
-pyyaml
-#xlrd
-#xlwt

+ 0 - 40
desktop/core/ext-py/tablib-0.14.0/tox.ini

@@ -1,40 +0,0 @@
-[tox]
-usedevelop = true
-minversion = 2.4
-envlist =
-    py{27,35,36,37,38}-tests,
-    py37-{docs,lint}
-
-[testenv]
-basepython =
-    py27: python2.7
-    py35: python3.5
-    py36: python3.6
-    py37: python3.7
-    py38: python3.8
-deps =
-    tests: -rtests/requirements.txt
-    docs: sphinx
-extras = pandas
-commands =
-    tests: pytest {posargs:tests}
-    docs: sphinx-build -b html -d {envtmpdir}/doctrees docs {envtmpdir}/html
-
-[testenv:py37-lint]
-basepython = python3.7
-deps =
-    flake8
-    # flake8-black
-    # flake8-isort
-    twine
-    check-manifest
-commands =
-    # flake8 src/tablib tests/
-    check-manifest -v
-    python setup.py sdist
-    twine check dist/*
-
-[flake8]
-exclude =
-    .tox
-ignore=E501,E127,E128,E124

Niektoré súbory nie sú zobrazené, pretože je v týchto rozdielových dátach zmenené mnoho súborov