Repository: ContextLab/data-wrangler (language: python)

Issue:
two minor updates to data loading functions
1. **explicitly close `numpy.lib.npyio.NpzFile` instance, handle errors**
   
   From the [numpy.load docs](https://numpy.org/devdocs/reference/generated/numpy.load.html):
   > For .npz files, the returned instance of NpzFile class must be closed to avoid leaking file descriptors.

   This probably isn't a big deal since Python generally closes file descriptors automatically when their reference counts drops to 0,  but there are a few scenarios where this doesn't happen (an exception is raised, running in `pdb` or an IDE debugger, etc.) and this change will handle most or all of them without adding any real overhead. The cleanest way to do this would just be to wrap the reset of `datawrangler.io.io.load` after the call to `numpy.load()` in a `try`/`finally` block and explicitly close the descriptor when the function returns, but this isn't possible because its fields (e.g., `"corpus"`) need to be accessible in outer scopes. I didn't comb through the code too carefully, so there may be other calls to `datawrangler.io.io.load` that would benefit from updates similar to `datawrangler.zoo.text.get_corpus`, but again, I don't think this is a high-priority issue.

2. **change `data_name` ➡️ `dataset_name` in `datawrangler.zoo.text.get_corpus`**

   There was a reference to a variable named `data_name` that didn't seem to exist anywhere -- my guess is that the `dataset_name` parameter was at some point renamed from `data_name`, and this one use of it wasn't updated. I looked through the git blame, and the bug has existed since the [`hypertools_revamp` notebook](https://github.com/jeremymanning/hypertools/blob/dev/dev/hypertools_revamp.ipynb) this function was added from. If `data_name` should actually be something other than `dataset_name`, let me know!


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 71028b9..adf5686 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -1,15 +1,40 @@
 name: Python package
 
-on: [push]
+on:
+  push:
+    paths:
+      - .github/workflows/**
+      - datawrangler/**
+      - tests/**
+      - MANIFEST.in
+      - Makefile
+      - requirements.txt
+      - requirements_dev.txt
+      - setup.cfg
+      - setup.py
+      - tox.ini
+  pull_request:
+    paths:
+      - .github/workflows/**
+      - datawrangler/**
+      - tests/**
+      - MANIFEST.in
+      - Makefile
+      - requirements.txt
+      - requirements_dev.txt
+      - setup.cfg
+      - setup.py
+      - tox.ini
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
+    # only run on pull requests between forks to avoid duplicate runs with 'push' event
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository
     strategy:
+      fail-fast: false
       matrix:
-        python-version: [3.7]
-
+        python-version: [3.6, 3.7, 3.8, 3.9]
     steps:
       - uses: actions/checkout@v2
       - name: Set up Python ${{ matrix.python-version }}
diff --git a/AUTHORS.rst b/AUTHORS.rst
index 8cca846..9049f65 100644
--- a/AUTHORS.rst
+++ b/AUTHORS.rst
@@ -5,12 +5,13 @@ Credits
 Development Lead
 ----------------
 
-* Jeremy Manning <jeremy.r.manning@dartmouth.edu>
+* Jeremy Manning <https://github.com/jeremymanning>
 
 Contributors
 ------------
 
-* Contextual Dynamics Lab <http://www.context-lab.com>
+* Contextual Dynamics Lab <https://github.com/ContextLab>
+* Paxton Fitzpatrick <https://github.com/paxtonfitzpatrick>
 
 Want to help? Contribute something and we'll add you to the list!
 
diff --git a/HISTORY.rst b/HISTORY.rst
index 691df79..260af9a 100644
--- a/HISTORY.rst
+++ b/HISTORY.rst
@@ -2,6 +2,42 @@
 History
 =======
 
+0.1.7 (2021-08-09)
+------------------
+
+* Updates default behaviors for several models (via config.ini)
+
+
+0.1.6 (2021-08-09)
+------------------
+
+* Another bug fix release (more fixes to datawrangler.unstack)
+
+0.1.5 (2021-08-09)
+------------------
+
+* Corrected a bug in datawrangler.unstack
+
+0.1.4 (2021-08-04)
+------------------
+
+* Added an option to specify a customized dictionary of default options to the apply_default_options function
+
+0.1.3 (2021-08-04)
+------------------
+
+* Fixed some bugs related to stacking and unstacking DataFrames
+
+0.1.2 (2021-08-04)
+------------------
+
+* Minor update that corrects URLs of Khan Academy and NeurIPS corpora and corrects some issues with loading npy files
+
+0.1.1 (2021-07-19)
+------------------
+
+* Minor update in order to make the package available on pipy.
+
 0.1.0 (2021-07-09)
 ------------------
 
diff --git a/README.md b/README.md
deleted file mode 100644
index 4cb0b71..0000000
--- a/README.md
+++ /dev/null
@@ -1,86 +0,0 @@
-# Data Wrangler 🤠
-Wrangle your messy data into consistent well-organized formats!
-
-
-## Overview
-
-Datasets come in all shapes and sizes, and are often *messy*:
-  - Observations come in different formats
-  - There are missing values
-  - Labels are missing and/or aren't consistent
-  - Datasets need to be [wrangled](https://en.wikipedia.org/wiki/Data_wrangling) into formats that play more nicely with other parts of your analysis pipeline
-
-The main goal of `data-wrangler` is to turn messy data into clean(er) data, defined as one of the following:
-  - A single two-dimensional `numpy` `array` whose rows are observations and whose columns are features
-  - A single `pandas` `DataFrame` whose indices are observations and whose columns are features
-  - A list of `array`s (each formatted as described above)
-  - A list of `DataFrame`s (each formatted as described above)
- 
-## Supported data formats 
-
-One package can't accomodate every foreseeable format or input source, but `data-wrangler` provides a framework for adding support for new datatypes in a straightforward way.  Essentially, adding support for a new data type entails writing two functions:
-  - An `is_<datatype>` function, which should return `True` if an object is compatable with the given datatype (or format), and `False` otherwise
-  - A `wrangle_<datatype>` function, which should take in an object of the given type or format and return a `pandas` `DataFrame` with numerical entries
-
-Currently supported datatypes are limited to:
-  - `array`-like objects
-  - `DataFrame`-like or `Series`-like objects
-  - text data (text is embedded using cutting-edge [natural language processing](https://en.wikipedia.org/wiki/Word_embedding) models)
-or lists of mixtures of the above.
-
-Missing observations (e.g. `nan`s, empty strings, etc.) may be filled in using:
-  - [Probabilistic principle component analysis](https://www.jstor.org/stable/2680726) to fill in isolated missing columns (features) that are present in at least some observations
-  - [Interpolation](https://en.wikipedia.org/wiki/Interpolation) to fill in observations with no features (e.g., when nearby observations are available)
-
-
-## Installation
-
-The `data-wrangler` package may be installed using `pip`:
-```
-pip install data-wrangler
-```
-
-To install the bleeding edge (development) version, use:
-```
-pip install git+https://github.com/ContextLab/data-wrangler.git
-```
-
-# Use
-
-
-## The `wrangle` function
-For numerical data (stored in `array`-like, `DataFrame`-like, or `Series`-like objects, or lists thereof), the `wrangle` function will (by default) transform the dataset as follows:
-  - Convert `array`-like and `Series`-like objects into `DataFrame`s
-  - If the data are passed in as a list, return the resulting list of converted `DataFrame`s
-  - If the data are passed as a single `array`-like, `DataFrame`-like, `Series`-like objct, return the resulting converted `DataFrame`
-
-Using the function in this way is simple:
-
-```python
-import datawrangler as dw
-
-data = <LOAD IN YOUR MIXED-FORMATTED DATASET>
-
-wrangled_data = dw.wrangle(data) # wrangled_data is either a DataFrame or a list of DataFrames
-```
-
-## The `generalizer` decorator
-
-## Inferring missing data
-
-## Handling text data
-
-### `scikit-learn` models
-
-### `hugging-face` models
-
-### Downloading supported text corpora
-
-## Adding support for new datatypes
-
-### Writing an `is_<DATATYPE>` function
-
-### Writing a `wrangle_<DATATYPE>` function
-
-# Contributing
-
diff --git a/README.rst b/README.rst
index 96a2e28..401d2f4 100644
--- a/README.rst
+++ b/README.rst
@@ -1,6 +1,8 @@
 Overview
 ================
 
+|build-status|  |docs|  |doi|
+
 Datasets come in all shapes and sizes, and are often *messy*:
 
   - Observations come in different formats
@@ -8,21 +10,62 @@ Datasets come in all shapes and sizes, and are often *messy*:
   - Labels are missing and/or aren't consistent
   - Datasets need to be wrangled 🐄 🐑 🚜
 
-The main goal of ``data-wrangler`` is to turn messy data into clean(er) data, defined as one of the following:
+The main goal of ``data-wrangler`` is to turn messy data into clean(er) data, defined as either a ``DataFrame`` or a
+list of ``DataFrame`` objects.  The package provides code for easily wrangling data from a variety of formats into
+``DataFrame`` objects, manipulating ``DataFrame`` objects in useful ways (that can be tricky to implement, but that
+apply to many analysis scenarios), and decorating Python functions to make them more flexible and/or easier to write.
+
+The ``data-wrangler`` package supports a variety of datatypes.  There is a special emphasis on text data, whereby
+``data-wrangler`` provides a simple API for interacting with natural language processing tools and datasets provided by
+``scikit-learn``, ``hugging-face``, and ``flair``.  The package is designed to provide sensible defaults, but also
+implements convenient ways of deeply customizing how different datatypes are wrangled.
+
+For more information, including a formal API and tutorials, check out https://data-wrangler.readthedocs.io
+
+Quick start
+================
 
-  - A single two-dimensional ``numpy`` ``array`` whose rows are observations and whose columns are features
-  - A single ``pandas`` ``DataFrame`` whose indices are observations and whose columns are features
-  - A list of ``array`` objects (each formatted as described above)
-  - A list of ``DataFrame`` objects (each formatted as described above)
+Install datawrangler using:
 
+.. code-block:: console
 
-Usage
-------
+    $ pip install pydata-wrangler
 
-To use datawrangler in a project::
+Some quick natural language processing examples::
 
     import datawrangler as dw
 
+    # load in sample text
+    text_url = 'https://raw.githubusercontent.com/ContextLab/data-wrangler/main/tests/resources/home_on_the_range.txt'
+    text = dw.io.load(text_url)
+
+    # embed text using scikit-learn's implementation of Latent Dirichlet Allocation, trained on a curated subset of
+    # Wikipedia, called the 'minipedia' corpus.  Return the fitted model so that it can be applied to new text.
+    lda = {'model': ['CountVectorizer', 'LatentDirichletAllocation'], 'args': [], 'kwargs': {}}
+    lda_embeddings, lda_fit = dw.wrangle(text, text_kwargs={'model': lda, 'corpus': 'minipedia'}, return_model=True)
+
+    # apply the minipedia-trained LDA model to new text
+    new_text = 'how much wood could a wood chuck chuck if a wood chuck could check wood?'
+    new_embeddings = dw.wrangle(new_text, text_kwargs={'model': lda_fit})
+
+    # embed text using hugging-face's pre-trained GPT2 model
+    gpt2 = {'model': 'TransformerDocumentEmbeddings', 'args': ['gpt2'], 'kwargs': {}}
+    gpt2_embeddings = dw.wrangle(text, text_kwargs={'model': gpt2})
+
+The ``data-wrangler`` package also provides powerful decorators that can modify existing functions to support new
+datatypes.  Just write your function as though its inputs are guaranteed to be Pandas DataFrames, and decorate it with
+``datawrangler.decorate.funnel`` to enable support for other datatypes without any new code::
+
+  image_url = 'https://raw.githubusercontent.com/ContextLab/data-wrangler/main/tests/resources/wrangler.jpg'
+  image = dw.io.load(image_url)
+
+  # define your function and decorate it with "funnel"
+  @dw.decorate.funnel
+  def binarize(x):
+    return x > np.mean(x.values)
+
+  binarized_image = binarize(image)  # rgb channels will be horizontally concatenated to create a 2D DataFrame
+
 
 Supported data formats
 ----------------------
@@ -34,12 +77,20 @@ One package can't accommodate every foreseeable format or input source, but ``da
 
 Currently supported datatypes are limited to:
 
-  - ``array``-like objects
+  - ``array``-like objects (including images)
   - ``DataFrame``-like or ``Series``-like objects
-  - text data (text is embedded using cutting-edge natural language processing
+  - text data (text is embedded using natural language processing models)
 or lists of mixtures of the above.
 
-Missing observations (e.g., ``nan``s, empty strings, etc.) may be filled in using:
+Missing observations (e.g., nans, empty strings, etc.) may be filled in using imputation and/or interpolation.
+
+.. |build-status| image:: https://github.com/ContextLab/data-wrangler/actions/workflows/ci.yaml/badge.svg
+    :alt: build status
+    :target: https://github.com/ContextLab/data-wrangler
+
+.. |docs| image:: https://readthedocs.org/projects/data-wrangler/badge/
+    :alt: docs status
+    :target: https://data-wrangler.readthedocs.io/
 
-  - Probabilistic principle component analysis
-  - Interpolation to fill in observations with no features (e.g., when nearby observations are available)
+.. |doi| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.5123310.svg
+   :target: https://doi.org/10.5281/zenodo.5123310
diff --git a/datawrangler/__init__.py b/datawrangler/__init__.py
index 5b28a98..dccab2a 100644
--- a/datawrangler/__init__.py
+++ b/datawrangler/__init__.py
@@ -2,8 +2,7 @@
 
 __author__ = """Contextual Dynamics Lab"""
 __email__ = 'contextualdynamics@gmail.com'
-__version__ = '0.1.0'
-
 
 from .zoo import wrangle
 from .decorate.decorate import funnel, pandas_stack as stack, pandas_unstack as unstack
+from .core import __version__
diff --git a/datawrangler/core/__init__.py b/datawrangler/core/__init__.py
index 5699b9e..539ec0b 100644
--- a/datawrangler/core/__init__.py
+++ b/datawrangler/core/__init__.py
@@ -1,1 +1,1 @@
-from .configurator import get_default_options, apply_defaults, update_dict
+from .configurator import get_default_options, apply_defaults, update_dict, __version__
diff --git a/datawrangler/core/config.ini b/datawrangler/core/config.ini
index b66aad4..2d4e6ae 100644
--- a/datawrangler/core/config.ini
+++ b/datawrangler/core/config.ini
@@ -1,5 +1,5 @@
 [supported_formats]
-types = ['dataframe', 'image', 'text', 'array', 'null']
+types = ['dataframe', 'text', 'array', 'null']
 
 
 [text]
@@ -68,9 +68,6 @@ n_components = 50
 [SparsePCA]
 n_components = 50
 
-[SparseCoder]
-n_components = 50
-
 [TruncatedSVD]
 n_components = 50
 
diff --git a/datawrangler/core/configurator.py b/datawrangler/core/configurator.py
index 3457154..709dc8f 100644
--- a/datawrangler/core/configurator.py
+++ b/datawrangler/core/configurator.py
@@ -1,5 +1,4 @@
 from configparser import ConfigParser
-from pkg_resources import get_distribution
 from copy import copy
 import os
 import warnings
@@ -8,7 +7,7 @@
 import numpy as np                     # used when applying default options
 
 
-__version__ = get_distribution('datawrangler')
+__version__ = '0.1.7'
 
 
 def get_default_options(fname=None):
@@ -17,11 +16,11 @@ def get_default_options(fname=None):
 
     Parameters
     ----------
-    fname: absolute-path filename for the config.ini file (default: data-wrangler/datawrangler/core/config.ini)
+    :param fname: absolute-path filename for the config.ini file (default: data-wrangler/datawrangler/core/config.ini)
 
     Returns
     -------
-    A dictionary whose keys are function names and whose values are dictionaries of default arguments and keyword
+    :return: A dictionary whose keys are function names and whose values are dictionaries of default arguments and keyword
     arguments
     """
     if fname is None:
@@ -34,26 +33,32 @@ def get_default_options(fname=None):
     for a, b in config.items():
         config[a] = dict(b)
         for c, d in config[a].items():
-            config[a][c] = eval(d)
+            config[a][c] = d
 
     return config
 
 
-def update_dict(template, updates):
+def update_dict(template, updates, from_config=False):
     """
     Replace a template dictionary's values with new values defined in a second "updates" dictionary.
 
     Parameters
     ----------
-    template: default keys and values to use (if not specified in the "updates" dictionary)
-    updates: new values to use (and/or new keys to add to the resulting dictionary)
+    :param template: default keys and values to use (if not specified in the "updates" dictionary)
+    :param updates: new values to use (and/or new keys to add to the resulting dictionary)
+    :param from_config: if True, evaluate the keys in the "template" dictionary and set their values to the result.
+      Used when loading options from the configuration file.  (Default: False)
 
     Returns
     -------
-    A new dictionary containing the union of the keys/values in template and updates, with preference given to
+    :return: A new dictionary containing the union of the keys/values in template and updates, with preference given to
     the updates dictionary
     """
     template = copy(template)
+    if from_config:
+        for k, v in template.items():
+            template[k] = eval(v)
+
     for k, v in updates.items():
         template[k] = v
     return template
@@ -61,24 +66,29 @@ def update_dict(template, updates):
 
 defaults = get_default_options()
 
-if not os.path.exists(defaults['data']['datadir']):
-    os.makedirs(defaults['data']['datadir'])
+if not os.path.exists(eval(defaults['data']['datadir'])):
+    os.makedirs(eval(defaults['data']['datadir']))
 
 
 # add in default keyword arguments (and values) specified in config.ini based on the function or class name
 # can also be used as a decorator
-def apply_defaults(f):
+def apply_defaults(f, defaults=None):
     """
     Replace a function's default arguments and keyword arguments with defaults specified in config.ini
 
     Parameters
     ----------
-    f: a function
+    :param f: a function
+    :param defaults: an optional dictionary of default options (default: get_default_options)
 
     Returns
     -------
-    a function replacing and un-specified arguments with the defaults defined in config.ini
+    :return: a function replacing and un-specified arguments with the defaults defined in config.ini
     """
+
+    if defaults is None:
+        defaults = get_default_options()
+
     def get_name(func):
         if hasattr(func, '__name__'):
             return func.__name__
@@ -92,11 +102,11 @@ def get_name(func):
 
     name = get_name(f)
     if name in defaults.keys():
-        default_kwargs = {k: v for k, v in dict(defaults[name]).items() if k[:2] != '__'}
+        default_kwargs = {k: eval(v) for k, v in dict(defaults[name]).items() if k[:2] != '__'}
     else:
         default_kwargs = {}
 
-    default_args = [v for k, v in dict(defaults[name]).items() if k[:2] == '__']
+    default_args = [eval(v) for k, v in dict(defaults[name]).items() if k[:2] == '__']
 
     @functools.wraps(f)
     def wrapped_function(*args, **kwargs):
diff --git a/datawrangler/decorate/decorate.py b/datawrangler/decorate/decorate.py
index 20f6bea..8b082b8 100644
--- a/datawrangler/decorate/decorate.py
+++ b/datawrangler/decorate/decorate.py
@@ -19,7 +19,7 @@
 
 
 defaults = get_default_options()
-format_checkers = defaults['supported_formats']['types']
+format_checkers = eval(defaults['supported_formats']['types'])
 
 
 # import all model-like classes within a sklearn-like module; return a list of model names
@@ -31,11 +31,11 @@ def import_sklearn_models(module):
 
     Parameters
     ----------
-    module: a Python module object (e.g. sklearn.decomposition)
+    :param module: a Python module object (e.g. sklearn.decomposition)
 
     Returns
     -------
-    a list of valid models contained in the module
+    :return: a list of valid models contained in the module
     """
     models = [d for d in dir(module) if hasattr(getattr(module, d), 'fit_transform')]
     for m in models:
@@ -49,7 +49,7 @@ def get_sklearn_model(x):
 
     Parameters
     ----------
-    x: a callable scikit-learn model, a string containing a scikit-learn model's name (e.g.,
+    :param x: a callable scikit-learn model, a string containing a scikit-learn model's name (e.g.,
     'LatentDirichletAllocation'), or a dictionary with the following keys:
       - 'model': a callable scikit-learn model or a string containing a scikit-learn model's name
       - 'args': a list of arguments to pass to the model (this list will be pre-pended with the data the model is
@@ -58,7 +58,7 @@ def get_sklearn_model(x):
 
     Returns
     -------
-    A callable scikit-learn model
+    :return: A callable scikit-learn model
     """
     if is_sklearn_model(x):
         return x  # already a valid model
@@ -83,19 +83,19 @@ def apply_sklearn_model(model, data, *args, mode='fit_transform', return_model=F
 
     Parameters
     ----------
-    model: a scikit-learn model (as defined in the *get_sklearn_model* description), or a list of models to be applied
+    :param model: a scikit-learn model (as defined in the *get_sklearn_model* description), or a list of models to be applied
            in sequence
-    data: a dataset (array or DataFrame)
-    args: other arguments to pass to the model (after data)
-    mode: one of 'fit', 'transform', or 'fit_transform' (default: 'fit_transform'); uses scikit-learn syntax
-    return_model: if True, both the (potentially transformed) data *and* the fitted model (or list of fitted models)
+    :param data: a dataset (array or DataFrame)
+    :param args: other arguments to pass to the model (after data)
+    :param mode: one of 'fit', 'transform', or 'fit_transform' (default: 'fit_transform'); uses scikit-learn syntax
+    :param return_model: if True, both the (potentially transformed) data *and* the fitted model (or list of fitted models)
           are returned.  If False, only the (potentially transformed) data is returned.  Default: False
-    kwargs: other keyword arguments to pass to *all* of the scikit-learn models (in addition to any model-specific
+    :param kwargs: other keyword arguments to pass to *all* of the scikit-learn models (in addition to any model-specific
           keyword arguments)
 
     Returns
     -------
-    Either the (potentially transformed) dataset (if return_model == False) or a tuple containing the
+    :return: Either the (potentially transformed) dataset (if return_model == False) or a tuple containing the
     transformed dataset (first element) and the fitted model(s) (second element), if return_model == True.
     """
     assert mode in ['fit', 'transform', 'fit_transform']
@@ -151,11 +151,11 @@ def list_generalizer(f):
 
     Parameters
     ----------
-    f: the function to decorate, of the form f(data, *args, **kwargs).
+    :param f: the function to decorate, of the form f(data, *args, **kwargs).
 
     Returns
     -------
-    A decorated function that supports lists of data objects (rather than only non-list data objects)
+    :return: A decorated function that supports lists of data objects (rather than only non-list data objects)
     """
     @functools.wraps(f)
     def wrapped(data, *args, **kwargs):
@@ -173,12 +173,12 @@ def funnel(f):
 
     Parameters
     ----------
-    f: a function of the form f(data, *args, **kwargs) that assumes data is either a DataFrame or a list of
+    :param f: a function of the form f(data, *args, **kwargs) that assumes data is either a DataFrame or a list of
        DataFrames
 
     Returns
     -------
-    A decorated function the supports any wrangle-able data format
+    :return: A decorated function the supports any wrangle-able data format
     """
     @functools.wraps(f)
     def wrapped(data, *args, **kwargs):
@@ -194,15 +194,16 @@ def wrapped(data, *args, **kwargs):
 def interpolate(f):
     """
     A decorator that fills in missing data by imputing and/or interpolating missing values
+
     Parameters
     ----------
-    f: a function of the form f(data, *args, **kwargs) that assumes the data are formatted as either a DataFrame or
+    :param f: a function of the form f(data, *args, **kwargs) that assumes the data are formatted as either a DataFrame or
        a list of DataFrames, with no missing (numpy.nan) values
 
     Returns
     -------
-    A decorated function that supports any wrangle-able datatype.  Pass in the following keyword arguments to fill in
-    missing data:
+    :return: A decorated function that supports any wrangle-able datatype.  Pass in the following keyword arguments to
+    fill in missing data:
       impute_kwargs: a dictionary containing one or more scikit-learn imputation models (e.g.,
           {'model': 'IterativeImputer'}.  The 'model' can be specified as defined in the *apply_sklearn_model* function.
       any other keywords are passed to pandas.DataFrame.interpolate; e.g. method='linear' will apply linear
@@ -215,14 +216,14 @@ def fill_missing(data, return_model=False, **kwargs):
         impute_kwargs = kwargs.pop('impute_kwargs', {})
 
         if impute_kwargs:
-            model = impute_kwargs.pop('model', defaults['impute']['model'])
+            model = impute_kwargs.pop('model', eval(defaults['impute']['model']))
             imputed_data, model = apply_sklearn_model(model, data, return_model=True, **impute_kwargs)
             data = pd.DataFrame(data=imputed_data, index=data.index, columns=data.columns)
         else:
             model = None
 
         if kwargs:
-            kwargs = update_dict(defaults['interpolate'], kwargs)
+            kwargs = update_dict(defaults['interpolate'], kwargs, from_config=True)
             data = data.interpolate(**kwargs)
 
         if return_model:
@@ -238,7 +239,7 @@ def wrapped(data, *args, **kwargs):
     return wrapped
 
 
-@funnel
+# noinspection PyIncorrectDocstring
 def pandas_stack(data, names=None, keys=None, verify_integrity=False, sort=False, copy=True, ignore_index=False,
                  levels=None):
     """
@@ -248,15 +249,28 @@ def pandas_stack(data, names=None, keys=None, verify_integrity=False, sort=False
     DataFrames are stacked vertically, with the data names as their level 1
     indices and their original indices as their level 2 indices.
 
-    INPUTS
-    data: data in any format supported by datawrangler
-
-    Also takes all keyword arguments from pandas.concat except axis, join, join_axes
-
-    All other keyword arguments (if any) are passed to funnel
+    Parameters
+    ----------
+    :param data: A single DataFrame or a list of DataFrames with must matching columns.
+    :param names: names for the levels in the resulting hierarchical index. (Default: None)
+    :param keys: if multiple levels passed, should contain tuples. Construct hierarchical index using the passed keys as
+      the outermost level.
+    :param verify_integrity: check whether the new concatenated axis contains duplicates. This can be very expensive
+      relative to the actual data concatenation.  (Default: False)
+    :param sort: sort non-concatenation axis if it is not already aligned when join is ‘outer’. This has no effect when
+      join='inner', which already preserves the order of the non-concatenation axis.  (Default: False)
+    :param copy: if False, do not copy data unnecessarily.  (Default: True)
+    :param ignore_index: if True, do not use the index values along the concatenation axis. The resulting axis will be
+      labeled 0, …, n - 1. This is useful if you are concatenating objects where the concatenation axis does not have
+      meaningful indexing information. Note the index values on the other axes are still respected in the join.
+      (Default: False)
+    :param levels: specific levels (unique values) to use for constructing a MultiIndex. Otherwise they will be inferred
+      from the keys. (Default: None)
+    :param kwargs: any other keyword arguments will be passed to datawrangler.decorate.funnel
 
-    OUTPUTS
-    a single MultiIndex DataFrame
+    Returns
+    -------
+    :return: a single MultiIndex DataFrame
     """
 
     if is_multiindex_dataframe(data):
@@ -266,6 +280,9 @@ def pandas_stack(data, names=None, keys=None, verify_integrity=False, sort=False
     elif len(data) == 0:
         return None
 
+    # ensure that Series objects are cast into DataFrames
+    data = [pd.DataFrame(d) for d in data]
+
     assert len(np.unique([d.shape[1] for d in data])) == 1, 'All DataFrames must have the same number of columns'
     for i, d1 in enumerate(data):
         template = d1.columns.values
@@ -294,15 +311,19 @@ def pandas_unstack(x):
 
     Parameters
     ----------
-    x: a single DataFrame or MultiIndex DataFrame
+    :param x: a single DataFrame, a MultiIndex DataFrame, or a list of DataFrames
 
     Returns
     -------
-    A list of one or more DataFrames
+    :return: a list of one or more DataFrames
     """
     if not is_multiindex_dataframe(x):
         if is_dataframe(x):
             return x
+        elif issubclass(type(x), pd.Series):
+            return pd.DataFrame(x).T
+        elif type(x) is list and all([is_dataframe(d) for d in x]):
+            return x
         else:
             raise Exception(f'Unsupported datatype: {type(x)}')
 
@@ -321,7 +342,17 @@ def pandas_unstack(x):
     assert names[0] == grouper, 'Unstacking error'
 
     x.index.rename(names, inplace=True)
-    return [d[1].set_index(d[1].index.get_level_values(1)) for d in list(x.groupby(grouper))]
+
+    groups = list(x.groupby(grouper))
+    n_levels = len(groups[0][1].index.levels)
+    if n_levels > 2:
+        g = groups[0][1]
+        index = pd.MultiIndex.from_arrays([g.index.get_level_values(len(g.index.levels) - n)
+                                           for n in range(1, len(g.index.levels))][::-1])
+        return [d[1].set_index(index) for d in groups]
+    else:
+        return [d[1].set_index(d[1].index.get_level_values(len(d[1].index.levels) - 1))
+                for d in list(x.groupby(grouper))]
 
 
 def apply_stacked(f):
@@ -336,25 +367,45 @@ def apply_stacked(f):
 
     Parameters
     ----------
-    f: a function of the form f(data, *args, **kwargs) that assumes data is a single DataFrame, and that returns a
+    :param f: a function of the form f(data, *args, **kwargs) that assumes data is a single DataFrame, and that returns a
        single DataFrame as output.
 
     Returns
     -------
-    A decorated function that supports any wrangle-able data types, applies the original function to the full
+    :return: a decorated function that supports any wrangle-able data types, applies the original function to the full
     list of datasets simultaneously, and then returns the result(s) as a new DataFrame or list of DataFrames.
     """
 
     @funnel
     def wrapped(data, *args, **kwargs):
+        def helper(d, x, split):
+            if split:
+                x0 = x[0]
+                x1 = x[1]
+            else:
+                x0 = x
+
+            if is_dataframe(d) and type(x0) is list and len(x0) == 1:
+                x0 = x0[0]
+
+            if split:
+                return x0, x1
+            else:
+                return x0
+
         stack_result = is_multiindex_dataframe(data)
 
         stacked_data = pandas_stack(data)
         transformed = f(stacked_data, *args, **kwargs)
 
-        if (not stack_result) and (('return_model' in kwargs.keys()) and kwargs['return_model']):
-            transformed[0] = pandas_unstack(transformed[0])
-        return transformed
+        return_model = kwargs.copy().pop('return_model', False)
+        if not stack_result:
+            if ('return_model' in kwargs.keys()) and kwargs['return_model']:
+                transformed[0] = pandas_unstack(transformed[0])
+            else:
+                transformed = pandas_unstack(transformed)
+
+        return helper(data, transformed, return_model)
 
     return wrapped
 
@@ -370,12 +421,12 @@ def apply_unstacked(f):
 
     Parameters
     ----------
-    f: a function of the form f(data, *args, **kwargs) that assumes data is a single DataFrame, and that returns a
-       single DataFrame as output.
+    :param f: a function of the form f(data, *args, **kwargs) that assumes data is a single DataFrame, and that returns
+      a single DataFrame as output.
 
     Returns
     -------
-    A decorated function that supports any wrangle-able data types, applies the original function to the full
+    :return: A decorated function that supports any wrangle-able data types, applies the original function to the full
     list of datasets separately, and then returns the result(s) as a new DataFrame or list of DataFrames.
     """
 
diff --git a/datawrangler/io/extension_handler.py b/datawrangler/io/extension_handler.py
index 7de49cd..889f26c 100644
--- a/datawrangler/io/extension_handler.py
+++ b/datawrangler/io/extension_handler.py
@@ -7,11 +7,11 @@ def get_extension(fname):
 
     Parameters
     ----------
-    fname: the filename, represented as a string
+    :param fname: the filename, represented as a string
 
     Returns
     -------
-    The extension, represented as a lowercase string.
+    :return: The extension, represented as a lowercase string.
     """
     _, f = os.path.split(fname)
     if '.' in f:
diff --git a/datawrangler/io/io.py b/datawrangler/io/io.py
index b398aa1..0ca95af 100644
--- a/datawrangler/io/io.py
+++ b/datawrangler/io/io.py
@@ -1,6 +1,7 @@
 import os
 import requests
 import dill
+import re
 import numpy as np
 from hashlib import blake2b as hasher
 from matplotlib import pyplot as plt
@@ -10,7 +11,7 @@
 from .extension_handler import get_extension
 
 defaults = get_default_options()
-img_types = plt.gcf().canvas.get_supported_filetypes().keys();
+img_types = ['eps', 'jpg', 'jpeg', 'pdf', 'pgf', 'png', 'ps', 'raw', 'rgba', 'svg', 'svgz', 'tif', 'tiff']
 
 
 def get_local_fname(x, digest_size=10):
@@ -19,19 +20,19 @@ def get_local_fname(x, digest_size=10):
 
     Parameters
     ----------
-    x: a string containing some data
-    digest_size: length of the hash to compute (default: 10)
+    :param x: a string containing some data
+    :param digest_size: length of the hash to compute (default: 10)
 
     Returns
     -------
-    The absolute path of the location where the given information should be stored.
+    :return: The absolute path of the location where the given information should be stored.
     """
     if os.path.exists(x):
         return x
 
     h = hasher(digest_size=digest_size)
     h.update(x.encode('ascii'))
-    return os.path.join(defaults['data']['datadir'], h.hexdigest() + '.' + get_extension(x))
+    return os.path.join(eval(defaults['data']['datadir']), h.hexdigest() + '.' + get_extension(x))
 
 
 def get_confirm_token(response):
@@ -41,11 +42,10 @@ def get_confirm_token(response):
     return None
 
 
-def load_remote(url, params=None):
-    if params is None:
-        params = {}
+def load_remote(url):
     session = requests.Session()
-    response = session.get(url, params=params, stream=True)
+    response = session.get(url, stream=True)
+
     token = get_confirm_token(response)
     if token:
         params['confirm'] = token
@@ -57,16 +57,14 @@ def load_remote(url, params=None):
         return response.content
 
 
-def load(x, base_url='https://docs.google.com/uc?export=download', dtype=None, **kwargs):
+def load(x, dtype=None, **kwargs):
     """
     Load local or remote files in a wide range of formats
 
     Parameters
     ----------
-    x: a string containing a URL, document ID (e.g., a Google object's ID), or file path
-    base_url: a template URL used to download objects specified using only their ID.
-      Default: 'https://docs.google.com/uc?export=download' (supports Google IDs)
-    dtype: Optional argument for specifying how the data should be loaded; can be one of:
+    :param x: a string containing a URL or file path
+    :param dtype: Optional argument for specifying how the data should be loaded; can be one of:
       - 'pickle': use the dill library to load in pickled objects and functions
       - 'numpy': treat the dataset as a .npy or .npz file
       - None (default): attempt to determine the filetype automatically based on the URL or file extension.  The
@@ -76,18 +74,18 @@ def load(x, base_url='https://docs.google.com/uc?export=download', dtype=None, *
             https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html
           - any image filetype supported by the Matplotlib library; for a full list see:
             matplotlib.pyplot.gcf().canvas.get_supported_filetypes()
-    kwargs: any additional keyword arguments are passed to whatever function is selected to load in the dataset.  For
-      example, when loading in a csv file (a Pandas-compatible format), passing the keyword argument index_col=0 will
-      tell Pandas to interpret the first (0) column as the resulting DataFrame's index when loading the file's contents
-      into a DataFrame.
+    :param kwargs: any additional keyword arguments are passed to whatever function is selected to load in the dataset.
+      For example, when loading in a csv file (a Pandas-compatible format), passing the keyword argument index_col=0
+      will tell Pandas to interpret the first (0) column as the resulting DataFrame's index when loading the file's
+      contents into a DataFrame.
 
     Returns
     -------
-    The retrieved data.  Remote files will be cached (saved) locally to disk for faster loading if/when the same
-    address or ID is used to load the file again at a later time.
+    :return: the retrieved data.  Remote files will be cached (saved) locally to disk for faster loading if/when the
+    same address is used to load the file again at a later time.
     """
     # noinspection PyShadowingNames
-    def helper(fname, **helper_kwargs):
+    def helper(fname, dtype=None, **helper_kwargs):
         if dtype == 'pickle':
             with open(fname, 'rb') as f:
                 return dill.load(f, **helper_kwargs)
@@ -95,40 +93,44 @@ def helper(fname, **helper_kwargs):
             if 'allow_pickle' not in helper_kwargs.keys():
                 helper_kwargs['allow_pickle'] = True
             data = np.load(fname, **helper_kwargs)
-            if type(data) is dict:
-                if len(data.keys()) == 1:
-                    return data[list(data.keys())[0]]
-            return data
+            try:
+                if type(data) is dict:
+                    if len(data.keys()) == 1:
+                        return data[list(data.keys())[0]]
+                return data
+            except Exception:
+                if isinstance(data, np.lib.npyio.NpzFile):
+                    data.close()
+                raise
         else:
-            ext = get_extension(fname)
-            if ext == 'txt':
+            dtype = get_extension(fname)
+            if dtype == 'txt':
                 with open(fname, 'r') as f:
                     return ''.join(f.readlines())
-            elif ext in ['csv', 'xls', 'xlsx', 'json', 'html', 'xml', 'hdf', 'feather', 'parquet', 'orc', 'sas',
-                         'spss', 'sql', 'gbq', 'stata', 'pkl']:
-                return load_dataframe(fname)
-            elif ext in ['npy', 'npz']:
+            elif dtype in ['csv', 'xls', 'xlsx', 'json', 'html', 'xml', 'hdf', 'feather', 'parquet', 'orc', 'sas',
+                           'spss', 'sql', 'gbq', 'stata', 'pkl']:
+                return load_dataframe(fname, **kwargs)
+            elif dtype in ['npy', 'npz']:
                 return np.load(fname)
-            elif ext in img_types:
+            elif dtype in img_types:
                 return plt.imread(fname)
             else:
                 raise ValueError(f'Unknown datatype: {dtype}')
 
     assert type(x) is str, IOError('cannot interpret non-string filename')
-    fname = get_local_fname(x)
-    if os.path.exists(fname):
-        return helper(fname, **kwargs)
-    else:
-        if x.startswith('http'):
-            data = load_remote(x)
+    if os.path.exists(x):
+        return helper(x, dtype=dtype, **kwargs)
+
+    local_fname = get_local_fname(x)
+    if x.startswith('http'):
+        if os.path.exists(local_fname):
+            return helper(local_fname, dtype=dtype, **kwargs)
         else:
-            # noinspection PyBroadException
-            try:     # is x a Google ID?
-                data = load_remote(base_url, params={'id': x})
-            except:
-                raise IOError('cannot find data at source: {x}')
-        save(x, data, dtype=dtype)
-        return load(x, dtype=dtype, **kwargs)
+            data = load_remote(x)
+    else:
+        return None
+    save(x, data, dtype=dtype)
+    return load(x, dtype=dtype, **kwargs)
 
 
 def save(x, obj, dtype=None, **kwargs):
@@ -137,19 +139,19 @@ def save(x, obj, dtype=None, **kwargs):
 
     Parameters
     ----------
-    x: the file's original path, URL, or ID (used to create a hash to define a new filename)
-    obj: the data to store to disk
-    dtype: optional argument specifying how to store the data; can be one of:
+    :param x: the file's original path or URL (used to create a hash to define a new filename)
+    :param obj: the data to store to disk
+    :param dtype: optional argument specifying how to store the data; can be one of:
       - 'pickle': use the dill library to pickle the object
       - 'numpy': save the objects as a compressed (.npz-formatted) numpy file
       - None (default): determine the filetype automatically; if x is passed in as bytes, write x directly to disk. If
         x is a string, treat x as text.
-    kwargs: any additional keyword arguments are passed to dill.dump (if dtype == 'pickle') or numpy.savez (if
+    :param kwargs: any additional keyword arguments are passed to dill.dump (if dtype == 'pickle') or numpy.savez (if
         dtype == 'numpy').  For any other datatype, additional keyword arguments are ignored.
 
     Returns
     -------
-    None.
+    :return: None
     """
     assert type(x) is str, IOError('cannot interpret non-string filename')
     fname = get_local_fname(x)
diff --git a/datawrangler/io/panda_handler.py b/datawrangler/io/panda_handler.py
index 469654d..26f1edf 100644
--- a/datawrangler/io/panda_handler.py
+++ b/datawrangler/io/panda_handler.py
@@ -11,18 +11,18 @@ def load_dataframe(x, extension=None, debug=False, **kwargs):
 
     Parameters
     ----------
-    x: a string (filename or URL) or DataFrame
-    extension: optional argument for specifying the filetype (e.g., 'csv', 'xls', etc.).  If no extension is specified,
+    :param x: a string (filename or URL) or DataFrame
+    :param extension: optional argument for specifying the filetype (e.g., 'csv', 'xls', etc.).  If no extension is specified,
       by default the extension will be inferred automatically from the filename.  The following data types are
       supported: https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html
-    debug: internal flag used for debugging (prints a warning message if filetype cannot be inferred automatically);
+    :param debug: internal flag used for debugging (prints a warning message if filetype cannot be inferred automatically);
       default: False.
-    kwargs: any additional keyword arguments are passed directly to the relevant Pandas function for reading in the
+    :param kwargs: any additional keyword arguments are passed directly to the relevant Pandas function for reading in the
       inferred data type.
 
     Returns
     -------
-    A DataFrame containing the file's contents
+    :return: a DataFrame containing the file's contents
     """
     if type(x) in six.string_types:
         if extension is None:
diff --git a/datawrangler/util/helpers.py b/datawrangler/util/helpers.py
index 6924504..7e004bd 100644
--- a/datawrangler/util/helpers.py
+++ b/datawrangler/util/helpers.py
@@ -11,16 +11,17 @@
 
 def btwn(x, a, b):
     """
-    Return True if and only if the values in the given Array are between the given bounds (inclusive)
+    Test whether the values of an array (or scalar) are between the given bounds (inclusive)
 
     Parameters
     ----------
-    x: a numeric scalar or Array
-    a: lower bound-- a numeric scalar or an Array of the same shape as x
-    b: upper bound-- a numeric scalar or an Array of the same shape as x
+    :param x: a numeric scalar or Array
+    :param a: lower bound-- a numeric scalar or an Array of the same shape as x
+    :param b: upper bound-- a numeric scalar or an Array of the same shape as x
 
     Returns
     -------
+    :return: True if the values in the given Array are between the given bounds (inclusive), and False otherwise.
 
     """
     assert np.isscalar(a), ValueError(f'lower limit must be scalar (given: {type(a)}')
@@ -29,7 +30,7 @@ def btwn(x, a, b):
     if b < a:
         return btwn(x, b, a)
 
-    return np.all(x >= a) and np.all(b <= b)
+    return np.all(x >= a) and np.all(x <= b)
 
 
 def dataframe_like(x, debug=False):
@@ -38,12 +39,12 @@ def dataframe_like(x, debug=False):
 
     Parameters
     ----------
-    x: the object
-    debug: internal flag (default: False) that prints out why an object is *not* dataframe like
+    :param x: the object
+    :param debug: internal flag (default: False) that prints out why an object is *not* dataframe like
 
     Returns
     -------
-    True (if the object can be treated like a DataFrame) or False otherwise
+    :return: True (if the object can be treated like a DataFrame) or False otherwise
     """
     required_attributes = ['values', 'index', 'columns', 'shape', 'stack', 'unstack', 'loc', 'iloc', 'size', 'copy',
                            'head', 'tail', 'items', 'iteritems', 'keys', 'iterrows', 'itertuples',
@@ -66,16 +67,20 @@ def array_like(x, force_literal=False):
 
     Parameters
     ----------
-    x: the object
-    force_literal: specify whether strings should be interpreted strictly (if force_literal == True) or whether they
-      may refer to files, URLs, or Google IDs (if force_literal == False).  Default: False
+    :param x: the object
+    :param force_literal: specify whether strings should be interpreted strictly (if force_literal == True) or whether
+      they may refer to files or URLs (if force_literal == False).  Default: False
 
     Returns
     -------
-    True (if the object can be treated like an Array) or False otherwise
+    :return: True (if the object can be treated like an Array) or False otherwise
     """
-    if (type(x) is str) and (not force_literal) and os.path.exists(x):
-        return array_like(load(x), force_literal=True)
+    if type(x) is str:
+        if force_literal:
+            return False
+        else:
+            return array_like(load(x), force_literal=True)
+
     return is_array(x) or dataframe_like(x) or (type(x) in [list, np.array, np.ndarray, pd.Series, pd.DataFrame])
 
 
@@ -85,11 +90,11 @@ def depth(x):
 
     Parameters
     ----------
-    x: an array-like object
+    :param x: an array-like object
 
     Returns
     -------
-    The depth of the object
+    :return: The depth of the object
     """
     if array_like(x):
         if np.isscalar(x) or (len(x) == 0):
diff --git a/datawrangler/zoo/__init__.py b/datawrangler/zoo/__init__.py
index 7fa3952..1758fb1 100644
--- a/datawrangler/zoo/__init__.py
+++ b/datawrangler/zoo/__init__.py
@@ -1,7 +1,6 @@
 from .format import wrangle
 from .array import is_array, wrangle_array
 from .dataframe import is_dataframe, wrangle_dataframe, is_multiindex_dataframe
-from .image import is_image, wrangle_image, get_image
 from .null import is_null, wrangle_null
 from .text import is_text, wrangle_text, get_corpus, apply_text_model, get_text_model, to_str_list, get_text
 from ..util.helpers import dataframe_like, array_like
diff --git a/datawrangler/zoo/array.py b/datawrangler/zoo/array.py
index 9d79f15..4e0c881 100644
--- a/datawrangler/zoo/array.py
+++ b/datawrangler/zoo/array.py
@@ -12,11 +12,11 @@ def is_number(x):
 
     Parameters
     ----------
-    x: the object to test
+    :param x: the object to test
 
     Returns
     -------
-    True of x is a real or complex scalar and False otherwise
+    :return: True of x is a real or complex scalar and False otherwise
     """
     if np.isscalar(x):
         return np.isreal(x) or np.iscomplex(x)  # exclude single characters (non-numeric)
@@ -31,11 +31,11 @@ def is_array(x):
 
     Parameters
     ----------
-    x: an object, file path, URL, or Google ID
+    :param x: an object, file path or URL
 
     Returns
     -------
-    Whether (or not) x is an array (or if it points to an array)
+    :return: whether (or not) x is an array (or if it points to an array)
     """
     if (not ('str' in str(type(x)))) and (type(x).__module__ == 'numpy'):
         return True
@@ -59,10 +59,10 @@ def wrangle_array(data, return_model=False, **kwargs):
 
     Parameters
     ----------
-    data: an Array (or path to an Array)
-    return_model: if True, return a function for casting an Array into a DataFrame (along with the resulting DataFrame).
-       Default: False
-    kwargs: a list of keyword arguments:
+    :param data: an Array (or path to an Array)
+    :param return_model: if True, return a function for casting an Array into a DataFrame (along with the resulting
+      DataFrame).  Default: False
+    :param kwargs: a list of keyword arguments:
        - 'model': a callable function or constructor, or a dictionary containing the following keys:
          - 'model': a callable function or constructor
          - 'args': a list of arguments to pass to the function (in addition to data)
@@ -74,7 +74,7 @@ def wrangle_array(data, return_model=False, **kwargs):
 
     Returns
     -------
-    The resulting DataFrame
+    :return: The resulting DataFrame
     """
     def stacker(x):
         while x.ndim >= 3:
diff --git a/datawrangler/zoo/dataframe.py b/datawrangler/zoo/dataframe.py
index a4ead66..39aac23 100644
--- a/datawrangler/zoo/dataframe.py
+++ b/datawrangler/zoo/dataframe.py
@@ -10,13 +10,11 @@ def is_dataframe(x):
 
     Parameters
     ----------
-
-    x: the object (or a file path)
+    :param x: the object (or a file path)
 
     Returns
     -------
-
-    Return True if the object is a DataFrame (or points to a file that can be loaded into Pandas as a DataFrame), and
+    :return: True if the object is a DataFrame (or points to a file that can be loaded into Pandas as a DataFrame), and
     False otherwise.
     """
     if type(x).__module__ in ['pandas.core.frame', 'modin.pandas.dataframe']:
@@ -39,12 +37,11 @@ def is_multiindex_dataframe(x):
 
     Parameters
     ----------
-    x: the object (or file path)
+    :param x: the object (or file path)
 
     Returns
     -------
-
-    Return True if the object is a MultiIndex DataFrame (or points to a file that can be loaded into Pandas as a
+    :return: True if the object is a MultiIndex DataFrame (or points to a file that can be loaded into Pandas as a
     MultiIndex DataFrame), and False otherwise.
     """
     return is_dataframe(x) and ('indexes.multi' in type(x.index).__module__)
@@ -56,17 +53,16 @@ def wrangle_dataframe(data, return_model=False, **kwargs):
 
     Parameters
     ----------
-    data: a DataFrame, dataframe-like object, or a file path that points to a file that can be loaded into Pandas as a
+    :param data: a DataFrame, dataframe-like object, or a file path that points to a file that can be loaded into Pandas as a
       DataFrame
-    return_model: if True, return a function for turning the ("messy") DataFrame into a "clean" DataFrame, along with
+    :param return_model: if True, return a function for turning the ("messy") DataFrame into a "clean" DataFrame, along with
       the cleaned DataFrame.  Otherwise (if False), just return the cleaned DataFrame.  Default: False
-    kwargs: passed to the DataFrame "wrangling" model (default: the constructor for pd.DataFrame)
+    :param kwargs: passed to the DataFrame "wrangling" model (default: the constructor for pd.DataFrame)
 
     Returns
     -------
-
-    The "wrangled" DataFrame (if return_model is False), or the DataFrame plus a "model" for cleaning DataFrames (if
-    return_model is True).
+    :return: The "wrangled" DataFrame (if return_model is False), or the DataFrame plus a "model" for cleaning
+      DataFrames (if return_model is True).
     """
     load_kwargs = kwargs.pop('load_kwargs', {})
 
diff --git a/datawrangler/zoo/format.py b/datawrangler/zoo/format.py
index 5daed4c..141d113 100644
--- a/datawrangler/zoo/format.py
+++ b/datawrangler/zoo/format.py
@@ -4,7 +4,6 @@
 
 from .dataframe import is_dataframe, is_multiindex_dataframe, wrangle_dataframe
 from .array import is_array, wrangle_array
-from .image import is_image, wrangle_image
 from .text import is_text, wrangle_text
 from .null import is_null, wrangle_null
 from ..util import array_like, depth
@@ -12,7 +11,7 @@
 
 # the order matters: if earlier checks pass, later checks will not run.
 # the list specifies the priority of converting to the given data types.
-format_checkers = get_default_options()['supported_formats']['types']
+format_checkers = eval(get_default_options()['supported_formats']['types'])
 
 
 def wrangle(x, return_dtype=False, **kwargs):
@@ -21,17 +20,16 @@ def wrangle(x, return_dtype=False, **kwargs):
 
     Parameters
     ----------
-
-    x: data in any format (text, numpy arrays, pandas dataframes, or a mixed list (or nested lists) of those types).
-      The following datatypes are supported:
+    :param x: data in any format (text, numpy arrays, pandas dataframes, or a mixed list (or nested lists) of those
+      types).  The following datatypes are supported:
         - Numpy Arrays, array-like objects, or paths to files that store array-like objects
         - Pandas DataFrames, dataframe-like objects, or paths to files that store dataframe-like objects
         - Images, or paths to files that store images
         - Text, or paths to plain text files
         - Mixed lists of the above
-    return_dtype: if True, also return the auto-detected datatype(s) of each dataset you wrangle
-    kwargs: used to control how data are wrangled (e.g., if you don't want to use the default options for each data
-      type):
+    :param return_dtype: if True, also return the auto-detected datatype(s) of each dataset you wrangle
+    :param kwargs: used to control how data are wrangled (e.g., if you don't want to use the default options for each
+      data type):
         - array_kwargs: passed to the datawrangler.zoo.array.wrangle_array function to control how arrays are handled
         - dataframe_kwargs: passed to the datawrangler.zoo.dataframe.wrangle_dataframe function to control how
           dataframes are handled
@@ -41,8 +39,7 @@ def wrangle(x, return_dtype=False, **kwargs):
 
     Returns
     -------
-
-    A DataFrame, or a list of DataFrames, containing the wrangled data
+    :return: a DataFrame, or a list of DataFrames, containing the wrangled data
     """
 
     deep_kwargs = {}
@@ -69,6 +66,9 @@ def to_dataframe(y):
                     deep_kwargs[fc]['model'] = model
                     deep_kwargs[fc]['return_model'] = return_model
                     pre_fit[fc] = True
+
+                    if return_model:
+                        wrangled = [wrangled, model]
                 else:
                     wrangled = wrangler(y, **deep_kwargs[fc])
                 dtype = fc
diff --git a/datawrangler/zoo/image.py b/datawrangler/zoo/image.py
deleted file mode 100644
index 7d5362b..0000000
--- a/datawrangler/zoo/image.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import PIL
-import six
-import os
-import numpy as np
-from matplotlib import pyplot as plt
-
-from .array import wrangle_array
-from ..util import array_like, btwn
-
-
-def get_image(img):
-    def valid_image_values(x):
-        if not hasattr(x, 'dtype'):
-            return False
-
-        dtype = str(x.dtype)
-        if 'int' in dtype:
-            return btwn(x, 0, 255)
-        elif 'float' in dtype:
-            return btwn(x, 0.0, 1.0)
-        else:
-            return False
-
-    if (type(img) in six.string_types) and os.path.exists(img):
-        try:
-            return plt.imread(img)  # also handles remote images
-        except PIL.UnidentifiedImageError:
-            return None
-
-    if array_like(img):
-        if valid_image_values(img):
-            if img.ndim == 1:
-                return img
-            elif img.ndim == 3 and img.shape[2] in [3, 4]:
-                return img
-    return None
-
-
-# noinspection PyUnusedLocal
-def is_image(data):
-    img = get_image(data)
-    return img is not None
-
-
-# noinspection PyUnusedLocal
-def wrangle_image(data, **kwargs):
-    img = get_image(data)
-
-    if img is not None:
-        return wrangle_array(img, **kwargs)
diff --git a/datawrangler/zoo/null.py b/datawrangler/zoo/null.py
index dcb45d1..cd3ead5 100644
--- a/datawrangler/zoo/null.py
+++ b/datawrangler/zoo/null.py
@@ -3,6 +3,18 @@
 
 
 def is_null(data):
+    """
+    Test whether an object is None or empty.
+
+    Parameters
+    ----------
+    :param data: the to-be-tested object
+
+    Returns
+    -------
+    :return: True if the object is None or empty and False otherwise.
+
+    """
     # noinspection PyBroadException
     try:
         if np.iterable(data):
@@ -12,12 +24,30 @@ def is_null(data):
         return False
 
 
-def wrangle_null(data, return_model=False, **kwargs):
-    x = pd.DataFrame()
+def wrangle_null(data, return_model=False, model=pd.DataFrame):
+    """
+    Turn a null object (None or empty) into an empty DataFrame.
+
+    Parameters
+    ----------
+    :param data: the to-be-wrangled null object
+    :param return_model: if True, return a model (and its arguments and keyword arguments) for turning the null object
+      into a DataFrame.
+    :param model: a function or constructor that will generate an empty DataFrame.  This can also be specified as a
+      dictionary with the following fields:
+        - 'model': a function or constructor
+        - 'args': a list of unnamed arguments to be passed to the given function or constructor
+        - 'kwargs': a dictionary of named arguments to be passed to the given function or constructor
+
+    Returns
+    -------
+    :return: an empty DataFrame
+    """
 
-    model = kwargs.pop('model', pd.DataFrame)
     if type(model) is not dict:
-        model = {'model': model, 'args': [], 'kwargs': kwargs}
+        model = {'model': model, 'args': [], 'kwargs': {}}
+
+    x = model['model'](*model['args'], **model['kwargs'])
 
     if return_model:
         return x, model
diff --git a/datawrangler/zoo/text.py b/datawrangler/zoo/text.py
index 81c4be2..71c400d 100644
--- a/datawrangler/zoo/text.py
+++ b/datawrangler/zoo/text.py
@@ -1,5 +1,6 @@
 import six
 import os
+import warnings
 import numpy as np
 from flair.data import Sentence
 from flair.datasets import UD_ENGLISH
@@ -26,11 +27,11 @@ def is_sklearn_model(x):
 
     Parameters
     ----------
-    x: the object to test
+    :param x: the object to test
 
     Returns
     -------
-    True if x contains "transform", "fit", and "fit_transform" methods and False otherwise.
+    :return: True if x contains "transform", "fit", and "fit_transform" methods and False otherwise.
     """
     return hasattr(x, 'transform') and hasattr(x, 'fit') and hasattr(x, 'fit_transform')
 
@@ -41,11 +42,11 @@ def is_hugging_face_model(x):
 
     Parameters
     ----------
-    x: the object to test
+    :param x: the object to test
 
     Returns
     -------
-    True if x contains an "embed" method, and False otherwise.
+    :return: True if x contains an "embed" method, and False otherwise.
     """
     return hasattr(x, 'embed')
 
@@ -57,12 +58,12 @@ def robust_is_sklearn_model(x):
 
     Parameters
     ----------
-    x: a to-be-tested model object or a string
+    :param x: a to-be-tested model object or a string
 
     Returns
     -------
-    True if x (or the scikit-learn module x evaluates to) contains "transform", "fit", and "fit_transform" methods and
-    False otherwise.
+    :return: True if x (or the scikit-learn module x evaluates to) contains "transform", "fit", and "fit_transform"
+      methods and False otherwise.
     """
     x = get_text_model(x)
     return is_sklearn_model(x)
@@ -74,11 +75,11 @@ def robust_is_hugging_face_model(x):
     hugging-face model when checked with this function, because 'WordEmbeddings' is defined in the flair.embeddings
     module and contains an "embed" method.
     ----------
-    x: a to-be-tested model object or a string
+    :param x: a to-be-tested model object or a string
 
     Returns
     -------
-    True if x (or the hugging-face module x evaluates to) contains an "embed" method and False otherwise.
+    :return: True if x (or the hugging-face module x evaluates to) contains an "embed" method and False otherwise.
     """
     x = get_text_model(x)
     return is_hugging_face_model(x)
@@ -92,12 +93,13 @@ def get_text_model(x):
 
     Parameters
     ----------
-    x: an object to turn into a valid scikit-learn or hugging-face model (e.g., an already-valid model or a string)
+    :param x: an object to turn into a valid scikit-learn or hugging-face model (e.g., an already-valid model or a
+      string)
 
     Returns
     -------
-    A valid scikit-learn or hugging-face model (or None if no model matching the given description can be found)
-
+    :return: A valid scikit-learn or hugging-face model (or None if no model matching the given description can be
+      found)
     """
     if is_sklearn_model(x) or is_hugging_face_model(x):
         return x  # already a valid model
@@ -126,9 +128,9 @@ def get_corpus(dataset_name='wikipedia', config_name='20200501.en'):
     """
     Download (and return) a text corpus.  By default, a 2020 snapshot of all English Wikipedia articles is returned.
 
-    Parameters
-    ----------
-    dataset_name: a string containing the corpus name.  Can be one of the following:
+    [Parameters]
+    ------------
+    :param dataset_name: a string containing the corpus name.  Can be one of the following:
       - Corpora built into data-wrangler:
         - 'minipedia': a curated and cleaned up subset of Wikipedia containing articles on a wide variety of topics
         - 'neurips': a collection of NeurIPS articles
@@ -136,12 +138,12 @@ def get_corpus(dataset_name='wikipedia', config_name='20200501.en'):
         - 'khan': transcripts of (most) Khan Academy YouTube videos
       - Any hugging-face corpus; for a full list see https://huggingface.co/datasets
         Note that downloading hugging-face corpora also requires specifying a config_name
-    config_name: configuration name or description for hugging-face corpora.  This argument is ignored if dataset_name
-      is set to one of the data-wrangler corpora described above.
+    :param config_name: configuration name or description for hugging-face corpora.  This argument is ignored if dataset
+      name is set to one of the data-wrangler corpora described above.
 
     Returns
     -------
-    A list of number-of-documents strings, where each string contains the text of one document in the corpus.
+    :return: A list of number-of-documents strings, where each string contains the text of one document in the corpus.
     """
 
     key = f'{dataset_name}[{config_name}]'
@@ -153,18 +155,23 @@ def get_formatter(s):
 
     # built-in corpora
     corpora = {
-        'minipedia': '1mRNAZlTbZzSvV3tAQfSjNm587xdYKVkX',
-        'neurips': '1Qo61vh2P3Rpb9PM1lyXb5M2iw7uB03uY',
-        'sotus': '1uKJtxs-C0KDM2my0K6W2p0jCF6howg1y',
-        'khan': '1KPhKxQlQrZHSPlCgky7K2bsfHlvJK039'}
+        'minipedia': 'https://www.dropbox.com/s/eal65nd5a193pmk/minipedia.npz?dl=1',
+        'neurips': 'https://www.dropbox.com/s/i32dycxr0qa90wx/neurips.npz?dl=1',
+        'sotus': 'https://www.dropbox.com/s/e2qfw8tkmxp6bad/sotus.npz?dl=1',
+        'khan': 'https://www.dropbox.com/s/ieztnyhao2ejo48/khan.npz?dl=1'}
 
     if dataset_name in corpora.keys():
-        print(f'loading corpus: {dataset_name}', end='...')
-        corpus = load(corpora[dataset_name], dtype='numpy')['corpus']
-        print('done!')
-
-        preloaded_corpora[key] = corpus
-        return corpus
+        print(f'loading corpus: {dataset_name}', end='')
+        data = load(corpora[dataset_name], dtype='numpy')
+        try:
+            corpus = data['corpus']
+            print('...done!', end='')
+            preloaded_corpora[key] = corpus
+            return corpus
+        finally:
+            # ensure NpzFile is closed
+            data.close()
+        print('')
 
     # Hugging-Face Corpus
     try:
@@ -173,7 +180,7 @@ def get_formatter(s):
         raise RuntimeError(f'Corpus not found: {dataset_name}.  Available corpora: {", ".join(list_datasets())}')
     except ValueError:
         raise RuntimeError(f'Configuration for {dataset_name} corpus not found: {config_name}. '
-                           f'Available configurations: {", ".join(get_dataset_config_names(data_name))}')
+                           f'Available configurations: {", ".join(get_dataset_config_names(dataset_name))}')
 
     corpus = []
     content_keys = ['text', 'content']
@@ -189,6 +196,68 @@ def get_formatter(s):
 
 # noinspection PyShadowingNames
 def apply_text_model(x, text, *args, mode='fit_transform', return_model=False, **kwargs):
+    """
+    Apply a scikit-learn or hugging-face text embedding model to one or more text datasets.  Scikit-learn models are
+    trained on the specified corpus and then applied to all datasets.  All Hugging-Face models are pre-trained.
+
+    Parameters
+    ----------
+    :param x: the model to apply.  Supported models include:
+      - Scikit-learn models.  The recommended pipeline is to specify a feature extraction model (for turning text into
+        a number-of-documents by number-of-features matrix), and then to apply a matrix decomposition or embedding model
+        (for turning the features matrix into text embeddings).  When models are passed as a list, each model is applied
+        in succession to the output of the previous model.  The pipeline is first fit to the provided corpus, and then
+        applied to the given text.  Default: ['CountVectorizer', 'LatentDirichletAllocation']
+        - All scikit-learn text feature extraction models are supported; for a full list see
+            https://scikit-learn.org/stable/modules/classes.html#module-sklearn.feature_extraction.text
+            These may be passed either as callable modules (e.g., sklearn.feature_extraction.text.CountVectorizer) or
+            as strings (e.g., 'CountVectorizer').  Default options for each model are defined in config.ini.
+        - All scikit-learn matrix decomposition models are supported; for a full list see
+            https://scikit-learn.org/stable/modules/classes.html#module-sklearn.decomposition
+            These may be passed either as callable modules (e.g., sklearn.decomposition.NMF) or as strings (e.g.,
+            'NMF').  Default options for each model are defined in config.ini.
+      - Hugging-face models.  These take raw text as input and produce text embeddings as output.  Hugging-face models
+          are specified using dictionaries containing the following keys:
+            - 'model': the type of embedding to use-- any flair embedding type is supported; for a full list see
+                https://github.com/flairNLP/flair#tutorials.  For word-level embeddings, 'WordEmbeddings' is
+                recommended.  For document-level embeddings, we recommend using either 'TransformerDocumentEmbeddings'
+                (to model the full document's content) or 'SentenceTransformerDocumentEmbeddings' (if sentence-level
+                representations are needed).  Embeddings may be specified either as a string (e.g.,
+                'TransformerDocumentEmbeddings') or as a callable module (e.g.,
+                flair.embeddings.TransformerDocumentEmbeddings).
+            - 'args': a list of unnamed arguments to pass to the given model.  All pre-trained hugging-face models are
+                supported, including (but not limited to):
+                  - word-level embedding models:
+                      https://github.com/flairNLP/flair/blob/master/resources/docs/TUTORIAL_4_ELMO_BERT_FLAIR_EMBEDDING.md
+                  - sentence-level transformer models:
+                      https://docs.google.com/spreadsheets/d/14QplCdTCDwEmTqrn1LH4yrbKvdogK4oQvYO1K1aPR5M/edit#gid=0
+                  - document-level transformer models: https://huggingface.co/transformers/pretrained_models.html
+            - 'kwargs': a dictionary of keyword arguments to pass to the given model (these are model-specific; for
+                 details and examples see https://github.com/flairNLP/flair#tutorials
+          for example, to embed a document using GPT-2, use
+            {model: 'TransformerDocumentEmbeddings', args: ['gpt2'], 'kwargs': {}}
+          The 'kwargs' dictionary may be further subdivided; if an 'embedding_kwargs' key is included in 'kwargs',
+          its values will be treated as keyword arguments to be applied to the embedding model when it is initialized.
+          All other keyword arguments are passed on to flair.data.Sentence in order to tokenize the given text.
+    :param text: a string (a single word, sentence, or document), list of strings (a list of words, sentences, or
+      documents), or a nested list of strings (a list of listed words, sentences, or documents).  Strings and (shallow)
+      lists of strings result in a single embedding matrix; nested lists produce a list of embedding matrices (one
+      per lowest-level list)
+    :param args: a list of unnamed arguments to pass to *every* text embedding model or pipeline step.  Default: [].
+    :param mode: one of: 'fit' (fit the model), 'transform' (apply an already-fitted model), or 'fit_transform' (fit
+      a model and then apply it to the same text).  The 'fit' mode is only supported for scikit-learn (and scikit-learn-
+      compatible) models.
+    :param return_model: if True, return both the embedded text and a trained model that may be applied to new text. If
+      False, return only the text embeddings.  Default: False.
+    :param kwargs: keyword arguments are passed to the embedding model; these are equivalent to specifying the
+      embedding model as a dictionary.  When a keyword argument appears in both model['kwargs'] and kwargs, the kwargs
+      value is used preferentially.
+
+    Returns
+    -------
+    :return: The text embeddings (if return_model is False) or a tuple whose first element is the text embeddings and
+      whose second element is a fitted model that may be applied to new text (if return_model is True).
+    """
     if type(x) is list:
         models = []
         for i, v in enumerate(x):
@@ -226,6 +295,8 @@ def apply_text_model(x, text, *args, mode='fit_transform', return_model=False, *
             return transformed_text, {'model': model, 'args': args, 'kwargs': kwargs}
         return transformed_text
     elif is_hugging_face_model(model):
+        warnings.simplefilter('ignore')
+
         if mode == 'fit':  # do nothing-- just return the un-transformed text and original model
             if return_model:
                 return text, {'model': model, 'args': args, 'kwargs': kwargs}
@@ -264,6 +335,21 @@ def apply_text_model(x, text, *args, mode='fit_transform', return_model=False, *
 
 
 def get_text(x, force_literal=False):
+    """
+    Parse, load, or download one or more documents.
+
+    Parameters
+    ----------
+    :param x: A string or list of strings.  Each string can be either the text of a document, a file path, or a URL.  If
+      a file path or URL is provided, the contents are loaded in, treated as text, and returned.  If a list of strings
+      is provided, the get_text function is applied to each element of the list.
+    :param force_literal: If True, interpret strings literally (rather than checking to see if the strings point to a
+      local or remote file).  Default: False.
+
+    Returns
+    -------
+    :return: The text as a string or (potentially nested) list of strings
+    """
     if type(x) == list:
         return [get_text(t) for t in x]
     if (type(x) in six.string_types) or (type(x) == np.str_):
@@ -275,12 +361,37 @@ def get_text(x, force_literal=False):
 
 
 def is_text(x):
+    """
+    Test whether an object contains (or points to) text.
+
+    Parameters
+    ----------
+    :param x: the object to test
+
+    Returns
+    -------
+    :return: True if the object is (or points to) text and False otherwise.
+    """
+
     if type(x) == list:
         return all([is_text(i) for i in x])
     return get_text(x) is not None
 
 
 def to_str_list(x, encoding='utf-8'):
+    """
+    Internal helper function used to wrangle text data.  Handles binary strings, nested lists of strings, and arrays
+      or dataframes containing text.
+
+    Parameters
+    ----------
+    :param x: the text-containing object to be wrangled.
+    :param encoding: for objects of type bytes, specify the encoding.  Default: 'utf-8'.
+
+    Returns
+    -------
+    :return: a string or (possibly nested) list of strings
+    """
     def to_string(s):
         if type(s) == str:
             return s
@@ -306,14 +417,38 @@ def to_string(s):
 
 # noinspection PyShadowingNames
 def wrangle_text(text, return_model=False, **kwargs):
+    """
+    Turn text into DataFrames
+
+    Parameters
+    ----------
+    :param text: A string or (nested) list of strings.  Each string can contain either the to-be-wrangled text, a file
+      path, or a URL.
+    :param return_model: if True, return a fitted model that may be applied to new text data, along with the wrangled
+      text.  Default: False.
+    :param kwargs: Other (optional) keyword arguments may be passed into the function to control the wrangling
+      process:
+      - 'corpus': any built-in or hugging-face corpus (see get_corpus for more details); this argument is passed to the
+        get_corpus function as the "dataset_name" keyword argument
+        - the 'config' argument may be used to select a specific variant of the corpus (passed to get_corpus as the
+          "config_name" keyword argument).
+      - 'model': any scikit-learn-compatible or hugging-face-compatible model (see apply_text_model for more details)
+      - 'array_kwargs': a dictionary of keyword arguments that may be passed to wrangle_array to control how the final
+        DataFrame is structured (see wrangle_array for details).
+
+    Returns
+    -------
+    :return: a DataFrame (or list of DataFrames) containing the embedded text.  If return_model is True a tuple, whose
+      first element contains the embedded text and second element contains the fitted models, is returned instead.
+    """
     text = get_text(text)
     if type(text) is not list:
         text = [text]
 
-    model = kwargs.pop('model', defaults['text']['model'])
+    model = kwargs.pop('model', eval(defaults['text']['model']))
     corpus = kwargs.pop('corpus', None)
     config = kwargs.pop('config', None)
-    array_args = kwargs.pop('array_args', {})
+    array_kwargs = kwargs.pop('array_kwargs', {})
 
     if type(model) is not list:
         model = [model]
@@ -323,8 +458,8 @@ def wrangle_text(text, return_model=False, **kwargs):
             if not ((type(corpus) is list) and is_text(corpus)):
                 corpus = get_corpus(dataset_name=corpus, config_name=config)
         else:
-            corpus = get_corpus(dataset_name=defaults['text']['corpus'],
-                                config_name=defaults['text']['corpus_config'])
+            corpus = get_corpus(dataset_name=eval(defaults['text']['corpus']),
+                                config_name=eval(defaults['text']['corpus_config']))
 
         # train model on corpus
         _, model = apply_text_model(model, corpus, mode='fit', return_model=True, **kwargs)
@@ -333,7 +468,7 @@ def wrangle_text(text, return_model=False, **kwargs):
     embedded_text = apply_text_model(model, text, mode='transform', return_model=False, **kwargs)
 
     # turn array into dataframe
-    df = wrangle_array(embedded_text, **array_args)
+    df = wrangle_array(embedded_text, **array_kwargs)
 
     if return_model:
         return df, model
diff --git a/docs/conf.py b/docs/conf.py
index b9365f3..26b03a0 100755
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -19,7 +19,6 @@
 #
 import os
 import sys
-import sphinx_readable_theme
 
 sys.path.insert(0, os.path.abspath('..'))
 
@@ -33,7 +32,7 @@
 
 # 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.viewcode', 'sphinx.ext.autosummary']
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'sphinx.ext.autosummary', 'nbsphinx']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -85,14 +84,33 @@
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme_path = [sphinx_readable_theme.get_html_theme_path()]
-html_theme = 'readable'
+html_theme = 'pydata_sphinx_theme'
 
 # 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 = {}
+html_logo = "images/wrangler_logo.png"
+# noinspection HttpUrlsUsage
+html_theme_options = {
+    "icon_links": [
+        {
+            "name": "GitHub",
+            "url": "https://github.com/ContextLab/data-wrangler",
+            "icon": "fab fa-github-square",
+        },
+        {
+            "name": "Twitter",
+            "url": "https://twitter.com/ContextMemLab",
+            "icon": "fab fa-twitter-square",
+        },
+        {
+            "name": "Web",
+            "url": "http://www.context-lab.com",
+            "icon": "fa fa-globe",
+        },
+    ]
+}
 
 # 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,
diff --git a/docs/datawrangler.rst b/docs/datawrangler.rst
index a7e0863..9d0fada 100644
--- a/docs/datawrangler.rst
+++ b/docs/datawrangler.rst
@@ -1,6 +1,22 @@
-﻿datawrangler
+datawrangler package
 ====================
 
-.. currentmodule:: datawrangler
+Subpackages
+-----------
 
-.. autofunction:: wrangle
\ No newline at end of file
+.. toctree::
+   :maxdepth: 4
+
+   datawrangler.core
+   datawrangler.decorate
+   datawrangler.io
+   datawrangler.util
+   datawrangler.zoo
+
+Module contents
+---------------
+
+.. automodule:: datawrangler
+   :members:
+   :undoc-members:
+   :show-inheritance:
diff --git a/docs/datawrangler.zoo.image.rst b/docs/datawrangler.zoo.image.rst
deleted file mode 100644
index 7e4f5c6..0000000
--- a/docs/datawrangler.zoo.image.rst
+++ /dev/null
@@ -1,10 +0,0 @@
-datawrangler.zoo.image
-======================
-
-.. currentmodule:: datawrangler.zoo.image
-
-.. autofunction:: is_image
-
-.. autofunction:: wrangle_image
-
-.. autofunction:: get_image
diff --git a/docs/datawrangler.zoo.rst b/docs/datawrangler.zoo.rst
index 321c872..2cfa6d9 100644
--- a/docs/datawrangler.zoo.rst
+++ b/docs/datawrangler.zoo.rst
@@ -7,6 +7,5 @@
    datawrangler.zoo.array
    datawrangler.zoo.dataframe
    datawrangler.zoo.text
-   datawrangler.zoo.image
    datawrangler.zoo.null
 
diff --git a/docs/datawrangler.zoo.text.rst b/docs/datawrangler.zoo.text.rst
index 9572d74..37e7a43 100644
--- a/docs/datawrangler.zoo.text.rst
+++ b/docs/datawrangler.zoo.text.rst
@@ -1,7 +1,7 @@
 datawrangler.zoo.text
-================
+=====================
 
-.. currentmodule:: datawrangler.zoo
+.. currentmodule:: datawrangler.zoo.text
 
 .. autofunction:: is_text
 
diff --git a/docs/images/wrangler_icon.png b/docs/images/wrangler_icon.png
new file mode 100644
index 0000000..987acc3
Binary files /dev/null and b/docs/images/wrangler_icon.png differ
diff --git a/docs/images/wrangler_logo.png b/docs/images/wrangler_logo.png
new file mode 100644
index 0000000..d20e36e
Binary files /dev/null and b/docs/images/wrangler_logo.png differ
diff --git a/docs/index.rst b/docs/index.rst
index 6beb33e..bb8ae2e 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -1,13 +1,16 @@
-DataWrangler 🤠
+DataWrangler
 ======================================
- wrangle your messy data into consistent well-organized formats!
+Wrangle your messy data into consistent well-organized formats!
+
+
 
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 1
    :caption: Contents:
 
    readme
    installation
+   tutorials
    api
    contributing
    authors
diff --git a/docs/installation.rst b/docs/installation.rst
index 129ca9c..32ebf8f 100644
--- a/docs/installation.rst
+++ b/docs/installation.rst
@@ -12,7 +12,7 @@ To install datawrangler, run this command in your terminal:
 
 .. code-block:: console
 
-    $ pip install datawrangler
+    $ pip install pydata-wrangler
 
 This is the preferred method to install datawrangler, as it will always install the most recent stable release.
 
diff --git a/docs/modules.rst b/docs/modules.rst
new file mode 100644
index 0000000..d0edd6b
--- /dev/null
+++ b/docs/modules.rst
@@ -0,0 +1,7 @@
+datawrangler
+============
+
+.. toctree::
+   :maxdepth: 4
+
+   datawrangler
diff --git a/docs/tutorials.rst b/docs/tutorials.rst
new file mode 100644
index 0000000..a3f0d89
--- /dev/null
+++ b/docs/tutorials.rst
@@ -0,0 +1,16 @@
+Tutorials
+======================================
+
+Check out these tutorials to see ``data-wrangler`` in action.
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Tutorials:
+
+   tutorials/wrangling_basics.ipynb
+   tutorials/interpolation_and_imputation.ipynb
+   tutorials/decorators1.ipynb
+   tutorials/decorators2.ipynb
+   tutorials/io.ipynb
+   tutorials/util.ipynb
+   tutorials/core.ipynb
diff --git a/docs/tutorials/core.ipynb b/docs/tutorials/core.ipynb
new file mode 100644
index 0000000..84e217c
--- /dev/null
+++ b/docs/tutorials/core.ipynb
@@ -0,0 +1,37 @@
+{
+ "cells": [],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "source": [
+     "\n",
+     "\n",
+     "\n"
+    ],
+    "metadata": {
+     "collapsed": false
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/docs/tutorials/decorators1.ipynb b/docs/tutorials/decorators1.ipynb
new file mode 100644
index 0000000..f574694
--- /dev/null
+++ b/docs/tutorials/decorators1.ipynb
@@ -0,0 +1,36 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    ""
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/docs/tutorials/decorators2.ipynb b/docs/tutorials/decorators2.ipynb
new file mode 100644
index 0000000..f574694
--- /dev/null
+++ b/docs/tutorials/decorators2.ipynb
@@ -0,0 +1,36 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    ""
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/docs/tutorials/interpolation_and_imputation.ipynb b/docs/tutorials/interpolation_and_imputation.ipynb
new file mode 100644
index 0000000..f574694
--- /dev/null
+++ b/docs/tutorials/interpolation_and_imputation.ipynb
@@ -0,0 +1,36 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    ""
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/docs/tutorials/io.ipynb b/docs/tutorials/io.ipynb
new file mode 100644
index 0000000..f574694
--- /dev/null
+++ b/docs/tutorials/io.ipynb
@@ -0,0 +1,36 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    ""
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/docs/tutorials/tutorial_helpers.py b/docs/tutorials/tutorial_helpers.py
new file mode 100644
index 0000000..f6d2e97
--- /dev/null
+++ b/docs/tutorials/tutorial_helpers.py
@@ -0,0 +1,28 @@
+import os
+
+
+def parent_directory(d, n=0):
+    """
+    Go up n levels in the directory tree
+
+    Parameters
+    ----------
+    :param d: reference file
+    :param n: number of levels to go up in the directory tree
+
+    Returns
+    -------
+    :return: nth parent of the reference file
+    """
+
+    if n == 0:
+        return os.path.split(d)[0]
+    else:
+        return parent_directory(parent_directory(d), n-1)
+
+
+resources = os.path.join(parent_directory(os.path.dirname(__file__), 1), 'tests', 'resources')
+
+data_file = os.path.join(resources, 'testdata.csv')
+image_file = os.path.join(resources, 'wrangler.jpg')
+text_file = os.path.join(resources, 'home_on_the_range.txt')
diff --git a/docs/tutorials/util.ipynb b/docs/tutorials/util.ipynb
new file mode 100644
index 0000000..f574694
--- /dev/null
+++ b/docs/tutorials/util.ipynb
@@ -0,0 +1,36 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    ""
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/docs/tutorials/wrangling_basics.ipynb b/docs/tutorials/wrangling_basics.ipynb
new file mode 100644
index 0000000..8993c6b
--- /dev/null
+++ b/docs/tutorials/wrangling_basics.ipynb
@@ -0,0 +1,984 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Data wrangling basics: supported filetypes\n"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "outputs": [],
+   "source": [
+    "import datawrangler as dw\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "from matplotlib import pyplot as plt\n",
+    "from tutorial_helpers import data_file, image_file, text_file"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Let's load in some sample data:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "outputs": [],
+   "source": [
+    "dataframe = dw.io.load(data_file, index_col=0)\n",
+    "array = dataframe.values\n",
+    "image = dw.io.load(image_file)\n",
+    "text = dw.io.load(text_file)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Sample DataFrame:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "        FirstDim  SecondDim  ThirdDim  FourthDim  FifthDim\nByTwos                                                    \n0              1          2         3          4         5\n2              2          4         6          8        10\n4              3          6         9         12        15\n5              4          8        12         16        20\n6              5         10        15         20        25\n8              6         12        18         24        30\n10             7         14        21         28        35",
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>FirstDim</th>\n      <th>SecondDim</th>\n      <th>ThirdDim</th>\n      <th>FourthDim</th>\n      <th>FifthDim</th>\n    </tr>\n    <tr>\n      <th>ByTwos</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>2</td>\n      <td>3</td>\n      <td>4</td>\n      <td>5</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2</td>\n      <td>4</td>\n      <td>6</td>\n      <td>8</td>\n      <td>10</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>3</td>\n      <td>6</td>\n      <td>9</td>\n      <td>12</td>\n      <td>15</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>4</td>\n      <td>8</td>\n      <td>12</td>\n      <td>16</td>\n      <td>20</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>5</td>\n      <td>10</td>\n      <td>15</td>\n      <td>20</td>\n      <td>25</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>6</td>\n      <td>12</td>\n      <td>18</td>\n      <td>24</td>\n      <td>30</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>7</td>\n      <td>14</td>\n      <td>21</td>\n      <td>28</td>\n      <td>35</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataframe"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Sample Array"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "array([[ 1,  2,  3,  4,  5],\n       [ 2,  4,  6,  8, 10],\n       [ 3,  6,  9, 12, 15],\n       [ 4,  8, 12, 16, 20],\n       [ 5, 10, 15, 20, 25],\n       [ 6, 12, 18, 24, 30],\n       [ 7, 14, 21, 28, 35]])"
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "array"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Sample image:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<matplotlib.image.AxesImage at 0x7fb72ab06cd0>"
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(image)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Sample text:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "O give me a home where the buffaloes roam\n",
+      "Where the deer and the antelope play\n",
+      "Where seldom is heard a discouraging word\n",
+      "And the skies are not cloudy all day\n",
+      "Home, home on the range\n",
+      "Where the deer and the antelope play\n",
+      "Where seldom is heard a discouraging word\n",
+      "And the skies are not cloudy all day\n",
+      "Where the air is so pure and the zephyrs so free\n",
+      "And the breezes so balmy and light\n",
+      "That I would not exchange my home on the range\n",
+      "For all of the cities so bright\n",
+      "Home, home on the range\n",
+      "Where the deer and the antelope play\n",
+      "Where seldom is heard a discouraging word\n",
+      "And the skies are not cloudy all day\n",
+      "How often at night when the heavens are bright\n",
+      "With the light of the glittering stars\n",
+      "I stand there amazed and I ask as I gaze\n",
+      "Does their glory exceed that of ours?\n",
+      "Home, home on the range\n",
+      "Where the deer and the antelope play\n",
+      "Where seldom is heard a discouraging word\n",
+      "And the skies are not cloudy all day\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(text)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Wrangling DataFrames\n",
+    "\n",
+    "Wrangling a well-formed DataFrame just returns itself:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "        FirstDim  SecondDim  ThirdDim  FourthDim  FifthDim\nByTwos                                                    \n0              1          2         3          4         5\n2              2          4         6          8        10\n4              3          6         9         12        15\n5              4          8        12         16        20\n6              5         10        15         20        25\n8              6         12        18         24        30\n10             7         14        21         28        35",
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>FirstDim</th>\n      <th>SecondDim</th>\n      <th>ThirdDim</th>\n      <th>FourthDim</th>\n      <th>FifthDim</th>\n    </tr>\n    <tr>\n      <th>ByTwos</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>2</td>\n      <td>3</td>\n      <td>4</td>\n      <td>5</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2</td>\n      <td>4</td>\n      <td>6</td>\n      <td>8</td>\n      <td>10</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>3</td>\n      <td>6</td>\n      <td>9</td>\n      <td>12</td>\n      <td>15</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>4</td>\n      <td>8</td>\n      <td>12</td>\n      <td>16</td>\n      <td>20</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>5</td>\n      <td>10</td>\n      <td>15</td>\n      <td>20</td>\n      <td>25</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>6</td>\n      <td>12</td>\n      <td>18</td>\n      <td>24</td>\n      <td>30</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>7</td>\n      <td>14</td>\n      <td>21</td>\n      <td>28</td>\n      <td>35</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "wrangled_df = dw.wrangle(dataframe)\n",
+    "assert np.allclose(dataframe, wrangled_df)\n",
+    "wrangled_df"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Wrangling Arrays\n",
+    "\n",
+    "Wrangling an Array turns it into a DataFrame.  If the Array is 2D, the resulting DataFrame will have the same\n",
+    "shape:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "   0   1   2   3   4\n0  1   2   3   4   5\n1  2   4   6   8  10\n2  3   6   9  12  15\n3  4   8  12  16  20\n4  5  10  15  20  25\n5  6  12  18  24  30\n6  7  14  21  28  35",
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n      <th>4</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>2</td>\n      <td>3</td>\n      <td>4</td>\n      <td>5</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2</td>\n      <td>4</td>\n      <td>6</td>\n      <td>8</td>\n      <td>10</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>3</td>\n      <td>6</td>\n      <td>9</td>\n      <td>12</td>\n      <td>15</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>4</td>\n      <td>8</td>\n      <td>12</td>\n      <td>16</td>\n      <td>20</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>5</td>\n      <td>10</td>\n      <td>15</td>\n      <td>20</td>\n      <td>25</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>6</td>\n      <td>12</td>\n      <td>18</td>\n      <td>24</td>\n      <td>30</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>7</td>\n      <td>14</td>\n      <td>21</td>\n      <td>28</td>\n      <td>35</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "wrangled_array = dw.wrangle(array)\n",
+    "assert np.allclose(dataframe, wrangled_array)\n",
+    "wrangled_array"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Note that we've recovered the original DataFrame, but the index and column labels have been reset.  We can provide\n",
+    "these labels to the wrangle function.  The `array_kwargs` keyword argument specifies how array (or array-like) data\n",
+    "objects should be turned into DataFrames:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "        FirstDim  SecondDim  ThirdDim  FourthDim  FifthDim\nByTwos                                                    \n0              1          2         3          4         5\n2              2          4         6          8        10\n4              3          6         9         12        15\n5              4          8        12         16        20\n6              5         10        15         20        25\n8              6         12        18         24        30\n10             7         14        21         28        35",
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>FirstDim</th>\n      <th>SecondDim</th>\n      <th>ThirdDim</th>\n      <th>FourthDim</th>\n      <th>FifthDim</th>\n    </tr>\n    <tr>\n      <th>ByTwos</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>2</td>\n      <td>3</td>\n      <td>4</td>\n      <td>5</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2</td>\n      <td>4</td>\n      <td>6</td>\n      <td>8</td>\n      <td>10</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>3</td>\n      <td>6</td>\n      <td>9</td>\n      <td>12</td>\n      <td>15</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>4</td>\n      <td>8</td>\n      <td>12</td>\n      <td>16</td>\n      <td>20</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>5</td>\n      <td>10</td>\n      <td>15</td>\n      <td>20</td>\n      <td>25</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>6</td>\n      <td>12</td>\n      <td>18</td>\n      <td>24</td>\n      <td>30</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>7</td>\n      <td>14</td>\n      <td>21</td>\n      <td>28</td>\n      <td>35</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "array_kwargs = {'index': dataframe.index, 'columns': dataframe.columns}\n",
+    "wrangled_array2 = dw.wrangle(array, array_kwargs=array_kwargs)\n",
+    "wrangled_array2"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Wrangling text data using natural language processing models\n",
+    "\n",
+    "Next, let's play with some text data.  By default, `data-wrangler` embeds text using a Latent Dirichlet Allocation model\n",
+    "trained on a curated version of Wikipedia, called the \"minipedia\" corpus.  First we'll split the text into its component\n",
+    "lines, and then we'll wrangle the result:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loading corpus: minipedia...done!\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "      0     1     2     3     4     5     6     7     8     9   ...    40  \\\n0   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n1   0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  ...  0.01   \n2   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n3   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n4   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n5   0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  ...  0.01   \n6   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n7   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n8   0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  ...  0.01   \n9   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n10  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  ...  0.01   \n11  0.01  0.01  0.01  0.51  0.01  0.01  0.01  0.01  0.01  0.01  ...  0.01   \n12  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n13  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  ...  0.01   \n14  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n15  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n16  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  ...  0.01   \n17  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n18  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  ...  0.01   \n19  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n20  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n21  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  ...  0.01   \n22  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n23  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  ...  0.02   \n\n      41    42    43    44    45    46    47    48    49  \n0   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n1   0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  \n2   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n3   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n4   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n5   0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  \n6   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n7   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n8   0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  \n9   0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n10  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  \n11  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  \n12  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n13  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  \n14  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n15  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n16  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  \n17  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n18  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  \n19  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n20  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n21  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  0.01  \n22  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n23  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  0.02  \n\n[24 rows x 50 columns]",
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n      <th>4</th>\n      <th>5</th>\n      <th>6</th>\n      <th>7</th>\n      <th>8</th>\n      <th>9</th>\n      <th>...</th>\n      <th>40</th>\n      <th>41</th>\n      <th>42</th>\n      <th>43</th>\n      <th>44</th>\n      <th>45</th>\n      <th>46</th>\n      <th>47</th>\n      <th>48</th>\n      <th>49</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>...</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>...</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>...</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>...</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.51</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>...</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>...</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>15</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>16</th>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>...</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n    </tr>\n    <tr>\n      <th>17</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>18</th>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>...</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n    </tr>\n    <tr>\n      <th>19</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>20</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>21</th>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>...</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n      <td>0.01</td>\n    </tr>\n    <tr>\n      <th>22</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n    <tr>\n      <th>23</th>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>...</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n      <td>0.02</td>\n    </tr>\n  </tbody>\n</table>\n<p>24 rows × 50 columns</p>\n</div>"
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "lines = text.split('\\n')  # creates a list of strings (one string per line)\n",
+    "wrangled_text = dw.wrangle(lines)\n",
+    "wrangled_text"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "In the resulting DataFrame, each row corresponds to a line of text, and each column corresponds to an embedding\n",
+    "dimension.  To get a better feel for what these dimensions mean, we can use the `return_model` flag to get back the\n",
+    "fitted model, and then we can examine the top-weighted words from each topic:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "outputs": [],
+   "source": [
+    "wrangled_text2, text_model = dw.wrangle(lines, text_kwargs={'return_model': True})"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Top words from each of the 50 discovered topics:\n",
+      "\n",
+      "Topic 0: angle, points, normal, units, equal, measure, distribution, distance, unit, constant\n",
+      "Topic 1: foot, feet, double, speed, running, course, action, round, distance, motion\n",
+      "Topic 2: game, play, team, played, rules, sports, field, events, competition, women\n",
+      "Topic 3: mm, metal, plastic, glass, steel, diameter, sizes, machine, strength, cm\n",
+      "Topic 4: 2008, million, 2007, 2009, 2011, 2010, march, december, 2006, january\n",
+      "Topic 5: color, green, blue, yellow, colors, brown, tree, dark, plant, plants\n",
+      "Topic 6: music, sound, film, rock, played, television, play, record, records, classical\n",
+      "Topic 7: hours, night, hour, days, minutes, 24, week, daily, sun, working\n",
+      "Topic 8: theory, self, behavior, science, cultural, concept, studies, individuals, model, relationship\n",
+      "Topic 9: earth, sun, god, million, appears, visible, bodies, believed, billion, ago\n",
+      "Topic 10: computer, data, management, project, key, electronic, access, online, devices, technology\n",
+      "Topic 11: church, god, christian, religious, roman, religion, tradition, eastern, traditions, st\n",
+      "Topic 12: military, forces, force, ii, arms, russian, royal, service, units, operations\n",
+      "Topic 13: objects, mass, object, field, core, space, matter, fields, visible, energy\n",
+      "Topic 14: building, built, buildings, construction, house, floor, room, space, houses, walls\n",
+      "Topic 15: class, classes, anti, active, business, fall, military, 1950s, divided, feature\n",
+      "Topic 16: cross, symbol, sign, al, et, shaped, version, appears, represents, link\n",
+      "Topic 17: wind, ice, scale, energy, temperature, weather, speed, pressure, flow, sea\n",
+      "Topic 18: gas, energy, temperature, heat, chemical, carbon, liquid, compounds, acid, reaction\n",
+      "Topic 19: gain, southern, species, models, california, northern, frequency, active, components, spring\n",
+      "Topic 20: pressure, flow, fluid, test, volume, supply, liquid, inner, internal, outer\n",
+      "Topic 21: gold, iron, silver, metal, steel, value, carbon, bc, pure, ii\n",
+      "Topic 22: death, stage, dead, die, remains, man, performed, stages, carried, bodies\n",
+      "Topic 23: species, humans, male, female, million, ago, live, population, living, animals\n",
+      "Topic 24: language, languages, books, writing, written, words, text, published, formal, literature\n",
+      "Topic 25: health, medical, care, treatment, poor, population, million, studies, report, risk\n",
+      "Topic 26: animals, animal, skin, humans, eye, eyes, wild, kept, domestic, raised\n",
+      "Topic 27: cells, cell, growth, plants, structures, layer, plant, acid, functions, biological\n",
+      "Topic 28: women, sexual, children, men, female, male, child, woman, man, mother\n",
+      "Topic 29: oil, fruit, varieties, hot, served, consumption, grown, fresh, content, sold\n",
+      "Topic 30: service, court, legal, services, civil, department, federal, government, laws, issued\n",
+      "Topic 31: blood, disease, heart, risk, diseases, treatment, health, causes, medical, loss\n",
+      "Topic 32: vehicles, electric, speed, built, drive, safety, equipment, transport, electrical, technology\n",
+      "Topic 33: art, style, london, works, 18th, museum, tradition, saw, famous, william\n",
+      "Topic 34: political, party, government, rights, legal, organization, exchange, status, organizations, economic\n",
+      "Topic 35: fish, sea, ft, river, deep, land, fresh, 200, island, 500\n",
+      "Topic 36: city, road, street, cities, town, river, urban, population, island, travel\n",
+      "Topic 37: god, fruit, trees, disease, risk, treatment, head, million, cultural, medical\n",
+      "Topic 38: soil, land, plant, bc, plants, rock, regions, region, india, stone\n",
+      "Topic 39: story, damage, article, loss, ring, exposure, protection, journal, published, severe\n",
+      "Topic 40: section, big, principal, differences, ii, fully, model, wind, 32, split\n",
+      "Topic 41: base, lines, wall, pieces, piece, opening, figure, upper, vertical, branch\n",
+      "Topic 42: property, elements, numbers, element, table, properties, real, value, classical, theory\n",
+      "Topic 43: worn, paper, wear, clothing, fashion, women, men, style, styles, cover\n",
+      "Topic 44: chinese, king, india, east, african, africa, japanese, asia, indian, spanish\n",
+      "Topic 45: species, trees, plants, leaves, winter, wild, tree, season, summer, northern\n",
+      "Topic 46: foot, et, al, feet, science, political, height, 18th, court, religious\n",
+      "Topic 47: market, price, product, products, goods, store, chain, supply, industry, company\n",
+      "Topic 48: school, education, training, schools, degree, college, children, professional, programs, degrees\n",
+      "Topic 49: wood, head, image, cut, wooden, tools, edge, tool, images, face\n"
+     ]
+    }
+   ],
+   "source": [
+    "# display top words from the model\n",
+    "def get_top_words(model, n_words=10):\n",
+    "  vectorizer = model[0]['model']\n",
+    "  embedder = model[1]['model']\n",
+    "\n",
+    "  vocab = {v: k for k, v in vectorizer.vocabulary_.items()}\n",
+    "  top_words = []\n",
+    "  for k in range(embedder.components_.shape[0]):\n",
+    "      top_words.append([vocab[i] for i in np.argsort(embedder.components_[k, :])[::-1][:n_words]])\n",
+    "  return top_words\n",
+    "\n",
+    "def display_top_words(model, n_words=10):\n",
+    "  for k, w in enumerate(get_top_words(model, n_words=n_words)):\n",
+    "      print(f'Topic {k}: {\", \".join(w)}')\n",
+    "\n",
+    "print(f'Top words from each of the {wrangled_text2.shape[1]} discovered topics:\\n')\n",
+    "display_top_words(text_model)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Then we can ask which topics had the most weight in each line:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Line 1 put the most weight on topic 2: Where the deer and the antelope play\n"
+     ]
+    }
+   ],
+   "source": [
+    "i = 1\n",
+    "line_embedding = wrangled_text2.loc[i].values\n",
+    "line_top_topic = np.where(line_embedding == np.max(line_embedding))[0][0]\n",
+    "\n",
+    "print(f'Line {i} put the most weight on topic {line_top_topic}: {lines[i]}')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Note that each time the model is re-trained, the topic weights will change.  If all text data are wrangled in a single\n",
+    "pass, `data-wrangler` will automatically apply the same model to all text data.  However, if the data are wrangled in\n",
+    "multiple calls to `dw.wrangle`, the model fit during the first pass should be re-used in subsequent analyses:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Topics do NOT match!\n"
+     ]
+    }
+   ],
+   "source": [
+    "def match(a, b, type):\n",
+    "    if np.allclose(a, b):\n",
+    "        print(f'{type.capitalize()}s match!')\n",
+    "    else:\n",
+    "        print(f'{type.capitalize()}s do NOT match!')\n",
+    "\n",
+    "match(wrangled_text, wrangled_text2, 'topic')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "We can re-apply the already-fitted model to \"new\" text:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Topics match!\n"
+     ]
+    }
+   ],
+   "source": [
+    "wrangled_text3 = dw.wrangle(lines, text_kwargs={'model': text_model})\n",
+    "match(wrangled_text2, wrangled_text3, 'topic')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "In addition to training scikit-learn text embedding models and applying them to new text, `data-wrangler` also provides\n",
+    "wrappers for all models on [hugging-face](https://huggingface.co/transformers/pretrained_models.html).  For example,\n",
+    "the example text may be embedded using BERT as follows:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.LayerNorm.weight']\n",
+      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "         0         1         2         3         4         5         6    \\\n0  -0.179094  0.284875 -0.299491 -0.177137 -0.141404 -0.067665  0.565553   \n1  -0.355487 -0.017091 -0.654681 -0.259151  0.354129 -0.081604  0.058410   \n2  -0.434022  0.232728 -0.357610 -0.538824 -0.114096  0.091183  0.355937   \n3   0.116562  0.352505 -0.202589 -0.516457 -0.240493 -0.251500  0.434644   \n4  -0.303647  0.064255  0.083019 -0.227822 -0.155865 -0.340454  0.406733   \n5  -0.355487 -0.017091 -0.654681 -0.259151  0.354129 -0.081604  0.058410   \n6  -0.434022  0.232728 -0.357610 -0.538824 -0.114096  0.091183  0.355937   \n7   0.116562  0.352505 -0.202589 -0.516457 -0.240493 -0.251500  0.434644   \n8  -0.154609 -0.117675 -0.193155 -0.120318  0.144618 -0.040556  0.055185   \n9  -0.055069  0.233549 -0.373195 -0.063233 -0.368840 -0.094472 -0.001174   \n10 -0.267577  0.273886 -0.290938 -0.154544 -0.294967 -0.245634  0.110082   \n11 -0.197301  0.388715 -0.570143  0.060791 -0.689461 -0.086844  0.264934   \n12 -0.303647  0.064255  0.083019 -0.227822 -0.155865 -0.340454  0.406733   \n13 -0.355487 -0.017091 -0.654681 -0.259151  0.354129 -0.081604  0.058410   \n14 -0.434022  0.232728 -0.357610 -0.538824 -0.114096  0.091183  0.355937   \n15  0.116562  0.352505 -0.202589 -0.516457 -0.240493 -0.251500  0.434644   \n16 -0.042624  0.237888 -0.339024 -0.296698 -0.030120  0.325440  0.256775   \n17 -0.128437  0.139192 -0.030835 -0.021700 -0.219863 -0.022784  0.231964   \n18 -0.058371  0.577921 -0.205151 -0.409644 -0.182388 -0.365214  0.237212   \n19 -0.095738  0.258930 -0.246360 -0.317963 -0.303286  0.059010  0.884104   \n20 -0.303647  0.064255  0.083019 -0.227822 -0.155865 -0.340454  0.406733   \n21 -0.355487 -0.017091 -0.654681 -0.259151  0.354129 -0.081604  0.058410   \n22 -0.434022  0.232728 -0.357610 -0.538824 -0.114096  0.091183  0.355937   \n23  0.116562  0.352505 -0.202589 -0.516457 -0.240493 -0.251500  0.434644   \n\n         7         8         9    ...       758       759       760       761  \\\n0   0.467750 -0.202324 -0.212224  ... -0.084236 -0.418129  0.018537  0.011057   \n1   0.774030 -0.508033 -0.182541  ...  0.604850 -0.409842 -0.351007  0.006899   \n2   0.533486 -0.258791 -0.517260  ...  0.326534 -0.007036  0.122069  0.427969   \n3   1.104639 -0.548261 -0.573233  ... -0.207017 -0.543512  0.078864  0.427558   \n4   0.363462 -0.119832  0.008430  ...  0.045680 -0.289353  0.040407  0.220519   \n5   0.774030 -0.508033 -0.182541  ...  0.604850 -0.409842 -0.351007  0.006899   \n6   0.533486 -0.258791 -0.517260  ...  0.326534 -0.007036  0.122069  0.427969   \n7   1.104639 -0.548261 -0.573233  ... -0.207017 -0.543512  0.078864  0.427558   \n8   0.593648 -0.052717 -0.609513  ...  0.127333 -0.753203 -0.320297  0.160509   \n9   0.553668 -0.308054 -0.308339  ... -0.078380 -0.351585  0.063690  0.097025   \n10  0.199497  0.071730  0.048779  ...  0.186747 -0.157770  0.178595 -0.231232   \n11  0.730778 -0.349251 -0.632186  ...  0.062608 -0.156804  0.015915  0.356509   \n12  0.363462 -0.119832  0.008430  ...  0.045680 -0.289353  0.040407  0.220519   \n13  0.774030 -0.508033 -0.182541  ...  0.604850 -0.409842 -0.351007  0.006899   \n14  0.533486 -0.258791 -0.517260  ...  0.326534 -0.007036  0.122069  0.427969   \n15  1.104639 -0.548261 -0.573233  ... -0.207017 -0.543512  0.078864  0.427558   \n16  0.668790 -0.397956 -0.412569  ... -0.078481 -0.429169  0.062366  0.155723   \n17  0.285454 -0.195330 -0.291857  ...  0.021852 -0.090953 -0.045454  0.106142   \n18  0.274319 -0.231599 -0.452986  ...  0.180460 -0.142040  0.198233 -0.205660   \n19  0.638759 -0.023153 -0.363116  ... -0.093948 -0.062690 -0.032260 -0.303910   \n20  0.363462 -0.119832  0.008430  ...  0.045680 -0.289353  0.040407  0.220519   \n21  0.774030 -0.508033 -0.182541  ...  0.604850 -0.409842 -0.351007  0.006899   \n22  0.533486 -0.258791 -0.517260  ...  0.326534 -0.007036  0.122069  0.427969   \n23  1.104639 -0.548261 -0.573233  ... -0.207017 -0.543512  0.078864  0.427558   \n\n         762       763       764       765       766       767  \n0  -0.008122  0.272119 -0.206632 -0.628336  0.101313  0.264802  \n1   0.283090  0.510657 -0.163572 -0.187182  0.706947  0.126187  \n2   0.178177  0.006136  0.400360 -0.195199 -0.078082  0.425256  \n3   0.229642  0.177264  0.150222 -0.463897  0.718633  0.301247  \n4   0.385223 -0.200164 -0.278663 -0.711024  0.326283  0.156556  \n5   0.283090  0.510657 -0.163572 -0.187182  0.706947  0.126187  \n6   0.178177  0.006136  0.400360 -0.195199 -0.078082  0.425256  \n7   0.229642  0.177264  0.150222 -0.463897  0.718633  0.301247  \n8   0.180886  0.219988 -0.039618 -0.503588  0.528944  0.037808  \n9   0.297684  0.268404 -0.114566 -0.443027  0.438811  0.249571  \n10  0.034351 -0.263620 -0.297643 -0.015021  0.064520  0.413469  \n11  0.126876  0.070972 -0.266137 -0.248545  0.569642  0.025831  \n12  0.385223 -0.200164 -0.278663 -0.711024  0.326283  0.156556  \n13  0.283090  0.510657 -0.163572 -0.187182  0.706947  0.126187  \n14  0.178177  0.006136  0.400360 -0.195199 -0.078082  0.425256  \n15  0.229642  0.177264  0.150222 -0.463897  0.718633  0.301247  \n16  0.464718  0.164203 -0.323323 -0.087794  0.519133 -0.012814  \n17  0.084842 -0.083967  0.176070 -0.354902  0.105398  0.048799  \n18 -0.146888  0.240958 -0.033177 -0.298921  0.645759  0.109323  \n19  0.204218 -0.038480  0.264909 -0.098913  0.112675  0.251036  \n20  0.385223 -0.200164 -0.278663 -0.711024  0.326283  0.156556  \n21  0.283090  0.510657 -0.163572 -0.187182  0.706947  0.126187  \n22  0.178177  0.006136  0.400360 -0.195199 -0.078082  0.425256  \n23  0.229642  0.177264  0.150222 -0.463897  0.718633  0.301247  \n\n[24 rows x 768 columns]",
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n      <th>4</th>\n      <th>5</th>\n      <th>6</th>\n      <th>7</th>\n      <th>8</th>\n      <th>9</th>\n      <th>...</th>\n      <th>758</th>\n      <th>759</th>\n      <th>760</th>\n      <th>761</th>\n      <th>762</th>\n      <th>763</th>\n      <th>764</th>\n      <th>765</th>\n      <th>766</th>\n      <th>767</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-0.179094</td>\n      <td>0.284875</td>\n      <td>-0.299491</td>\n      <td>-0.177137</td>\n      <td>-0.141404</td>\n      <td>-0.067665</td>\n      <td>0.565553</td>\n      <td>0.467750</td>\n      <td>-0.202324</td>\n      <td>-0.212224</td>\n      <td>...</td>\n      <td>-0.084236</td>\n      <td>-0.418129</td>\n      <td>0.018537</td>\n      <td>0.011057</td>\n      <td>-0.008122</td>\n      <td>0.272119</td>\n      <td>-0.206632</td>\n      <td>-0.628336</td>\n      <td>0.101313</td>\n      <td>0.264802</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-0.355487</td>\n      <td>-0.017091</td>\n      <td>-0.654681</td>\n      <td>-0.259151</td>\n      <td>0.354129</td>\n      <td>-0.081604</td>\n      <td>0.058410</td>\n      <td>0.774030</td>\n      <td>-0.508033</td>\n      <td>-0.182541</td>\n      <td>...</td>\n      <td>0.604850</td>\n      <td>-0.409842</td>\n      <td>-0.351007</td>\n      <td>0.006899</td>\n      <td>0.283090</td>\n      <td>0.510657</td>\n      <td>-0.163572</td>\n      <td>-0.187182</td>\n      <td>0.706947</td>\n      <td>0.126187</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-0.434022</td>\n      <td>0.232728</td>\n      <td>-0.357610</td>\n      <td>-0.538824</td>\n      <td>-0.114096</td>\n      <td>0.091183</td>\n      <td>0.355937</td>\n      <td>0.533486</td>\n      <td>-0.258791</td>\n      <td>-0.517260</td>\n      <td>...</td>\n      <td>0.326534</td>\n      <td>-0.007036</td>\n      <td>0.122069</td>\n      <td>0.427969</td>\n      <td>0.178177</td>\n      <td>0.006136</td>\n      <td>0.400360</td>\n      <td>-0.195199</td>\n      <td>-0.078082</td>\n      <td>0.425256</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.116562</td>\n      <td>0.352505</td>\n      <td>-0.202589</td>\n      <td>-0.516457</td>\n      <td>-0.240493</td>\n      <td>-0.251500</td>\n      <td>0.434644</td>\n      <td>1.104639</td>\n      <td>-0.548261</td>\n      <td>-0.573233</td>\n      <td>...</td>\n      <td>-0.207017</td>\n      <td>-0.543512</td>\n      <td>0.078864</td>\n      <td>0.427558</td>\n      <td>0.229642</td>\n      <td>0.177264</td>\n      <td>0.150222</td>\n      <td>-0.463897</td>\n      <td>0.718633</td>\n      <td>0.301247</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-0.303647</td>\n      <td>0.064255</td>\n      <td>0.083019</td>\n      <td>-0.227822</td>\n      <td>-0.155865</td>\n      <td>-0.340454</td>\n      <td>0.406733</td>\n      <td>0.363462</td>\n      <td>-0.119832</td>\n      <td>0.008430</td>\n      <td>...</td>\n      <td>0.045680</td>\n      <td>-0.289353</td>\n      <td>0.040407</td>\n      <td>0.220519</td>\n      <td>0.385223</td>\n      <td>-0.200164</td>\n      <td>-0.278663</td>\n      <td>-0.711024</td>\n      <td>0.326283</td>\n      <td>0.156556</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>-0.355487</td>\n      <td>-0.017091</td>\n      <td>-0.654681</td>\n      <td>-0.259151</td>\n      <td>0.354129</td>\n      <td>-0.081604</td>\n      <td>0.058410</td>\n      <td>0.774030</td>\n      <td>-0.508033</td>\n      <td>-0.182541</td>\n      <td>...</td>\n      <td>0.604850</td>\n      <td>-0.409842</td>\n      <td>-0.351007</td>\n      <td>0.006899</td>\n      <td>0.283090</td>\n      <td>0.510657</td>\n      <td>-0.163572</td>\n      <td>-0.187182</td>\n      <td>0.706947</td>\n      <td>0.126187</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>-0.434022</td>\n      <td>0.232728</td>\n      <td>-0.357610</td>\n      <td>-0.538824</td>\n      <td>-0.114096</td>\n      <td>0.091183</td>\n      <td>0.355937</td>\n      <td>0.533486</td>\n      <td>-0.258791</td>\n      <td>-0.517260</td>\n      <td>...</td>\n      <td>0.326534</td>\n      <td>-0.007036</td>\n      <td>0.122069</td>\n      <td>0.427969</td>\n      <td>0.178177</td>\n      <td>0.006136</td>\n      <td>0.400360</td>\n      <td>-0.195199</td>\n      <td>-0.078082</td>\n      <td>0.425256</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.116562</td>\n      <td>0.352505</td>\n      <td>-0.202589</td>\n      <td>-0.516457</td>\n      <td>-0.240493</td>\n      <td>-0.251500</td>\n      <td>0.434644</td>\n      <td>1.104639</td>\n      <td>-0.548261</td>\n      <td>-0.573233</td>\n      <td>...</td>\n      <td>-0.207017</td>\n      <td>-0.543512</td>\n      <td>0.078864</td>\n      <td>0.427558</td>\n      <td>0.229642</td>\n      <td>0.177264</td>\n      <td>0.150222</td>\n      <td>-0.463897</td>\n      <td>0.718633</td>\n      <td>0.301247</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-0.154609</td>\n      <td>-0.117675</td>\n      <td>-0.193155</td>\n      <td>-0.120318</td>\n      <td>0.144618</td>\n      <td>-0.040556</td>\n      <td>0.055185</td>\n      <td>0.593648</td>\n      <td>-0.052717</td>\n      <td>-0.609513</td>\n      <td>...</td>\n      <td>0.127333</td>\n      <td>-0.753203</td>\n      <td>-0.320297</td>\n      <td>0.160509</td>\n      <td>0.180886</td>\n      <td>0.219988</td>\n      <td>-0.039618</td>\n      <td>-0.503588</td>\n      <td>0.528944</td>\n      <td>0.037808</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>-0.055069</td>\n      <td>0.233549</td>\n      <td>-0.373195</td>\n      <td>-0.063233</td>\n      <td>-0.368840</td>\n      <td>-0.094472</td>\n      <td>-0.001174</td>\n      <td>0.553668</td>\n      <td>-0.308054</td>\n      <td>-0.308339</td>\n      <td>...</td>\n      <td>-0.078380</td>\n      <td>-0.351585</td>\n      <td>0.063690</td>\n      <td>0.097025</td>\n      <td>0.297684</td>\n      <td>0.268404</td>\n      <td>-0.114566</td>\n      <td>-0.443027</td>\n      <td>0.438811</td>\n      <td>0.249571</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>-0.267577</td>\n      <td>0.273886</td>\n      <td>-0.290938</td>\n      <td>-0.154544</td>\n      <td>-0.294967</td>\n      <td>-0.245634</td>\n      <td>0.110082</td>\n      <td>0.199497</td>\n      <td>0.071730</td>\n      <td>0.048779</td>\n      <td>...</td>\n      <td>0.186747</td>\n      <td>-0.157770</td>\n      <td>0.178595</td>\n      <td>-0.231232</td>\n      <td>0.034351</td>\n      <td>-0.263620</td>\n      <td>-0.297643</td>\n      <td>-0.015021</td>\n      <td>0.064520</td>\n      <td>0.413469</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>-0.197301</td>\n      <td>0.388715</td>\n      <td>-0.570143</td>\n      <td>0.060791</td>\n      <td>-0.689461</td>\n      <td>-0.086844</td>\n      <td>0.264934</td>\n      <td>0.730778</td>\n      <td>-0.349251</td>\n      <td>-0.632186</td>\n      <td>...</td>\n      <td>0.062608</td>\n      <td>-0.156804</td>\n      <td>0.015915</td>\n      <td>0.356509</td>\n      <td>0.126876</td>\n      <td>0.070972</td>\n      <td>-0.266137</td>\n      <td>-0.248545</td>\n      <td>0.569642</td>\n      <td>0.025831</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>-0.303647</td>\n      <td>0.064255</td>\n      <td>0.083019</td>\n      <td>-0.227822</td>\n      <td>-0.155865</td>\n      <td>-0.340454</td>\n      <td>0.406733</td>\n      <td>0.363462</td>\n      <td>-0.119832</td>\n      <td>0.008430</td>\n      <td>...</td>\n      <td>0.045680</td>\n      <td>-0.289353</td>\n      <td>0.040407</td>\n      <td>0.220519</td>\n      <td>0.385223</td>\n      <td>-0.200164</td>\n      <td>-0.278663</td>\n      <td>-0.711024</td>\n      <td>0.326283</td>\n      <td>0.156556</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>-0.355487</td>\n      <td>-0.017091</td>\n      <td>-0.654681</td>\n      <td>-0.259151</td>\n      <td>0.354129</td>\n      <td>-0.081604</td>\n      <td>0.058410</td>\n      <td>0.774030</td>\n      <td>-0.508033</td>\n      <td>-0.182541</td>\n      <td>...</td>\n      <td>0.604850</td>\n      <td>-0.409842</td>\n      <td>-0.351007</td>\n      <td>0.006899</td>\n      <td>0.283090</td>\n      <td>0.510657</td>\n      <td>-0.163572</td>\n      <td>-0.187182</td>\n      <td>0.706947</td>\n      <td>0.126187</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>-0.434022</td>\n      <td>0.232728</td>\n      <td>-0.357610</td>\n      <td>-0.538824</td>\n      <td>-0.114096</td>\n      <td>0.091183</td>\n      <td>0.355937</td>\n      <td>0.533486</td>\n      <td>-0.258791</td>\n      <td>-0.517260</td>\n      <td>...</td>\n      <td>0.326534</td>\n      <td>-0.007036</td>\n      <td>0.122069</td>\n      <td>0.427969</td>\n      <td>0.178177</td>\n      <td>0.006136</td>\n      <td>0.400360</td>\n      <td>-0.195199</td>\n      <td>-0.078082</td>\n      <td>0.425256</td>\n    </tr>\n    <tr>\n      <th>15</th>\n      <td>0.116562</td>\n      <td>0.352505</td>\n      <td>-0.202589</td>\n      <td>-0.516457</td>\n      <td>-0.240493</td>\n      <td>-0.251500</td>\n      <td>0.434644</td>\n      <td>1.104639</td>\n      <td>-0.548261</td>\n      <td>-0.573233</td>\n      <td>...</td>\n      <td>-0.207017</td>\n      <td>-0.543512</td>\n      <td>0.078864</td>\n      <td>0.427558</td>\n      <td>0.229642</td>\n      <td>0.177264</td>\n      <td>0.150222</td>\n      <td>-0.463897</td>\n      <td>0.718633</td>\n      <td>0.301247</td>\n    </tr>\n    <tr>\n      <th>16</th>\n      <td>-0.042624</td>\n      <td>0.237888</td>\n      <td>-0.339024</td>\n      <td>-0.296698</td>\n      <td>-0.030120</td>\n      <td>0.325440</td>\n      <td>0.256775</td>\n      <td>0.668790</td>\n      <td>-0.397956</td>\n      <td>-0.412569</td>\n      <td>...</td>\n      <td>-0.078481</td>\n      <td>-0.429169</td>\n      <td>0.062366</td>\n      <td>0.155723</td>\n      <td>0.464718</td>\n      <td>0.164203</td>\n      <td>-0.323323</td>\n      <td>-0.087794</td>\n      <td>0.519133</td>\n      <td>-0.012814</td>\n    </tr>\n    <tr>\n      <th>17</th>\n      <td>-0.128437</td>\n      <td>0.139192</td>\n      <td>-0.030835</td>\n      <td>-0.021700</td>\n      <td>-0.219863</td>\n      <td>-0.022784</td>\n      <td>0.231964</td>\n      <td>0.285454</td>\n      <td>-0.195330</td>\n      <td>-0.291857</td>\n      <td>...</td>\n      <td>0.021852</td>\n      <td>-0.090953</td>\n      <td>-0.045454</td>\n      <td>0.106142</td>\n      <td>0.084842</td>\n      <td>-0.083967</td>\n      <td>0.176070</td>\n      <td>-0.354902</td>\n      <td>0.105398</td>\n      <td>0.048799</td>\n    </tr>\n    <tr>\n      <th>18</th>\n      <td>-0.058371</td>\n      <td>0.577921</td>\n      <td>-0.205151</td>\n      <td>-0.409644</td>\n      <td>-0.182388</td>\n      <td>-0.365214</td>\n      <td>0.237212</td>\n      <td>0.274319</td>\n      <td>-0.231599</td>\n      <td>-0.452986</td>\n      <td>...</td>\n      <td>0.180460</td>\n      <td>-0.142040</td>\n      <td>0.198233</td>\n      <td>-0.205660</td>\n      <td>-0.146888</td>\n      <td>0.240958</td>\n      <td>-0.033177</td>\n      <td>-0.298921</td>\n      <td>0.645759</td>\n      <td>0.109323</td>\n    </tr>\n    <tr>\n      <th>19</th>\n      <td>-0.095738</td>\n      <td>0.258930</td>\n      <td>-0.246360</td>\n      <td>-0.317963</td>\n      <td>-0.303286</td>\n      <td>0.059010</td>\n      <td>0.884104</td>\n      <td>0.638759</td>\n      <td>-0.023153</td>\n      <td>-0.363116</td>\n      <td>...</td>\n      <td>-0.093948</td>\n      <td>-0.062690</td>\n      <td>-0.032260</td>\n      <td>-0.303910</td>\n      <td>0.204218</td>\n      <td>-0.038480</td>\n      <td>0.264909</td>\n      <td>-0.098913</td>\n      <td>0.112675</td>\n      <td>0.251036</td>\n    </tr>\n    <tr>\n      <th>20</th>\n      <td>-0.303647</td>\n      <td>0.064255</td>\n      <td>0.083019</td>\n      <td>-0.227822</td>\n      <td>-0.155865</td>\n      <td>-0.340454</td>\n      <td>0.406733</td>\n      <td>0.363462</td>\n      <td>-0.119832</td>\n      <td>0.008430</td>\n      <td>...</td>\n      <td>0.045680</td>\n      <td>-0.289353</td>\n      <td>0.040407</td>\n      <td>0.220519</td>\n      <td>0.385223</td>\n      <td>-0.200164</td>\n      <td>-0.278663</td>\n      <td>-0.711024</td>\n      <td>0.326283</td>\n      <td>0.156556</td>\n    </tr>\n    <tr>\n      <th>21</th>\n      <td>-0.355487</td>\n      <td>-0.017091</td>\n      <td>-0.654681</td>\n      <td>-0.259151</td>\n      <td>0.354129</td>\n      <td>-0.081604</td>\n      <td>0.058410</td>\n      <td>0.774030</td>\n      <td>-0.508033</td>\n      <td>-0.182541</td>\n      <td>...</td>\n      <td>0.604850</td>\n      <td>-0.409842</td>\n      <td>-0.351007</td>\n      <td>0.006899</td>\n      <td>0.283090</td>\n      <td>0.510657</td>\n      <td>-0.163572</td>\n      <td>-0.187182</td>\n      <td>0.706947</td>\n      <td>0.126187</td>\n    </tr>\n    <tr>\n      <th>22</th>\n      <td>-0.434022</td>\n      <td>0.232728</td>\n      <td>-0.357610</td>\n      <td>-0.538824</td>\n      <td>-0.114096</td>\n      <td>0.091183</td>\n      <td>0.355937</td>\n      <td>0.533486</td>\n      <td>-0.258791</td>\n      <td>-0.517260</td>\n      <td>...</td>\n      <td>0.326534</td>\n      <td>-0.007036</td>\n      <td>0.122069</td>\n      <td>0.427969</td>\n      <td>0.178177</td>\n      <td>0.006136</td>\n      <td>0.400360</td>\n      <td>-0.195199</td>\n      <td>-0.078082</td>\n      <td>0.425256</td>\n    </tr>\n    <tr>\n      <th>23</th>\n      <td>0.116562</td>\n      <td>0.352505</td>\n      <td>-0.202589</td>\n      <td>-0.516457</td>\n      <td>-0.240493</td>\n      <td>-0.251500</td>\n      <td>0.434644</td>\n      <td>1.104639</td>\n      <td>-0.548261</td>\n      <td>-0.573233</td>\n      <td>...</td>\n      <td>-0.207017</td>\n      <td>-0.543512</td>\n      <td>0.078864</td>\n      <td>0.427558</td>\n      <td>0.229642</td>\n      <td>0.177264</td>\n      <td>0.150222</td>\n      <td>-0.463897</td>\n      <td>0.718633</td>\n      <td>0.301247</td>\n    </tr>\n  </tbody>\n</table>\n<p>24 rows × 768 columns</p>\n</div>"
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bert = {'model': 'TransformerDocumentEmbeddings', 'args': ['bert-base-uncased'], 'kwargs': {}}\n",
+    "bert_embeddings = dw.wrangle(lines, text_kwargs={'model': bert})\n",
+    "bert_embeddings"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Wrangling images\n",
+    "\n",
+    "Images (stored in any format supported by [matplotlib](https://matplotlib.org/)) treated as Arrays.  Images are wrangled\n",
+    "into `DataFrame`s by slicing the image along axis 2 (i.e., the color dimension), horizontally concatenating the slices,\n",
+    "and then turning the result into a `DataFrame`.  In general, this approach is taken for all high-dimensional (> 2D)\n",
+    "Arrays:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "wrangled_image = dw.wrangle(image)\n",
+    "plt.imshow(wrangled_image);"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Objects, file paths, and URLs\n",
+    "\n",
+    "Data supplied to `data-wrangler` may be passed in directly as a Python object that is already loaded into memory (as in\n",
+    "the above examples).  However, data may also be supplied as a (string) file path or URL.  For example,\n",
+    "wrangling the already loaded-in image versus wrangling the image's file path will yield the same result:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Images match!\n"
+     ]
+    }
+   ],
+   "source": [
+    "wrangled_image_from_path = dw.wrangle(image_file)\n",
+    "match(wrangled_image, wrangled_image_from_path, 'image')\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Handling multiple data types\n",
+    "\n",
+    "Multiple objects, file paths, or URLs may be wrangled in a single function call.  If desired, type-specific wrangling\n",
+    "preferences may be provided.  Specifying `return_dtype=True` also returns a list of the automatically detected data\n",
+    "types for each object:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "outputs": [],
+   "source": [
+    "text_kwargs = {'model': bert}\n",
+    "\n",
+    "i = 10\n",
+    "first_lines = lines[:i]\n",
+    "last_lines = lines[i:]"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.LayerNorm.weight']\n",
+      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
+      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.LayerNorm.weight']\n",
+      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
+     ]
+    }
+   ],
+   "source": [
+    "wrangled_data, dtypes = dw.wrangle([dataframe, array, image_file, first_lines, last_lines],\n",
+    "                                   text_kwargs=text_kwargs,\n",
+    "                                   return_dtype=True)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "We can check the inferred datatypes:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "['dataframe', 'array', 'array', 'text', 'text']"
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dtypes"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "We can also verify that when the data are wrangled simultaneously, we get the same results as when each object is\n",
+    "wrangled separately.  For example, here's the newly wrangled image:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<matplotlib.image.AxesImage at 0x7fb72b2ea890>"
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# visualize the wrangled image\n",
+    "plt.imshow(wrangled_data[2])"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "And here's how the text embeddings compare to our previous results:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "First lines's bert embeddings match!\n",
+      "Last lines's bert embeddings match!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# compare the first lines' embeddings:\n",
+    "match(bert_embeddings.iloc[:i], wrangled_data[3], 'first lines\\'s BERT embedding')\n",
+    "\n",
+    "# compare the last lines' embeddings\n",
+    "match(bert_embeddings.iloc[i:], wrangled_data[4], 'last lines\\'s BERT embedding')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Check out the other tutorials for more advanced data wrangling functions!"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index ecdd880..bec8955 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -6,12 +6,11 @@ torchvision~=0.8.2
 pytorch-transformers~=1.1.0
 pytorch-pretrained-bert~=0.6.2
 sentencepiece==0.1.95
-pandas~=1.2.4
-scipy~=1.7.0
+pandas
+scipy
 numpy~=1.19.5
 requests~=2.26.0
 six~=1.15.0
-pytest>=5.4.1
 setuptools>=49.6.0
 flair~=0.8.0.post1
 tqdm~=4.49.0
@@ -23,4 +22,4 @@ sentence-transformers~=2.0.0
 tokenizers~=0.10.3
 transformers~=4.8.2
 datawrangler>=0.1.0
-Pillow
\ No newline at end of file
+Pillow
diff --git a/requirements_dev.txt b/requirements_dev.txt
index af4a3b9..0fdacef 100644
--- a/requirements_dev.txt
+++ b/requirements_dev.txt
@@ -1,12 +1,4 @@
-pip==19.2.3
-bump2version==0.5.11
-wheel==0.33.6
-watchdog==0.9.0
-flake8==3.7.8
-tox==3.14.0
-coverage==4.5.4
 Sphinx==1.8.5
-twine==1.14.0
-
-pytest==6.2.4
-sphinx_readable_theme
+pytest
+pydata-sphinx-theme
+nbsphinx
diff --git a/setup.cfg b/setup.cfg
index e923880..9af91e0 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.1.0
+current_version = 0.1.3
 commit = True
 tag = True
 
diff --git a/setup.py b/setup.py
index a590733..e6f3acc 100644
--- a/setup.py
+++ b/setup.py
@@ -4,12 +4,6 @@
 
 from setuptools import setup, find_packages
 
-with open('README.md') as readme_file:
-    readme = readme_file.read()
-
-with open('HISTORY.rst') as history_file:
-    history = history_file.read()
-
 with open('requirements.txt') as requirements_file:
     requirements = requirements_file.read()
 
@@ -20,26 +14,33 @@
     author_email='contextualdynamics@gmail.com',
     python_requires='>=3.6',
     classifiers=[
-        'Development Status :: 2 - Pre-Alpha',
+        'Development Status :: 4 - Beta',
         'Intended Audience :: Developers',
+        'Intended Audience :: Education',
+        'Intended Audience :: Science/Research',
         'License :: OSI Approved :: MIT License',
         'Natural Language :: English',
+        'Topic :: Software Development :: Libraries :: Python Modules',
         'Programming Language :: Python :: 3',
         'Programming Language :: Python :: 3.6',
         'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
     ],
-    description="Wrangle messy data into consistent well-organized format",
+    description="Wrangle messy data into pandas DataFrames, with a special focus on text data and natural language "
+                "processing",
     install_requires=requirements,
     license="MIT license",
-    long_description=readme + '\n\n' + history,
+    long_description='For more information see https://data-wrangler.readthedocs.io/en/latest/',
+    long_description_content_type='text/x-rst',
     include_package_data=True,
-    keywords='datawrangler',
-    name='datawrangler',
+    keywords=['datawrangler', 'pydata-wrangler', 'python', 'pandas', 'natural language processing', 'image',
+              'data science', 'data manipulation'],
+    name='pydata-wrangler',
     packages=find_packages(include=['datawrangler', 'datawrangler.*']),
     test_suite='tests',
     tests_require=test_requirements,
     url='https://github.com/ContextLab/data-wrangler',
-    version='0.1.0',
+    version='0.1.7',
     zip_safe=False,
 )


Test patch:
diff --git a/tests/wrangler/__init__.py b/tests/wrangler/__init__.py
index e69de29..ec40a07 100644
--- a/tests/wrangler/__init__.py
+++ b/tests/wrangler/__init__.py
@@ -0,0 +1,10 @@
+# comment out to run tests MUCH faster...
+
+# import datawrangler as dw
+# import os
+# from glob import glob as lsdir
+#
+# # reset data directory
+# data_directory = eval(dw.core.get_default_options()['data']['datadir'])
+# for f in lsdir(os.path.join(data_directory, '*.*')):
+#     os.remove(f)
diff --git a/tests/wrangler/conftest.py b/tests/wrangler/conftest.py
index 8d27033..ac12299 100644
--- a/tests/wrangler/conftest.py
+++ b/tests/wrangler/conftest.py
@@ -13,16 +13,31 @@ def data_file(resources):
     return os.path.join(resources, 'testdata.csv')
 
 
+@pytest.fixture
+def data_url():
+    return 'https://raw.githubusercontent.com/ContextLab/data-wrangler/main/tests/resources/testdata.csv'
+
+
 @pytest.fixture
 def img_file(resources):
     return os.path.join(resources, 'wrangler.jpg')
 
 
+@pytest.fixture
+def img_url():
+    return 'https://raw.githubusercontent.com/ContextLab/data-wrangler/main/tests/resources/wrangler.jpg'
+
+
 @pytest.fixture
 def text_file(resources):
     return os.path.join(resources, 'home_on_the_range.txt')
 
 
+@pytest.fixture
+def text_url():
+    return 'https://raw.githubusercontent.com/ContextLab/data-wrangler/main/tests/resources/home_on_the_range.txt'
+
+
 @pytest.fixture
 def data(data_file):
     return pd.read_csv(data_file, index_col=0)
diff --git a/tests/wrangler/test_core.py b/tests/wrangler/test_core.py
index d845441..cb6a344 100644
--- a/tests/wrangler/test_core.py
+++ b/tests/wrangler/test_core.py
@@ -18,11 +18,11 @@ def test_get_default_options():
     assert 'CountVectorizer' in keys
 
     assert 'text' in keys
-    assert defaults['text']['model'] == ['CountVectorizer', 'LatentDirichletAllocation']
+    assert eval(defaults['text']['model']) == ['CountVectorizer', 'LatentDirichletAllocation']
 
     assert 'data' in keys
-    assert os.path.exists(defaults['data']['homedir'])
-    assert os.path.exists(defaults['data']['datadir'])
+    assert os.path.exists(eval(defaults['data']['homedir']))
+    assert os.path.exists(eval(defaults['data']['datadir']))
 
 
 def test_apply_defaults():
@@ -32,7 +32,7 @@ def test_apply_defaults():
     cv2 = dw.core.apply_defaults(CountVectorizer)().get_params()
 
     for k in defaults.keys():
-        assert cv2[k] == defaults[k]
+        assert cv2[k] == eval(defaults[k])
 
     for k in cv1.keys():
         if k not in defaults.keys():
diff --git a/tests/wrangler/test_decorate.py b/tests/wrangler/test_decorate.py
index ee236af..b9f934a 100644
--- a/tests/wrangler/test_decorate.py
+++ b/tests/wrangler/test_decorate.py
@@ -44,7 +44,7 @@ def f(x):
                                   text_kwargs=text_kwargs,
                                   wrangle_kwargs=wrangle_kwargs)
 
-    correct_dtypes = ['dataframe', 'dataframe', 'array', 'image', 'text']
+    correct_dtypes = ['dataframe', 'dataframe', 'array', 'array', 'text']
     assert all([i == c for i, c in zip(inferred_dtypes, correct_dtypes)])
 
     assert np.allclose(wrangled[0].values, wrangled[1].values)
@@ -70,6 +70,7 @@ def test_interpolate(data):
     def f(x):
         return x
 
+    # noinspection PyCallingNonCallable
     recovered_data1 = f(impute_test, interp_kwargs={'impute_kwargs': {'model': 'IterativeImputer'}})
     assert np.allclose(data, recovered_data1)
     assert dw.zoo.is_dataframe(data)
@@ -78,6 +79,7 @@ def f(x):
     # test interpolation
     interp_test = data.copy()
     interp_test.loc[5] = np.nan
+    # noinspection PyCallingNonCallable
     recovered_data2 = f(interp_test, interp_kwargs={'method': 'linear'})
     assert np.allclose(data, recovered_data2)
     assert dw.zoo.is_dataframe(data)
@@ -90,6 +92,7 @@ def f(x):
     impute_interp_test.loc[8, 'FifthDim'] = np.nan
     impute_interp_test.loc[4] = np.nan
 
+    # noinspection PyCallingNonCallable
     recovered_data3 = f(impute_interp_test, interp_kwargs={'impute_kwargs': {'model': 'IterativeImputer'},
                                                            'method': 'pchip'})
     assert np.allclose(recovered_data3.values[~np.isnan(impute_interp_test)],
@@ -104,17 +107,42 @@ def test_apply_unstacked(data):
     data2 = data.iloc[i:]
     stacked_data = dw.stack([data1, data2])
 
-    assert np.allclose(dw.stack(stacked_data), data)
+    assert np.allclose(stacked_data, data)
 
     @dw.decorate.apply_unstacked
     def f(x):
-        return x.mean(axis=0)
+        return pd.DataFrame(x.mean(axis=0)).T
 
     means = f(stacked_data)
     assert dw.zoo.is_multiindex_dataframe(means)
     assert np.allclose(means.iloc[0], data1.mean(axis=0))
     assert np.allclose(means.iloc[1], data2.mean(axis=0))
 
+    xs = [np.cumsum(np.random.randn(100, 5), axis=0) for _ in range(10)]
+
+    @dw.decorate.apply_unstacked
+    def g(x):
+        return x
+
+    assert all(np.allclose(x, y) for x, y in zip(xs, g(xs)))
+    assert all(np.allclose(x, y) for x, y in zip(xs, dw.unstack(g(dw.stack(xs)))))
+
+
+def test_unstack(data):
+    xs = dw.wrangle([np.cumsum(np.random.randn(100, 5), axis=0) for _ in range(10)])
+    ys = dw.wrangle([np.cumsum(np.random.randn(100, 5), axis=0) for _ in range(10)])
+
+    stacked_xs = dw.stack(xs)
+    stacked_ys = dw.stack(ys)
+    stacked_xy = dw.stack([stacked_xs, stacked_ys])
+
+    assert np.allclose(dw.unstack(stacked_xs)[0], xs[0])
+    assert np.allclose(dw.unstack(stacked_xs)[0].index.values, xs[0].index.values)
+
+    assert np.allclose(dw.unstack(stacked_xy)[0], stacked_xs)
+    assert dw.zoo.is_multiindex_dataframe(dw.unstack(stacked_xy)[0])
+    assert np.allclose(dw.unstack(stacked_xy)[0].index.to_frame(), stacked_xs.index.to_frame())
+
 
 def test_apply_stacked(data):
     i = 4
diff --git a/tests/wrangler/test_io.py b/tests/wrangler/test_io.py
index 4510297..6c2b6aa 100644
--- a/tests/wrangler/test_io.py
+++ b/tests/wrangler/test_io.py
@@ -3,6 +3,7 @@
 """Tests for `datawrangler` package (io module)."""
 
 import datawrangler as dw
+import numpy as np
 
 
 def test_load(data_file, img_file, text_file):
@@ -14,20 +15,19 @@ def test_load(data_file, img_file, text_file):
     assert not dw.zoo.is_dataframe(image)
     assert not dw.zoo.is_dataframe(text)
 
-    assert not dw.zoo.is_image(data)
-    assert dw.zoo.is_image(image)
-    assert not dw.zoo.is_image(text)
+    assert not dw.zoo.is_array(data)
+    assert dw.zoo.is_array(image)
+    assert not dw.zoo.is_array(text)
 
     assert not dw.zoo.is_text(data)
     assert not dw.zoo.is_text(image)
     assert dw.zoo.is_text(text)
 
 
-def test_save(text_file):
-    remote_file = 'https://raw.githubusercontent.com/ContextLab/data-wrangler/main/tests/resources/home_on_the_range' \
-                  '.txt'
+# noinspection PyUnusedLocal
+def test_save(data_file, data_url, img_file, img_url, text_file, text_url):
+    for dtype in ['data', 'img', 'text']:
+        local = dw.io.load(eval(f'{dtype}_file'))
+        remote = dw.io.load(eval(f'{dtype}_url'))  # requires downloading and saving the remote file
 
-    local_text = dw.io.load(text_file)
-    remote_text = dw.io.load(remote_file)  # calls save and then loads the local version
-
-    assert local_text == remote_text
+        assert np.all(local == remote)
diff --git a/tests/wrangler/test_zoo.py b/tests/wrangler/test_zoo.py
index a8ce3c1..058498e 100644
--- a/tests/wrangler/test_zoo.py
+++ b/tests/wrangler/test_zoo.py
@@ -43,30 +43,12 @@ def test_is_array(data, img_file, text_file, data_file):
     assert not dw.zoo.is_array(data_file)
 
 
-def test_wrangle_array(data):
+def test_wrangle_array(data, img_file):
     df = dw.zoo.wrangle_array(data.values)
     assert dw.zoo.is_dataframe(df)
     assert df.shape == (7, 5)
 
-
-def test_get_image(img_file):
-    img = dw.zoo.image.get_image(img_file)
-    assert img is not None
-    assert img.shape == (1400, 1920, 3)
-    assert np.max(img) == 248
-    assert np.min(img) == 12
-    assert np.isclose(np.mean(img), 152.193)
-
-
-def test_is_image(img_file, data, data_file, text_file):
-    assert dw.zoo.is_image(img_file)
-    assert not dw.zoo.is_image(data)
-    assert not dw.zoo.is_image(data_file)
-    assert not dw.zoo.is_image(text_file)
-
-
-def test_wrangle_image(img_file):
-    df = dw.zoo.wrangle_image(img_file)
+    df = dw.zoo.wrangle_array(img_file)
     assert df.shape == (1400, 5760)
     assert dw.zoo.is_dataframe(df)
     assert np.max(df.values) == 248
@@ -130,21 +112,12 @@ def test_wrangle_text_sklearn(text_file):
     assert np.allclose(cv[i:], cv2[1])
 
     # scikit-learn CountVectorizer + LatentDirichletAllocation
-    text_kwargs = {'model': ['CountVectorizer', 'LatentDirichletAllocation']}
+    text_kwargs = {'model': ['CountVectorizer', 'LatentDirichletAllocation'], 'corpus': 'sotus'}
     lda = dw.wrangle(text, text_kwargs=text_kwargs)
     assert lda.shape == (24, 50)
     assert dw.util.btwn(lda, 0, 1)
     assert np.allclose(lda.sum(axis=1), 1)
 
-    lda2 = dw.wrangle(text)  # default model: ['CountVectorizer', 'LatentDirichletAllocation']
-    assert lda2.shape == lda.shape
-    assert dw.util.btwn(lda2, 0, 1)
-    assert np.allclose(lda2.sum(axis=1), 1)
-
-    # check that the same lines of text received non-uniform topic weights
-    assert np.allclose(np.max(lda, axis=1) > 1 / lda.shape[1], np.max(lda2, axis=1) > 1 / lda2.shape[1])
-    assert np.where(np.max(lda, axis=1) > 1 / lda.shape[1])[0].tolist() == [1, 5, 8, 10, 11, 13, 16, 18, 21]
-
     # scikit-learn TfidfVectorizer + NMF
     text_kwargs = {'model': ['TfidfVectorizer', {'model': 'NMF', 'args': [], 'kwargs': {'n_components': 25}}],
                    'corpus': 'sotus'}
@@ -168,7 +141,8 @@ def test_wrangle_text_hugging_face(text_file):
                         +0.0083214, -0.0095522, -0.0250349, -0.0261115, -0.0308725, -0.0095388,
                         -0.0167642, -0.0208202, +0.0083214, -0.0095522, -0.0250349, -0.0261115])
 
-    distilbert_kwargs = {'model': {'model': 'TransformerDocumentEmbeddings', 'args': ['distilbert-base-uncased'], 'kwargs': {}}}
+    distilbert_kwargs = {'model': {'model': 'TransformerDocumentEmbeddings', 'args': ['distilbert-base-uncased'],
+                                   'kwargs': {}}}
     distilbert_embeddings = dw.wrangle(text, text_kwargs=distilbert_kwargs)
     assert distilbert_embeddings.shape == (24, 768)
     assert np.isclose(distilbert_embeddings.mean(axis=0).mean(axis=0), -0.0088198)