diff --git a/.travis.yml b/.travis.yml
index d5706bb..32f8b77 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,11 +1,11 @@
 language: python
 
 python:
-  - 2.6
-  - 2.7
+  - 3.2
+  - 3.3
 
 before_install:
-    pip install --use-mirrors nose unittest2 pymongo
+    pip install --use-mirrors six nose pymongo
 
 install:
   - python setup.py install
diff --git a/README.md b/README.md
index d79e273..dcace39 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,15 @@
+## MongoKit-Py3 [![Build Status](https://travis-ci.org/aquavitae/mongokit-py3.png?branch=master)](https://travis-ci.org/aquavitae/mongokit-py3)
+
+This is a fork of [MongoKit](https://github.com/namlook/mongokit) for Python 3. The readme below is taken directly from 
+that project, and all the documentation can be view there, with the following differences:
+
+ * All references to ``unicode`` have been replaced with ``str``.
+ * ``basestring`` does not exist in Python 3, so it has mostly been replaced with ``bytes``, except for a few cases 
+   where it is obvious from the context that ``str`` was intended instead.
+ * Data stored in GridFS must be ``bytes``.  If a ``str`` is used, it should be encoded to ``bytes`` first.
+
+*--- Original Readme follows ---*
+
 # MongoKit [![Build Status](https://travis-ci.org/namlook/mongokit.png)](https://travis-ci.org/namlook/mongokit.png)
 
 [MongoDB](http://www.mongodb.org/display/DOCS/Home) is a great schema-less document oriented database. It has a lot of drivers for many languages (python, ruby, perl, java, php...).
diff --git a/doc/gridfs.txt b/doc/gridfs.txt
index 0e49f90..ac97258 100644
--- a/doc/gridfs.txt
+++ b/doc/gridfs.txt
@@ -53,7 +53,7 @@ And that's it ! By doing this, MongoKit will open a GridFile,
 fill it with the value, and close it.
 
 Note that you have to be careful to the type : attachments
-only accept string.
+only accept string (Python 2) or bytes (Python 3).
 
 You can read any attachment in a very simple way :
 
diff --git a/doc/structure.txt b/doc/structure.txt
index 6f40e08..33e30a0 100644
--- a/doc/structure.txt
+++ b/doc/structure.txt
@@ -12,9 +12,11 @@ types::
     - bool 
     - int 
     - float
-    - long
-    - basestring
-    - unicode
+    - long # Python 2 only
+    - basestring # Python 2 only
+	- bytes # Python 3 only
+    - unicode # Python 2 only
+    - str # Python 3 only
     - list
     - dict
     - datetime.datetime
diff --git a/ez_setup.py b/ez_setup.py
index 83b1acc..1eefe0d 100644
--- a/ez_setup.py
+++ b/ez_setup.py
@@ -1,11 +1,11 @@
 #!python
-"""Bootstrap setuptools installation
+"""Bootstrap distribute installation
 
 If you want to use setuptools in your package's setup.py, just include this
 file in the same directory with it, and add this to the top of your setup.py::
 
-    from ez_setup import use_setuptools
-    use_setuptools()
+from distribute_setup import use_setuptools
+use_setuptools()
 
 If you want to require a specific version of setuptools, set a download
 mirror, or use an alternate download directory, you can do so by supplying
@@ -13,264 +13,473 @@
 
 This file can also be run as a script to install or upgrade setuptools.
 """
+import os
 import sys
-DEFAULT_VERSION = "0.6c7"
-DEFAULT_URL     = "http://pypi.python.org/packages/%s/s/setuptools/" % sys.version[:3]
-
-md5_data = {
-    'setuptools-0.6b1-py2.3.egg': '8822caf901250d848b996b7f25c6e6ca',
-    'setuptools-0.6b1-py2.4.egg': 'b79a8a403e4502fbb85ee3f1941735cb',
-    'setuptools-0.6b2-py2.3.egg': '5657759d8a6d8fc44070a9d07272d99b',
-    'setuptools-0.6b2-py2.4.egg': '4996a8d169d2be661fa32a6e52e4f82a',
-    'setuptools-0.6b3-py2.3.egg': 'bb31c0fc7399a63579975cad9f5a0618',
-    'setuptools-0.6b3-py2.4.egg': '38a8c6b3d6ecd22247f179f7da669fac',
-    'setuptools-0.6b4-py2.3.egg': '62045a24ed4e1ebc77fe039aa4e6f7e5',
-    'setuptools-0.6b4-py2.4.egg': '4cb2a185d228dacffb2d17f103b3b1c4',
-    'setuptools-0.6c1-py2.3.egg': 'b3f2b5539d65cb7f74ad79127f1a908c',
-    'setuptools-0.6c1-py2.4.egg': 'b45adeda0667d2d2ffe14009364f2a4b',
-    'setuptools-0.6c2-py2.3.egg': 'f0064bf6aa2b7d0f3ba0b43f20817c27',
-    'setuptools-0.6c2-py2.4.egg': '616192eec35f47e8ea16cd6a122b7277',
-    'setuptools-0.6c3-py2.3.egg': 'f181fa125dfe85a259c9cd6f1d7b78fa',
-    'setuptools-0.6c3-py2.4.egg': 'e0ed74682c998bfb73bf803a50e7b71e',
-    'setuptools-0.6c3-py2.5.egg': 'abef16fdd61955514841c7c6bd98965e',
-    'setuptools-0.6c4-py2.3.egg': 'b0b9131acab32022bfac7f44c5d7971f',
-    'setuptools-0.6c4-py2.4.egg': '2a1f9656d4fbf3c97bf946c0a124e6e2',
-    'setuptools-0.6c4-py2.5.egg': '8f5a052e32cdb9c72bcf4b5526f28afc',
-    'setuptools-0.6c5-py2.3.egg': 'ee9fd80965da04f2f3e6b3576e9d8167',
-    'setuptools-0.6c5-py2.4.egg': 'afe2adf1c01701ee841761f5bcd8aa64',
-    'setuptools-0.6c5-py2.5.egg': 'a8d3f61494ccaa8714dfed37bccd3d5d',
-    'setuptools-0.6c6-py2.3.egg': '35686b78116a668847237b69d549ec20',
-    'setuptools-0.6c6-py2.4.egg': '3c56af57be3225019260a644430065ab',
-    'setuptools-0.6c6-py2.5.egg': 'b2f8a7520709a5b34f80946de5f02f53',
-    'setuptools-0.6c7-py2.3.egg': '209fdf9adc3a615e5115b725658e13e2',
-    'setuptools-0.6c7-py2.4.egg': '5a8f954807d46a0fb67cf1f26c55a82e',
-    'setuptools-0.6c7-py2.5.egg': '45d2ad28f9750e7434111fde831e8372',
-    'setuptools-0.6c8-py2.3.egg': '50759d29b349db8cfd807ba8303f1902',
-    'setuptools-0.6c8-py2.4.egg': 'cba38d74f7d483c06e9daa6070cce6de',
-    'setuptools-0.6c8-py2.5.egg': '1721747ee329dc150590a58b3e1ac95b',
-    'setuptools-0.6c9-py2.3.egg': 'a83c4020414807b496e4cfbe08507c03',
-    'setuptools-0.6c9-py2.4.egg': '260a2be2e5388d66bdaee06abec6342a',
-    'setuptools-0.6c9-py2.5.egg': 'fe67c3e5a17b12c0e7c541b7ea43a8e6',
-    'setuptools-0.6c9-py2.6.egg': 'ca37b1ff16fa2ede6e19383e7b59245a',
-}
-
-import sys, os
-try: from hashlib import md5
-except ImportError: from md5 import md5
-
-def _validate_md5(egg_name, data):
-    if egg_name in md5_data:
-        digest = md5(data).hexdigest()
-        if digest != md5_data[egg_name]:
-            print >>sys.stderr, (
-                "md5 validation of %s failed!  (Possible download problem?)"
-                % egg_name
-            )
-            sys.exit(2)
-    return data
-
-def use_setuptools(
-    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
-    download_delay=15
-):
-    """Automatically find/download setuptools and make it available on sys.path
-
-    `version` should be a valid setuptools version number that is available
-    as an egg for download under the `download_base` URL (which should end with
-    a '/').  `to_dir` is the directory where setuptools will be downloaded, if
-    it is not already available.  If `download_delay` is specified, it should
-    be the number of seconds that will be paused before initiating a download,
-    should one be required.  If an older version of setuptools is installed,
-    this routine will print a message to ``sys.stderr`` and raise SystemExit in
-    an attempt to abort the calling script.
-    """
-    was_imported = 'pkg_resources' in sys.modules or 'setuptools' in sys.modules
-    def do_download():
-        egg = download_setuptools(version, download_base, to_dir, download_delay)
-        sys.path.insert(0, egg)
-        import setuptools; setuptools.bootstrap_install_from = egg
+import time
+import fnmatch
+import tempfile
+import tarfile
+from distutils import log
+
+try:
+    from site import USER_SITE
+except ImportError:
+    USER_SITE = None
+
+try:
+    import subprocess
+
+    def _python_cmd(*args):
+        args = (sys.executable,) + args
+        return subprocess.call(args) == 0
+
+except ImportError:
+    # will be used for python 2.3
+    def _python_cmd(*args):
+        args = (sys.executable,) + args
+        # quoting arguments if windows
+        if sys.platform == 'win32':
+            def quote(arg):
+                if ' ' in arg:
+                    return '"%s"' % arg
+                return arg
+            args = [quote(arg) for arg in args]
+        return os.spawnl(os.P_WAIT, sys.executable, *args) == 0
+
+DEFAULT_VERSION = "0.6.14"
+DEFAULT_URL = "http://pypi.python.org/packages/source/d/distribute/"
+SETUPTOOLS_FAKED_VERSION = "0.6c11"
+
+SETUPTOOLS_PKG_INFO = """\
+Metadata-Version: 1.0
+Name: setuptools
+Version: %s
+Summary: xxxx
+Home-page: xxx
+Author: xxx
+Author-email: xxx
+License: xxx
+Description: xxx
+""" % SETUPTOOLS_FAKED_VERSION
+
+
+def _install(tarball):
+    # extracting the tarball
+    tmpdir = tempfile.mkdtemp()
+    log.warn('Extracting in %s', tmpdir)
+    old_wd = os.getcwd()
     try:
-        import pkg_resources
-    except ImportError:
-        return do_download()       
+        os.chdir(tmpdir)
+        tar = tarfile.open(tarball)
+        _extractall(tar)
+        tar.close()
+
+        # going in the directory
+        subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
+        os.chdir(subdir)
+        log.warn('Now working in %s', subdir)
+
+        # installing
+        log.warn('Installing Distribute')
+        if not _python_cmd('setup.py', 'install'):
+            log.warn('Something went wrong during the installation.')
+            log.warn('See the error message above.')
+    finally:
+        os.chdir(old_wd)
+
+
+def _build_egg(egg, tarball, to_dir):
+    # extracting the tarball
+    tmpdir = tempfile.mkdtemp()
+    log.warn('Extracting in %s', tmpdir)
+    old_wd = os.getcwd()
     try:
-        pkg_resources.require("setuptools>="+version); return
-    except pkg_resources.VersionConflict, e:
-        if was_imported:
-            print >>sys.stderr, (
-            "The required version of setuptools (>=%s) is not available, and\n"
-            "can't be installed while this script is running. Please install\n"
-            " a more recent version first, using 'easy_install -U setuptools'."
-            "\n\n(Currently using %r)"
-            ) % (version, e.args[0])
-            sys.exit(2)
-        else:
-            del pkg_resources, sys.modules['pkg_resources']    # reload ok
-            return do_download()
-    except pkg_resources.DistributionNotFound:
-        return do_download()
-
-def download_setuptools(
-    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
-    delay = 15
-):
-    """Download setuptools from a specified location and return its filename
-
-    `version` should be a valid setuptools version number that is available
-    as an egg for download under the `download_base` URL (which should end
-    with a '/'). `to_dir` is the directory where the egg will be downloaded.
-    `delay` is the number of seconds to pause before an actual download attempt.
-    """
-    import urllib2, shutil
-    egg_name = "setuptools-%s-py%s.egg" % (version,sys.version[:3])
-    url = download_base + egg_name
-    saveto = os.path.join(to_dir, egg_name)
+        os.chdir(tmpdir)
+        tar = tarfile.open(tarball)
+        _extractall(tar)
+        tar.close()
+
+        # going in the directory
+        subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
+        os.chdir(subdir)
+        log.warn('Now working in %s', subdir)
+
+        # building an egg
+        log.warn('Building a Distribute egg in %s', to_dir)
+        _python_cmd('setup.py', '-q', 'bdist_egg', '--dist-dir', to_dir)
+
+    finally:
+        os.chdir(old_wd)
+    # returning the result
+    log.warn(egg)
+    if not os.path.exists(egg):
+        raise IOError('Could not build the egg.')
+
+
+def _do_download(version, download_base, to_dir, download_delay):
+    egg = os.path.join(to_dir, 'distribute-%s-py%d.%d.egg'
+                       % (version, sys.version_info[0], sys.version_info[1]))
+    if not os.path.exists(egg):
+        tarball = download_setuptools(version, download_base,
+                                      to_dir, download_delay)
+        _build_egg(egg, tarball, to_dir)
+    sys.path.insert(0, egg)
+    import setuptools
+    setuptools.bootstrap_install_from = egg
+
+
+def use_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
+                   to_dir=os.curdir, download_delay=15, no_fake=True):
+    # making sure we use the absolute path
+    to_dir = os.path.abspath(to_dir)
+    was_imported = 'pkg_resources' in sys.modules or \
+        'setuptools' in sys.modules
+    try:
+        try:
+            import pkg_resources
+            if not hasattr(pkg_resources, '_distribute'):
+                if not no_fake:
+                    _fake_setuptools()
+                raise ImportError
+        except ImportError:
+            return _do_download(version, download_base, to_dir, download_delay)
+        try:
+            pkg_resources.require("distribute>="+version)
+            return
+        except pkg_resources.VersionConflict:
+            e = sys.exc_info()[1]
+            if was_imported:
+                sys.stderr.write(
+                "The required version of distribute (>=%s) is not available,\n"
+                "and can't be installed while this script is running. Please\n"
+                "install a more recent version first, using\n"
+                "'easy_install -U distribute'."
+                "\n\n(Currently using %r)\n" % (version, e.args[0]))
+                sys.exit(2)
+            else:
+                del pkg_resources, sys.modules['pkg_resources'] # reload ok
+                return _do_download(version, download_base, to_dir,
+                                    download_delay)
+        except pkg_resources.DistributionNotFound:
+            return _do_download(version, download_base, to_dir,
+                                download_delay)
+    finally:
+        if not no_fake:
+            _create_fake_setuptools_pkg_info(to_dir)
+
+def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
+                        to_dir=os.curdir, delay=15):
+    """Download distribute from a specified location and return its filename
+
+`version` should be a valid distribute version number that is available
+as an egg for download under the `download_base` URL (which should end
+with a '/'). `to_dir` is the directory where the egg will be downloaded.
+`delay` is the number of seconds to pause before an actual download
+attempt.
+"""
+    # making sure we use the absolute path
+    to_dir = os.path.abspath(to_dir)
+    try:
+        from urllib.request import urlopen
+    except ImportError:
+        from urllib2 import urlopen
+    tgz_name = "distribute-%s.tar.gz" % version
+    url = download_base + tgz_name
+    saveto = os.path.join(to_dir, tgz_name)
     src = dst = None
-    if not os.path.exists(saveto):  # Avoid repeated downloads
+    if not os.path.exists(saveto): # Avoid repeated downloads
         try:
-            from distutils import log
-            if delay:
-                log.warn("""
----------------------------------------------------------------------------
-This script requires setuptools version %s to run (even to display
-help).  I will attempt to download it for you (from
-%s), but
-you may need to enable firewall access for this script first.
-I will start the download in %d seconds.
-
-(Note: if this machine does not have network access, please obtain the file
-
-   %s
-
-and place it in this directory before rerunning this script.)
----------------------------------------------------------------------------""",
-                    version, download_base, delay, url
-                ); from time import sleep; sleep(delay)
             log.warn("Downloading %s", url)
-            src = urllib2.urlopen(url)
+            src = urlopen(url)
             # Read/write all in one block, so we don't create a corrupt file
             # if the download is interrupted.
-            data = _validate_md5(egg_name, src.read())
-            dst = open(saveto,"wb"); dst.write(data)
+            data = src.read()
+            dst = open(saveto, "wb")
+            dst.write(data)
         finally:
-            if src: src.close()
-            if dst: dst.close()
+            if src:
+                src.close()
+            if dst:
+                dst.close()
     return os.path.realpath(saveto)
 
+def _no_sandbox(function):
+    def __no_sandbox(*args, **kw):
+        try:
+            from setuptools.sandbox import DirectorySandbox
+            if not hasattr(DirectorySandbox, '_old'):
+                def violation(*args):
+                    pass
+                DirectorySandbox._old = DirectorySandbox._violation
+                DirectorySandbox._violation = violation
+                patched = True
+            else:
+                patched = False
+        except ImportError:
+            patched = False
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-def main(argv, version=DEFAULT_VERSION):
-    """Install or upgrade setuptools and EasyInstall"""
-    try:
-        import setuptools
-    except ImportError:
-        egg = None
         try:
-            egg = download_setuptools(version, delay=0)
-            sys.path.insert(0,egg)
-            from setuptools.command.easy_install import main
-            return main(list(argv)+[egg])   # we're done here
+            return function(*args, **kw)
         finally:
-            if egg and os.path.exists(egg):
-                os.unlink(egg)
-    else:
-        if setuptools.__version__ == '0.0.1':
-            print >>sys.stderr, (
-            "You have an obsolete version of setuptools installed.  Please\n"
-            "remove it from your system entirely before rerunning this script."
-            )
-            sys.exit(2)
-
-    req = "setuptools>="+version
-    import pkg_resources
+            if patched:
+                DirectorySandbox._violation = DirectorySandbox._old
+                del DirectorySandbox._old
+
+    return __no_sandbox
+
+def _patch_file(path, content):
+    """Will backup the file then patch it"""
+    existing_content = open(path).read()
+    if existing_content == content:
+        # already patched
+        log.warn('Already patched.')
+        return False
+    log.warn('Patching...')
+    _rename_path(path)
+    f = open(path, 'w')
     try:
-        pkg_resources.require(req)
-    except pkg_resources.VersionConflict:
-        try:
-            from setuptools.command.easy_install import main
-        except ImportError:
-            from easy_install import main
-        main(list(argv)+[download_setuptools(delay=0)])
-        sys.exit(0) # try to force an exit
+        f.write(content)
+    finally:
+        f.close()
+    return True
+
+_patch_file = _no_sandbox(_patch_file)
+
+def _same_content(path, content):
+    return open(path).read() == content
+
+def _rename_path(path):
+    new_name = path + '.OLD.%s' % time.time()
+    log.warn('Renaming %s into %s', path, new_name)
+    os.rename(path, new_name)
+    return new_name
+
+def _remove_flat_installation(placeholder):
+    if not os.path.isdir(placeholder):
+        log.warn('Unkown installation at %s', placeholder)
+        return False
+    found = False
+    for file in os.listdir(placeholder):
+        if fnmatch.fnmatch(file, 'setuptools*.egg-info'):
+            found = True
+            break
+    if not found:
+        log.warn('Could not locate setuptools*.egg-info')
+        return
+
+    log.warn('Removing elements out of the way...')
+    pkg_info = os.path.join(placeholder, file)
+    if os.path.isdir(pkg_info):
+        patched = _patch_egg_dir(pkg_info)
     else:
-        if argv:
-            from setuptools.command.easy_install import main
-            main(argv)
+        patched = _patch_file(pkg_info, SETUPTOOLS_PKG_INFO)
+
+    if not patched:
+        log.warn('%s already patched.', pkg_info)
+        return False
+    # now let's move the files out of the way
+    for element in ('setuptools', 'pkg_resources.py', 'site.py'):
+        element = os.path.join(placeholder, element)
+        if os.path.exists(element):
+            _rename_path(element)
         else:
-            print "Setuptools version",version,"or greater has been installed."
-            print '(Run "ez_setup.py -U setuptools" to reinstall or upgrade.)'
-
-def update_md5(filenames):
-    """Update our built-in md5 registry"""
-
-    import re
-
-    for name in filenames:
-        base = os.path.basename(name)
-        f = open(name,'rb')
-        md5_data[base] = md5(f.read()).hexdigest()
+            log.warn('Could not find the %s element of the '
+                     'Setuptools distribution', element)
+    return True
+
+_remove_flat_installation = _no_sandbox(_remove_flat_installation)
+
+def _after_install(dist):
+    log.warn('After install bootstrap.')
+    placeholder = dist.get_command_obj('install').install_purelib
+    _create_fake_setuptools_pkg_info(placeholder)
+
+def _create_fake_setuptools_pkg_info(placeholder):
+    if not placeholder or not os.path.exists(placeholder):
+        log.warn('Could not find the install location')
+        return
+    pyver = '%s.%s' % (sys.version_info[0], sys.version_info[1])
+    setuptools_file = 'setuptools-%s-py%s.egg-info' % \
+            (SETUPTOOLS_FAKED_VERSION, pyver)
+    pkg_info = os.path.join(placeholder, setuptools_file)
+    if os.path.exists(pkg_info):
+        log.warn('%s already exists', pkg_info)
+        return
+
+    log.warn('Creating %s', pkg_info)
+    f = open(pkg_info, 'w')
+    try:
+        f.write(SETUPTOOLS_PKG_INFO)
+    finally:
         f.close()
 
-    data = ["    %r: %r,\n" % it for it in md5_data.items()]
-    data.sort()
-    repl = "".join(data)
-
-    import inspect
-    srcfile = inspect.getsourcefile(sys.modules[__name__])
-    f = open(srcfile, 'rb'); src = f.read(); f.close()
-
-    match = re.search("\nmd5_data = {\n([^}]+)}", src)
-    if not match:
-        print >>sys.stderr, "Internal error!"
-        sys.exit(2)
-
-    src = src[:match.start(1)] + repl + src[match.end(1):]
-    f = open(srcfile,'w')
-    f.write(src)
-    f.close()
-
+    pth_file = os.path.join(placeholder, 'setuptools.pth')
+    log.warn('Creating %s', pth_file)
+    f = open(pth_file, 'w')
+    try:
+        f.write(os.path.join(os.curdir, setuptools_file))
+    finally:
+        f.close()
 
-if __name__=='__main__':
-    if len(sys.argv)>2 and sys.argv[1]=='--md5update':
-        update_md5(sys.argv[2:])
+_create_fake_setuptools_pkg_info = _no_sandbox(_create_fake_setuptools_pkg_info)
+
+def _patch_egg_dir(path):
+    # let's check if it's already patched
+    pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
+    if os.path.exists(pkg_info):
+        if _same_content(pkg_info, SETUPTOOLS_PKG_INFO):
+            log.warn('%s already patched.', pkg_info)
+            return False
+    _rename_path(path)
+    os.mkdir(path)
+    os.mkdir(os.path.join(path, 'EGG-INFO'))
+    pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
+    f = open(pkg_info, 'w')
+    try:
+        f.write(SETUPTOOLS_PKG_INFO)
+    finally:
+        f.close()
+    return True
+
+_patch_egg_dir = _no_sandbox(_patch_egg_dir)
+
+def _before_install():
+    log.warn('Before install bootstrap.')
+    _fake_setuptools()
+
+
+def _under_prefix(location):
+    if 'install' not in sys.argv:
+        return True
+    args = sys.argv[sys.argv.index('install')+1:]
+    for index, arg in enumerate(args):
+        for option in ('--root', '--prefix'):
+            if arg.startswith('%s=' % option):
+                top_dir = arg.split('root=')[-1]
+                return location.startswith(top_dir)
+            elif arg == option:
+                if len(args) > index:
+                    top_dir = args[index+1]
+                    return location.startswith(top_dir)
+        if arg == '--user' and USER_SITE is not None:
+            return location.startswith(USER_SITE)
+    return True
+
+
+def _fake_setuptools():
+    log.warn('Scanning installed packages')
+    try:
+        import pkg_resources
+    except ImportError:
+        # we're cool
+        log.warn('Setuptools or Distribute does not seem to be installed.')
+        return
+    ws = pkg_resources.working_set
+    try:
+        setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools',
+                                  replacement=False))
+    except TypeError:
+        # old distribute API
+        setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools'))
+
+    if setuptools_dist is None:
+        log.warn('No setuptools distribution found')
+        return
+    # detecting if it was already faked
+    setuptools_location = setuptools_dist.location
+    log.warn('Setuptools installation detected at %s', setuptools_location)
+
+    # if --root or --preix was provided, and if
+    # setuptools is not located in them, we don't patch it
+    if not _under_prefix(setuptools_location):
+        log.warn('Not patching, --root or --prefix is installing Distribute'
+                 ' in another location')
+        return
+
+    # let's see if its an egg
+    if not setuptools_location.endswith('.egg'):
+        log.warn('Non-egg installation')
+        res = _remove_flat_installation(setuptools_location)
+        if not res:
+            return
     else:
-        main(sys.argv[1:])
-
+        log.warn('Egg installation')
+        pkg_info = os.path.join(setuptools_location, 'EGG-INFO', 'PKG-INFO')
+        if (os.path.exists(pkg_info) and
+            _same_content(pkg_info, SETUPTOOLS_PKG_INFO)):
+            log.warn('Already patched.')
+            return
+        log.warn('Patching...')
+        # let's create a fake egg replacing setuptools one
+        res = _patch_egg_dir(setuptools_location)
+        if not res:
+            return
+    log.warn('Patched done.')
+    _relaunch()
+
+
+def _relaunch():
+    log.warn('Relaunching...')
+    # we have to relaunch the process
+    # pip marker to avoid a relaunch bug
+    if sys.argv[:3] == ['-c', 'install', '--single-version-externally-managed']:
+        sys.argv[0] = 'setup.py'
+    args = [sys.executable] + sys.argv
+    sys.exit(subprocess.call(args))
+
+
+def _extractall(self, path=".", members=None):
+    """Extract all members from the archive to the current working
+directory and set owner, modification time and permissions on
+directories afterwards. `path' specifies a different directory
+to extract to. `members' is optional and must be a subset of the
+list returned by getmembers().
+"""
+    import copy
+    import operator
+    from tarfile import ExtractError
+    directories = []
+
+    if members is None:
+        members = self
+
+    for tarinfo in members:
+        if tarinfo.isdir():
+            # Extract directories with a safe mode.
+            directories.append(tarinfo)
+            tarinfo = copy.copy(tarinfo)
+            tarinfo.mode = 448 # decimal for oct 0700
+        self.extract(tarinfo, path)
+
+    # Reverse sort directories.
+    if sys.version_info < (2, 4):
+        def sorter(dir1, dir2):
+            return cmp(dir1.name, dir2.name)
+        directories.sort(sorter)
+        directories.reverse()
+    else:
+        directories.sort(key=operator.attrgetter('name'), reverse=True)
 
+    # Set correct owner, mtime and filemode on directories.
+    for tarinfo in directories:
+        dirpath = os.path.join(path, tarinfo.name)
+        try:
+            self.chown(tarinfo, dirpath)
+            self.utime(tarinfo, dirpath)
+            self.chmod(tarinfo, dirpath)
+        except ExtractError:
+            e = sys.exc_info()[1]
+            if self.errorlevel > 1:
+                raise
+            else:
+                self._dbg(1, "tarfile: %s" % e)
 
 
+def main(argv, version=DEFAULT_VERSION):
+    """Install or upgrade setuptools and EasyInstall"""
+    tarball = download_setuptools()
+    _install(tarball)
 
 
+if __name__ == '__main__':
+    main(sys.argv[1:])
\ No newline at end of file
diff --git a/mongokit/__init__.py b/mongokit/__init__.py
index 3b9a1ad..87f9ad6 100644
--- a/mongokit/__init__.py
+++ b/mongokit/__init__.py
@@ -25,19 +25,19 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-__version__ = "0.9.1"
+__version__ = "0.9.1.1"
 
 from bson.dbref import DBRef
-from cursor import Cursor
-from operators import *
-from schema_document import *
-from mongo_exceptions import *
-from document import Document, ObjectId
-from versioned_document import VersionedDocument
-from database import Database
-from collection import Collection
-from connection import Connection, MongoClient, MongoReplicaSetClient, ReplicaSetConnection
-from master_slave_connection import MasterSlaveConnection
+from .cursor import Cursor
+from .operators import *
+from .schema_document import *
+from .mongo_exceptions import *
+from .document import Document, ObjectId
+from .versioned_document import VersionedDocument
+from .database import Database
+from .collection import Collection
+from .connection import Connection, MongoClient, MongoReplicaSetClient, ReplicaSetConnection
+from .master_slave_connection import MasterSlaveConnection
 from pymongo import (
     ASCENDING as INDEX_ASCENDING,
     DESCENDING as INDEX_DESCENDING,
@@ -48,4 +48,4 @@
     OFF as INDEX_OFF,
     HASHED as INDEX_HASHED
 )
-from migration import DocumentMigration
+from .migration import DocumentMigration
diff --git a/mongokit/auth.py b/mongokit/auth.py
index 2833b30..90bcbc2 100644
--- a/mongokit/auth.py
+++ b/mongokit/auth.py
@@ -25,18 +25,18 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-from mongokit import Document
+from .document import Document
 import hashlib
 import os
 
 
 class User(Document):
     structure = {
-        "_id": unicode,
+        "_id": str,
         "user": {
-            "login": unicode,
-            "password": unicode,  # TODO validator
-            "email": unicode,
+            "login": str,
+            "password": str,  # TODO validator
+            "email": str,
         }
     }
     required_fields = ['user.password', 'user.email']  # what if openid ? password is None
@@ -56,11 +56,15 @@ def del_login(self):
 
     def set_password(self, password):
         """ Hash password on the fly """
-        if isinstance(password, unicode):
+        password_salt = hashlib.sha1(os.urandom(60)).hexdigest()  # Always str
+        if isinstance(password, str):
             password = password.encode('utf-8')
-        password_salt = hashlib.sha1(os.urandom(60)).hexdigest()
+        password_salt = password_salt.encode('utf-8')
         crypt = hashlib.sha1(password + password_salt).hexdigest()
-        self['user']['password'] = unicode(password_salt + crypt, 'utf-8')
+        crypt = crypt.encode('utf-8')
+        password_crypt = password_salt + crypt
+        password_crypt = str(password_crypt, 'utf-8')
+        self['user']['password'] = password_crypt
 
     def get_password(self):
         """ Return the password hashed """
@@ -73,9 +77,10 @@ def del_password(self):
 
     def verify_password(self, password):
         """ Check the password against existing credentials  """
-        if isinstance(password, unicode):
-            password = password.encode('utf-8')
         password_salt = self['user']['password'][:40]
+        if isinstance(password, str):
+            password = password.encode('utf-8')
+        password_salt = password_salt.encode('utf-8')
         crypt_pass = hashlib.sha1(password + password_salt).hexdigest()
         if crypt_pass == self['user']['password'][40:]:
             return True
diff --git a/mongokit/collection.py b/mongokit/collection.py
index 431ac0b..180a014 100644
--- a/mongokit/collection.py
+++ b/mongokit/collection.py
@@ -26,8 +26,8 @@
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 from pymongo.collection import Collection as PymongoCollection
-from mongo_exceptions import MultipleResultsFound
-from cursor import Cursor
+from .mongo_exceptions import MultipleResultsFound
+from .cursor import Cursor
 
 from warnings import warn
 
@@ -55,7 +55,7 @@ def __getattr__(self, key):
                 #self._documents[key].generate_index(self)
             return self._documents[key]
         else:
-            newkey = u"%s.%s" % (self.name, key)
+            newkey = "%s.%s" % (self.name, key)
             if not newkey in self._collections:
                 self._collections[newkey] = Collection(self.database, newkey)
             return self._collections[newkey]
diff --git a/mongokit/connection.py b/mongokit/connection.py
index 89f99cb..56d979c 100644
--- a/mongokit/connection.py
+++ b/mongokit/connection.py
@@ -30,7 +30,7 @@
     from pymongo import MongoReplicaSetClient as PymongoReplicaSetConnection
 except ImportError:
     from pymongo import Connection as PymongoConnection
-from database import Database
+from .database import Database
 
 
 class CallableMixin(object):
@@ -65,13 +65,12 @@ def register(self, obj_list):
             decorator = obj_list
             obj_list = [obj_list]
         # cleanup
-        for dbname, db in self._databases.items():
-            for colname, col in db._collections.items():
-                for docname, doc in col._documents.items():
-                    del col._documents[docname]
-                for obj_name in [obj.__name__ for obj in obj_list]:
-                    if obj_name in col._registered_documents:
-                        del col._registered_documents[obj_name]
+        for db in self._databases.values():
+            for col in db._collections.values():
+                col._documents.clear()
+                for obj in obj_list:
+                    if obj.__name__ in col._registered_documents:
+                        del col._registered_documents[obj.__name__]
         # register
         for obj in obj_list:
             CallableDocument = type(
diff --git a/mongokit/cursor.py b/mongokit/cursor.py
index a943d1d..7fe2ea9 100644
--- a/mongokit/cursor.py
+++ b/mongokit/cursor.py
@@ -50,6 +50,9 @@ def next(self):
         else:
             raise StopIteration
 
+    # Python 3 iterator protocol
+    __next__ = next
+
     def __getitem__(self, index):
         # This will be a cursor if `index` is a slice
         item_or_cursor = super(Cursor, self).__getitem__(index)
diff --git a/mongokit/database.py b/mongokit/database.py
index 4cb7198..35c3a1e 100644
--- a/mongokit/database.py
+++ b/mongokit/database.py
@@ -27,8 +27,8 @@
 
 from pymongo.database import Database as PymongoDatabase
 from bson.dbref import DBRef
-from mongokit.document import Document
-from collection import Collection
+from .document import Document
+from .collection import Collection
 
 
 class Database(PymongoDatabase):
diff --git a/mongokit/document.py b/mongokit/document.py
index 71266f3..043c05b 100644
--- a/mongokit/document.py
+++ b/mongokit/document.py
@@ -25,19 +25,19 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-from mongokit import SchemaDocument, AutoReferenceError
-from mongokit.mongo_exceptions import *
-from mongokit.schema_document import (
+from .mongo_exceptions import *
+from .schema_document import (
     STRUCTURE_KEYWORDS,
     CustomType,
+    SchemaDocument,
     SchemaTypeError,
     SchemaProperties,
     StructureError)
-from mongokit.helpers import (
+from .helpers import (
     totimestamp,
     fromtimestamp,
     DotedDict)
-from mongokit.grid import *
+from .grid import *
 import pymongo
 from bson import BSON
 from bson.binary import Binary
@@ -82,9 +82,9 @@ def _validate_descriptors(cls, attrs):
                     if 'fields' not in index:
                         raise BadIndexError(
                             "'fields' key must be specify in indexes")
-                    for key, value in index.iteritems():
+                    for key, value in index.items():
                         if key == "fields":
-                            if isinstance(value, basestring):
+                            if isinstance(value, str):
                                 if value not in attrs['_namespaces'] and value not in STRUCTURE_KEYWORDS:
                                     raise ValueError(
                                         "Error in indexes: can't find %s in structure" % value)
@@ -93,11 +93,11 @@ def _validate_descriptors(cls, attrs):
                                     raise BadIndexError(
                                         "Error in indexes: a tuple must contain "
                                         "only two value : the field name and the direction")
-                                if not (isinstance(value[1], int) or isinstance(value[1], basestring)):
+                                if not (isinstance(value[1], int) or isinstance(value[1], str)):
                                     raise BadIndexError(
-                                        "Error in %s, the direction must be int or basestring "
+                                        "Error in %s, the direction must be int or string "
                                         "(got %s instead)" % (value[0], type(value[1])))
-                                if not isinstance(value[0], basestring):
+                                if not isinstance(value[0], str):
                                     raise BadIndexError(
                                         "Error in %s, the field name must be string "
                                         "(got %s instead)" % (value[0], type(value[0])))
@@ -135,9 +135,7 @@ def _validate_descriptors(cls, attrs):
                             assert isinstance(value, int)
 
 
-class Document(SchemaDocument):
-
-    __metaclass__ = DocumentProperties
+class Document(SchemaDocument, metaclass=DocumentProperties):
 
     type_field = '_type'
 
@@ -166,7 +164,7 @@ def __init__(self, doc=None, gen_skel=True, collection=None, lang='en', fallback
         super(Document, self).__init__(doc=doc, gen_skel=gen_skel, gen_auth_types=False,
                                        lang=lang, fallback_lang=fallback_lang)
         if self.type_field in self:
-            self[self.type_field] = unicode(self.__class__.__name__)
+            self[self.type_field] = str(self.__class__.__name__)
         # collection
         self.collection = collection
         if collection:
@@ -236,11 +234,11 @@ def validate(self, auto_migrate=False):
             error = None
             try:
                 super(Document, self).validate()
-            except StructureError, e:
+            except StructureError as e:
                 error = e
-            except KeyError, e:
+            except KeyError as e:
                 error = e
-            except SchemaTypeError, e:
+            except SchemaTypeError as e:
                 error = e
             if error:
                 if not self.migration_handler:
@@ -423,7 +421,7 @@ def save(self, uuid=False, validate=None, safe=True, *args, **kwargs):
                 self._make_reference(self, self.structure)
         if '_id' not in self:
             if uuid:
-                self['_id'] = unicode("%s-%s" % (self.__class__.__name__, uuid4()))
+                self['_id'] = str("%s-%s" % (self.__class__.__name__, uuid4()))
         self._process_custom_type('bson', self, self.structure)
         self.collection.save(self, safe=safe, *args, **kwargs)
         self._process_custom_type('python', self, self.structure)
@@ -453,12 +451,12 @@ def generate_index(cls, collection):
 
             if isinstance(given_fields, tuple):
                 fields = [given_fields]
-            elif isinstance(given_fields, basestring):
+            elif isinstance(given_fields, str):
                 fields = [(given_fields, 1)]
             else:
                 fields = []
                 for field in given_fields:
-                    if isinstance(field, basestring):
+                    if isinstance(field, str):
                         field = (field, 1)
                     fields.append(field)
             log.debug('Creating index for %s' % str(given_fields))
@@ -536,7 +534,7 @@ def _convert_to_python(doc, struct):
             raise ImportError("can't import anyjson. Please install it before continuing.")
         obj = self.to_json_type()
         _convert_to_python(obj, self.structure)
-        return unicode(dumps(obj))
+        return str(dumps(obj))
 
     def from_json(self, json):
         """
diff --git a/mongokit/grid.py b/mongokit/grid.py
index 7ecfc3f..e178302 100644
--- a/mongokit/grid.py
+++ b/mongokit/grid.py
@@ -65,7 +65,7 @@ def __setitem__(self, key, value):
         try:
             self.put(value, **spec)
         except TypeError:
-            raise TypeError("GridFS value mus be string not %s" % type(value))
+            raise TypeError("GridFS value must be bytes not %s" % type(value))
 
     def __getattr__(self, key):
         if not key.startswith('_'):
diff --git a/mongokit/helpers.py b/mongokit/helpers.py
index 87a455d..cebeb9d 100644
--- a/mongokit/helpers.py
+++ b/mongokit/helpers.py
@@ -98,7 +98,7 @@ def __init__(self, doc=None, warning=False):
         self.__dotify_dict(self)
 
     def __dotify_dict(self, doc):
-        for k, v in doc.iteritems():
+        for k, v in doc.items():
             if isinstance(v, dict):
                 doc[k] = DotedDict(v)
                 self.__dotify_dict(v)
@@ -206,7 +206,7 @@ def __init__(self, passed_dict, remove_under_type=False, reference=None):
         self.update(final_dict)
 
     def _make_dotation(self, d, final_dict, key=""):
-        for k, v in d.iteritems():
+        for k, v in d.items():
             if isinstance(k, type):
                 k = "$%s" % k.__name__
             if isinstance(v, dict) and v != {}:
diff --git a/mongokit/master_slave_connection.py b/mongokit/master_slave_connection.py
index 9b33dd6..b64a680 100644
--- a/mongokit/master_slave_connection.py
+++ b/mongokit/master_slave_connection.py
@@ -10,7 +10,7 @@
 except ImportError:
     from pymongo import Connection as PymongoConnection
 
-from mongokit.connection import MongoKitConnection
+from .connection import MongoKitConnection
 
 
 class MasterSlaveConnection(MongoKitConnection, PymongoMasterSlaveConnection):
diff --git a/mongokit/migration.py b/mongokit/migration.py
index 268194d..e4fe482 100644
--- a/mongokit/migration.py
+++ b/mongokit/migration.py
@@ -25,8 +25,10 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-from mongokit.helpers import DotCollapsedDict
-from mongokit.mongo_exceptions import *
+from __future__ import print_function
+
+from .helpers import DotCollapsedDict
+from .mongo_exceptions import *
 
 
 class DocumentMigration(object):
@@ -47,7 +49,7 @@ def clean(self):
 
     def validate_update(self, update_query):
         structure = DotCollapsedDict(self.doc_class.structure)
-        for op, fields in update_query.iteritems():
+        for op, fields in update_query.items():
             for field in fields:
                 if op != '$unset' and op != '$rename':
                     if field not in structure:
@@ -84,7 +86,7 @@ def migrate_all(self, collection, safe=True):
                 collection.update(self.target, self.update, multi=True, safe=safe)
                 status = collection.database.last_status()
                 if not status.get('updatedExisting', 1):
-                    print "%s : %s >>> deprecated" % (self.__class__.__name__, method_name)
+                    print("%s : %s >>> deprecated" % (self.__class__.__name__, method_name))
 
     def get_deprecated(self, collection):
         method_names = sorted([i for i in dir(self) if i.startswith('migration') or i.startswith('allmigration')])
diff --git a/mongokit/schema_document.py b/mongokit/schema_document.py
index 33d5526..9d7d049 100644
--- a/mongokit/schema_document.py
+++ b/mongokit/schema_document.py
@@ -33,8 +33,8 @@
 
 log = logging.getLogger(__name__)
 
-from operators import SchemaOperator, IS
-from helpers import *
+from .operators import SchemaOperator, IS
+from .helpers import *
 
 __all__ = [
     'CustomType',
@@ -94,7 +94,19 @@ def validate(self, value, path):
         """
         pass
 
-
+_authorized_types = [
+        type(None),
+        bool,
+        int,
+        float,
+        list,
+        dict,
+        datetime.datetime,
+        CustomType,
+        str,
+        bytes,
+    ]
+    
 # field wich does not need to be declared into the structure
 STRUCTURE_KEYWORDS = []
 
@@ -232,7 +244,7 @@ def _validate_descriptors(cls, attrs):
                     raise ValueError("Error in i18n: can't find %s in structure" % i18n)
 
 
-class SchemaDocument(dict):
+class SchemaDocument(dict, metaclass=SchemaProperties):
     """
     A SchemaDocument is dictionary with a building structured schema
     The validate method will check that the document match the underling
@@ -240,7 +252,7 @@ class SchemaDocument(dict):
 
     >>> class TestDoc(SchemaDocument):
     ...     structure = {
-    ...         "foo":unicode,
+    ...         "foo":str,
     ...         "bar":int,
     ...         "nested":{
     ...            "bla":float}}
@@ -303,7 +315,6 @@ class SchemaDocument(dict):
     >>> doc
     {"foo":{"bar":u"bla}}
     """
-    __metaclass__ = SchemaProperties
 
     structure = None
     required_fields = []
@@ -322,20 +333,7 @@ class SchemaDocument(dict):
     use_dot_notation = False
     dot_notation_warning = False
 
-    authorized_types = [
-        type(None),
-        bool,
-        int,
-        long,
-        float,
-        unicode,
-        basestring,
-        list,
-        dict,
-        datetime.datetime,
-        bson.binary.Binary,
-        CustomType,
-    ]
+    authorized_types = _authorized_types
 
     def __init__(self, doc=None, gen_skel=True, gen_auth_types=True, validate=True, lang='en', fallback_lang='en'):
         """
@@ -354,7 +352,7 @@ def __init__(self, doc=None, gen_skel=True, gen_auth_types=True, validate=True,
         self.validation_errors = {}
         # init
         if doc:
-            for k, v in doc.iteritems():
+            for k, v in doc.items():
                 self[k] = v
             gen_skel = False
         if gen_skel:
@@ -481,7 +479,7 @@ def __validate_structure(struct, name,  authorized):
                         raise StructureError("%s: %s is not an authorized type" % (name, struct))
             elif isinstance(struct, dict):
                 for key in struct:
-                    if isinstance(key, basestring):
+                    if isinstance(key, str):
                         if "." in key:
                             raise BadKeyError("%s: %s must not contain '.'" % (name, key))
                         if key.startswith('$'):
@@ -490,7 +488,7 @@ def __validate_structure(struct, name,  authorized):
                         if not key in authorized_types:
                             raise AuthorizedTypeError("%s: %s is not an authorized type" % (name, key))
                     else:
-                        raise StructureError("%s: %s must be a basestring or a type" % (name, key))
+                        raise StructureError("%s: %s must be a string or a type" % (name, key))
                     if struct[key] is None:
                         pass
                     elif isinstance(struct[key], dict):
@@ -645,7 +643,7 @@ def _validate_doc(self, doc, struct, path=""):
     def _process_validators(self, doc, struct, path=""):
         doted_struct = DotCollapsedDict(self.structure)
         doted_doc = DotCollapsedDict(doc)
-        for key, validators in self.validators.iteritems():
+        for key, validators in self.validators.items():
             if key in doted_doc and doted_doc[key] is not None:
                 if not hasattr(validators, "__iter__"):
                     validators = [validators]
@@ -653,9 +651,9 @@ def _process_validators(self, doc, struct, path=""):
                     try:
                         if not validator(doted_doc[key]):
                             raise ValidationError("%s does not pass the validator " + validator.__name__)
-                    except Exception, e:
+                    except Exception as e:
                         self._raise_exception(ValidationError, key,
-                                              unicode(e) % key)
+                                              str(e) % key)
 
     def _process_custom_type(self, target, doc, struct, path="", root_path=""):
         for key in struct:
@@ -915,7 +913,7 @@ def __call__(self):
 
     def to_bson(self, value):
         if value is not None:
-            for l, v in value.iteritems():
+            for l, v in value.items():
                 if isinstance(v, list) and isinstance(self._field_type, list):
                     for i in v:
                         if not isinstance(i, self._field_type[0]):
@@ -925,7 +923,7 @@ def to_bson(self, value):
                     if not isinstance(v, self._field_type):
                         raise SchemaTypeError("%s (%s) must be an instance of %s not %s" % (
                                               self._field_name, l, self._field_type, type(v).__name__))
-            return [{'lang': l, 'value': v} for l, v in value.iteritems()]
+            return [{'lang': l, 'value': v} for l, v in value.items()]
 
     def to_python(self, value):
         if value is not None:
diff --git a/mongokit/versioned_document.py b/mongokit/versioned_document.py
index cb2e9c6..42bd232 100644
--- a/mongokit/versioned_document.py
+++ b/mongokit/versioned_document.py
@@ -25,13 +25,13 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-from mongokit import *
-from mongo_exceptions import *
+from .document import Document
+from .mongo_exceptions import *
 
 
 class RevisionDocument(Document):
     structure = {
-        "id": unicode,
+        "id": str,
         "revision": int,
         "doc": dict
     }
@@ -58,7 +58,7 @@ def save(self, versioning=True, *args, **kwargs):
                 self['_revision'] = 0
             self['_revision'] += 1
             super(VersionedDocument, self).save(*args, **kwargs)
-            versionned_doc = RevisionDocument({"id": unicode(self['_id']), "revision": self['_revision']},
+            versionned_doc = RevisionDocument({"id": str(self['_id']), "revision": self['_revision']},
                                               collection=self.versioning_collection)
             versionned_doc['doc'] = dict(self)
             versionned_doc.save()
@@ -97,6 +97,6 @@ def get_revisions(self):
             yield self.__class__(verdoc['doc'], collection=self.collection)
 
     def get_last_revision_id(self):
-        last_doc = self.versioning_collection.find({'id': unicode(self['_id'])}).sort('revision', -1).next()
+        last_doc = self.versioning_collection.find({'id': str(self['_id'])}).sort('revision', -1).next()
         if last_doc:
             return last_doc['revision']
diff --git a/requirements.txt b/requirements.txt
index f71c1f1..a646148 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -6,4 +6,6 @@ nose==1.3.0
 pep8==1.4.6
 pylint==0.28.0
 pymongo==2.5.2
-wsgiref==0.1.2
+six==1.4.1
+## required for python2
+#wsgiref==0.1.2
diff --git a/setup.py b/setup.py
index 26b7ec6..c8bb0c9 100644
--- a/setup.py
+++ b/setup.py
@@ -37,14 +37,14 @@
 import codecs
 
 setup(
-    name = 'mongokit',
-    version = '0.9.1',  # TODO don't forget to change version in __init__
-
-    description = 'Python mongodb kit',
+    name = 'mongokit-py3',
+    version='0.9.1.1',  # TODO don't forget to change version in __init__
+    description='Python mongodb kit - Python 3 fork',
     long_description = codecs.open('README.md', "r", "utf-8").read(),
     author = 'Namlook',
+    maintainer='David Townshend',
     license = 'New BSD License',
-    url = 'http://namlook.github.com/mongokit/',
+    url='http://github.com/aquavitae/mongokit-py3/',
 
     classifiers = [
         'Development Status :: 5 - Production/Stable',
diff --git a/tests/test_api.py b/tests/test_api.py
index c22cf15..01af5ca 100644
--- a/tests/test_api.py
+++ b/tests/test_api.py
@@ -31,6 +31,8 @@
 from bson.objectid import ObjectId
 from pymongo import ReadPreference
 
+import six
+string_type = six.string_types[0]
 
 class ApiTestCase(unittest.TestCase):
     def setUp(self):
@@ -45,31 +47,31 @@ def test_save(self):
         class MyDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
         mydoc.save()
         assert isinstance(mydoc['_id'], ObjectId)
 
         saved_doc = self.col.find_one({"bla.bar":42})
-        for key, value in mydoc.iteritems():
+        for key, value in six.iteritems(mydoc):
             assert saved_doc[key] == value
 
         mydoc = self.col.MyDoc()
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 43
         mydoc.save(uuid=True)
-        assert isinstance(mydoc['_id'], unicode)
+        assert isinstance(mydoc['_id'], str)
         assert mydoc['_id'].startswith("MyDoc"), id
 
         saved_doc = self.col.find_one({"bla.bar":43})
-        for key, value in mydoc.iteritems():
+        for key, value in six.iteritems(mydoc):
             assert saved_doc[key] == value
 
     def test_save_without_collection(self):
@@ -102,7 +104,7 @@ def test_generate_skeleton(self):
         class A(SchemaDocument):
             structure = {
                 "a":{"foo":int},
-                "bar":unicode
+                "bar":str
             }
         a = A(gen_skel=False)
         assert a == {}
@@ -113,7 +115,7 @@ def test_generate_skeleton2(self):
         class A(SchemaDocument):
             structure = {
                 "a":{"foo":[int]},
-                "bar":{unicode:{"egg":int}}
+                "bar":{str:{"egg":int}}
             }
         a = A(gen_skel=False)
         assert a == {}
@@ -123,8 +125,8 @@ class A(SchemaDocument):
     def test_generate_skeleton3(self):
         class A(SchemaDocument):
             structure = {
-                "a":{"foo":[int], "spam":{"bla":unicode}},
-                "bar":{unicode:{"egg":int}}
+                "a":{"foo":[int], "spam":{"bla":str}},
+                "bar":{str:{"egg":int}}
             }
         a = A(gen_skel=False)
         assert a == {}
@@ -177,11 +179,11 @@ class MyDoc(Document):
             allPlans,
             [
                 {
-                    u'cursor': u'BasicCursor',
-                    u'indexBounds': {},
-                    u'nscannedObjects': 10,
-                    u'nscanned': 10,
-                    u'n': 10,
+                    'cursor': 'BasicCursor',
+                    'indexBounds': {},
+                    'nscannedObjects': 10,
+                    'nscanned': 10,
+                    'n': 10,
                 },
             ],
         )
@@ -317,12 +319,12 @@ class DocB(Document):
     def test_fetch_with_query(self):
         class DocA(Document):
             structure = {
-                "bar":unicode,
+                "bar":str,
                 "doc_a":{'foo':int},
             }
         class DocB(Document):
             structure = {
-                "bar":unicode,
+                "bar":str,
                 "doc_b":{"bar":int},
             }
         self.connection.register([DocA, DocB])
@@ -331,18 +333,18 @@ class DocB(Document):
         for i in range(10):
             mydoc = self.col.DocA()
             if i % 2 == 0:
-                mydoc['bar'] = u"spam"
+                mydoc['bar'] = "spam"
             else:
-                mydoc['bar'] = u"egg"
+                mydoc['bar'] = "egg"
             mydoc['doc_a']["foo"] = i
             mydoc.save()
         # creating DocB
         for i in range(5):
             mydoc = self.col.DocB()
             if i % 2 == 0:
-                mydoc['bar'] = u"spam"
+                mydoc['bar'] = "spam"
             else:
-                mydoc['bar'] = u"egg"
+                mydoc['bar'] = "egg"
             mydoc['doc_b']["bar"] = i
             mydoc.save()
 
@@ -437,7 +439,7 @@ class MyDoc(Document):
         # boostraping
         for i in range(10):
             mydoc = mongokit.MyDoc()
-            mydoc['_id'] = unicode(i)
+            mydoc['_id'] = str(i)
             mydoc['foo'] = i
             mydoc.save()
 
@@ -474,7 +476,7 @@ class DocA(Document):
 
         # creating DocA
         mydoc = self.col.DocA()
-        mydoc['doc_a']["foo"] = u'bar'
+        mydoc['doc_a']["foo"] = 'bar'
         assertion = False
         try:
             mydoc.save()
@@ -487,7 +489,7 @@ class DocA(Document):
 
         # creating DocA
         mydoc = self.col.DocA()
-        mydoc['doc_a']["foo"] = u'foo'
+        mydoc['doc_a']["foo"] = 'foo'
         self.assertRaises(SchemaTypeError, mydoc.save, validate=True)
         mydoc.save()
 
@@ -570,21 +572,21 @@ class Section(Document):
     def test_get_size(self):
         class MyDoc(Document):
             structure = {
-                "doc":{"foo":int, "bla":unicode},
+                "doc":{"foo":int, "bla":str},
             }
         self.connection.register([MyDoc])
 
         mydoc = self.col.MyDoc()
         mydoc['doc']['foo'] = 3
-        mydoc['doc']['bla'] = u'bla bla'
+        mydoc['doc']['bla'] = 'bla bla'
         assert mydoc.get_size() == 41, mydoc.get_size()
 
-        mydoc['doc']['bla'] = u'bla bla'+'b'*12
+        mydoc['doc']['bla'] = 'bla bla' + 'b' * 12
         assert mydoc.get_size() == 41+12
 
         mydoc.validate()
 
-        mydoc['doc']['bla'] = u'b'*40000000
+        mydoc['doc']['bla'] = 'b' * 40000000
         self.assertRaises(MaxDocumentSizeError, mydoc.validate)
 
     def test_get_with_no_wrap(self):
@@ -592,7 +594,7 @@ class MyDoc(Document):
             structure = {"foo":int}
         self.connection.register([MyDoc])
 
-        for i in xrange(2000):
+        for i in six.moves.range(2000):
             mydoc = self.col.MyDoc()
             mydoc['foo'] = i
             mydoc.save()
@@ -623,28 +625,28 @@ class MyDoc(Document):
         self.connection.register([MyDoc])
 
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'1'
+        mydoc['_id'] = '1'
         mydoc['foo'] = 1
         mydoc.save()
 
         mydoc = self.connection.test.othercol.MyDoc()
-        mydoc['_id'] = u'2'
+        mydoc['_id'] = '2'
         mydoc['foo'] = 2
         mydoc.save()
 
         mydoc = self.connection.othertest.mongokit.MyDoc()
-        mydoc['_id'] = u'3'
+        mydoc['_id'] = '3'
         mydoc['foo'] = 3
         mydoc.save()
 
         mydoc = self.col.MyDoc.find_one({'foo':1})
-        assert mydoc.get_dbref(), DBRef(u'mongokit', u'1', u'test')
+        assert mydoc.get_dbref(), DBRef('mongokit', '1', 'test')
 
         mydoc = self.connection.test.othercol.MyDoc.find_one({'foo':2})
-        assert mydoc.get_dbref() == DBRef(u'othercol', u'2', u'test')
+        assert mydoc.get_dbref() == DBRef('othercol', '2', 'test')
 
         mydoc = self.connection.othertest.mongokit.MyDoc.find_one({'foo':3})
-        assert mydoc.get_dbref() == DBRef(u'mongokit', u'3', u'othertest')
+        assert mydoc.get_dbref() == DBRef('mongokit', '3', 'othertest')
 
     def test__hash__(self):
         class MyDoc(Document):
@@ -682,14 +684,14 @@ class MyDoc(Document):
             use_dot_notation = True
             structure = {
                 "foo":int,
-                "bar":{"egg":unicode},
+                "bar":{"egg":str},
                 "toto":{"spam":{"bla":int}}
             }
 
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
         mydoc.foo = 3
-        mydoc.bar.egg = u'bla'
+        mydoc.bar.egg = 'bla'
         mydoc.toto.spam.bla = 7
         mydoc.save()
         fetched_doc = self.col.MyDoc.find_one()
@@ -701,12 +703,12 @@ class MyDoc(Document):
     def test_validate_doc_with_field_added_after_save(self):
         class Doc(Document):
            structure = {
-               "foo": unicode,
+               "foo": str,
            }
         self.connection.register([Doc])
 
         doc = self.col.Doc()
-        doc['foo'] = u"bla"
+        doc['foo'] = "bla"
         doc.save()
         doc['bar'] = 2
         self.assertRaises(StructureError, doc.validate)
@@ -714,20 +716,20 @@ class Doc(Document):
     def test_distinct(self):
         class Doc(Document):
             structure = {
-                "foo": unicode,
+                "foo": str,
                 "bla": int
             }
         self.connection.register([Doc])
 
         for i in range(15):
             if i % 2 == 0:
-                foo = u"blo"
+                foo = "blo"
             else:
-                foo = u"bla"
+                foo = "bla"
             doc = self.col.Doc(doc={'foo':foo, 'bla':i})
             doc.save()
         assert self.col.find().distinct('foo') == ['blo', 'bla']
-        assert self.col.find().distinct('bla') == range(15)
+        assert self.col.find().distinct('bla') == list(range(15))
 
     def test_explain(self):
         class MyDoc(Document):
@@ -750,66 +752,68 @@ class MyDoc(Document):
         self.assertEqual(explain1, explain2)
 
     def test_with_long(self):
-        class Doc(Document):
-            structure = {
-                "foo":OR(int, long),
-                "bar":unicode,
-            }
-        self.connection.register([Doc])
-        doc = self.col.Doc()
-        doc['foo'] = 12L
-        doc.save()
-        fetch_doc = self.col.Doc.find_one()
-        fetch_doc['bar'] = u'egg'
-        fetch_doc.save()
+        # Python 2 test only
+        if six.PY2:
+            class Doc(Document):
+                structure = {
+                    "foo":OR(int, long),
+                    "bar":str,
+                }
+            self.connection.register([Doc])
+            doc = self.col.Doc()
+            doc['foo'] = long(12)
+            doc.save()
+            fetch_doc = self.col.Doc.find_one()
+            fetch_doc['bar'] = 'egg'
+            fetch_doc.save()
 
     def test_skip_validation_with_required_field(self):
         class Task(Document):
             structure = {
-                'extra' : unicode,
+                'extra' : str,
             }
             required_fields = ['extra']
             skip_validation = True
         self.connection.register([Task])
         task = self.col.Task()
-        task['extra'] = u'foo'
+        task['extra'] = 'foo'
         task.validate()
 
     def test_passing_collection_in_argument(self):
         class MyDoc(Document):
             structure = {
-                'foo':unicode
+                'foo':str
             }
         doc = MyDoc(collection=self.col)
-        doc['foo'] = u'bla'
+        doc['foo'] = 'bla'
         doc.save()
 
     def test_reload(self):
         class MyDoc(Document):
             structure = {
                 'foo':{
-                    'bar':unicode,
+                    'bar':str,
                     'eggs':{'spam':int},
                 },
-                'bla':unicode
+                'bla':str
             }
         self.connection.register([MyDoc])
 
         doc = self.col.MyDoc()
         self.assertRaises(KeyError, doc.reload)
         doc['_id'] = 3
-        doc['foo']['bar'] = u'mybar'
+        doc['foo']['bar'] = 'mybar'
         doc['foo']['eggs']['spam'] = 4
-        doc['bla'] = u'ble'
+        doc['bla'] = 'ble'
         self.assertRaises(OperationFailure, doc.reload)
         doc.save()
 
-        doc['bla'] = u'bli'
+        doc['bla'] = 'bli'
 
         self.col.update({'_id':doc['_id']}, {'$set':{'foo.eggs.spam':2}})
 
         doc.reload()
-        assert doc == {'_id': 3, 'foo': {u'eggs': {u'spam': 2}, u'bar': u'mybar'}, 'bla': u'ble'}
+        assert doc == {'_id': 3, 'foo': {'eggs': {'spam': 2}, 'bar': 'mybar'}, 'bla': 'ble'}
 
     def test_rewind(self):
         class MyDoc(Document):
@@ -894,7 +898,7 @@ class MyDoc(Document):
             }
         try:
             doc = self.connection.MyDoc()
-        except AttributeError, e:
+        except AttributeError as e:
             failed = True
             self.assertEqual(str(e), 'MyDoc: __collection__ attribute not '
               'found. You cannot specify the `__database__` attribute '
@@ -956,29 +960,29 @@ class Root(Document):
         @self.connection.register
         class DocA(Root):
            __collection__ = "doca"
-           structure = {'title':unicode}
+           structure = {'title':str}
 
         doc = self.connection.DocA()
-        doc['title'] = u'foo'
+        doc['title'] = 'foo'
         doc.save()
 
         self.assertEqual(self.connection.test.doca.find_one(), doc)
 
 
-    def test_basestring_type(self):
+    def test_string_types(self):
         @self.connection.register
         class DocA(Document):
            __database__ = 'test'
            __collection__ = "doca"
-           structure = {'title':unicode}
+           structure = {'title':str}
 
         doc = self.connection.DocA()
-        doc['title'] = 'foo'
+        doc['title'] = six.b('foo')
         failed = False
         try:
             doc.save()
-        except SchemaTypeError, e:
-            self.assertEqual(str(e), "title must be an instance of unicode not str")
+        except SchemaTypeError as e:
+            self.assertEqual(str(e), "title must be an instance of %s not %s" % (str.__name__, six.binary_type.__name__))
             failed = True
         self.assertEqual(failed, True)
 
@@ -987,15 +991,15 @@ class DocA(Document):
            __database__ = 'test'
            __collection__ = "doca"
            authorized_types = Document.authorized_types+[str]
-           structure = {'title':str}
+           structure = {'title':six.binary_type}
 
         doc = self.connection.DocA()
-        doc['title'] = u'foo'
+        doc['title'] = 'foo'
         failed = False
         try:
             doc.save()
-        except SchemaTypeError, e:
-            self.assertEqual(str(e), "title must be an instance of str not unicode")
+        except SchemaTypeError as e:
+            self.assertEqual(str(e), "title must be an instance of %s not %s" % (six.binary_type.__name__, str.__name__))
             failed = True
         self.assertEqual(failed, True)
 
@@ -1004,10 +1008,10 @@ class DocA(Document):
         class DocA(Document):
            __database__ = 'test'
            __collection__ = "doca"
-           structure = {'title':basestring}
+           structure = {'title':string_type}
 
         doc = self.connection.DocA()
-        doc['title'] = u'foo'
+        doc['title'] = 'foo'
         doc.save()
         doc['title'] = 'foo'
         doc.save()
@@ -1026,7 +1030,7 @@ class DocA(Document):
         failed = False
         try:
             doc.save()
-        except SchemaTypeError, e:
+        except SchemaTypeError as e:
             self.assertEqual(str(e), "foo must be an instance of int not float")
             failed = True
         self.assertEqual(failed, True)
@@ -1043,7 +1047,7 @@ class DocA(Document):
         failed = False
         try:
             doc.save()
-        except SchemaTypeError, e:
+        except SchemaTypeError as e:
             self.assertEqual(str(e), "foo must be an instance of float not int")
             failed = True
         self.assertEqual(failed, True)
diff --git a/tests/test_auth.py b/tests/test_auth.py
index d1387a5..59950d7 100644
--- a/tests/test_auth.py
+++ b/tests/test_auth.py
@@ -25,12 +25,16 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from __future__ import print_function
+
 import unittest
 
 from mongokit import *
 from mongokit.auth import User
 from bson.objectid import ObjectId
 
+import six
+
 import logging
 logging.basicConfig()
 
@@ -48,7 +52,7 @@ class SimpleUser(User): pass
         self.connection.register([SimpleUser])
 
         user = self.col.SimpleUser()
-        user.login = u"user"
+        user.login = "user"
         self.assertRaises(RequireFieldError, user.validate)
         user.password = "myp4$$ord"
 
@@ -65,25 +69,25 @@ class SimpleUser(User): pass
         self.connection.register([SimpleUser])
 
         user = self.col.SimpleUser()
-        user.login = u"user"
-        user.email = u"user@foo.bar"
-        user.password = u"u$ser_p4$$w0rd"
-        print "°°°°°°°°°", user
+        user.login = "user"
+        user.email = "user@foo.bar"
+        user.password = "u$ser_p4$$w0rd"
+        print("°°°°°°°°°", user)
         user.save()
 
         saved_user = self.col.SimpleUser.get_from_id('user')
         assert saved_user.verify_password("bad") == False
-        assert saved_user.verify_password(u"u$ser_p4$$w0rd") == True
+        assert saved_user.verify_password("u$ser_p4$$w0rd") == True
 
-        assert user.login == u"user"
-        assert user['_id'] == u'user'
-        assert user['user']['login'] == u'user'
+        assert user.login == "user"
+        assert user['_id'] == 'user'
+        assert user['user']['login'] == 'user'
         del user.login
         assert user['_id'] is None
         assert user['user']['login'] is None
         assert user.login is None
 
-        assert user.email == user['user']['email'] == u'user@foo.bar'
+        assert user.email == user['user']['email'] == 'user@foo.bar'
         del user.email
         assert user['user']['email'] is None
         assert user.email is None
@@ -92,17 +96,17 @@ def test_overload_user(self):
         class SimpleUser(User):
             structure = {
                 "auth":{
-                    "session_id":unicode,
+                    "session_id":str,
                 },
                 "profil":{
-                    "name":unicode,
+                    "name":str,
                 }
             }
         self.connection.register([SimpleUser])
 
         user = self.col.SimpleUser()
-        user.login = u"user"
-        user.email = u"user@foo.bar"
+        user.login = "user"
+        user.email = "user@foo.bar"
         user.password = "u$ser_p4$$w0rd"
         user.save()
 
diff --git a/tests/test_autoref.py b/tests/test_autoref.py
index 4bd5e51..dfeb655 100644
--- a/tests/test_autoref.py
+++ b/tests/test_autoref.py
@@ -33,6 +33,8 @@
 from mongokit import *
 from bson.objectid import ObjectId
 
+import six
+
 class AutoRefTestCase(unittest.TestCase):
     """Tests AutoRef case"""
     def setUp(self):
@@ -102,29 +104,29 @@ class Embed(Document):
         class Doc(Document):
             structure = {
                 'embed':Embed,
-                'eggs': unicode,
+                'eggs': str,
             }
             use_autorefs = True
         self.connection.register([Embed, Doc])
 
         embed = self.col.Embed()
-        embed['foo'] = {'hello':u'monde'}
+        embed['foo'] = {'hello':'monde'}
         embed['bar'] = 3
         embed.save()
 
         doc = self.col.Doc()
         doc['embed'] = embed
-        doc['eggs'] = u'arf'
+        doc['eggs'] = 'arf'
         doc.save()
 
-        assert doc == {'embed': {u'_id': embed['_id'], u'bar': 3, u'foo': {u'hello': u'monde'}}, '_id': doc['_id'], 'eggs': u'arf'}, doc
+        assert doc == {'embed': {'_id': embed['_id'], 'bar': 3, 'foo': {'hello': 'monde'}}, '_id': doc['_id'], 'eggs': 'arf'}, doc
 
         doc = self.col.Doc.fetch_one()
-        doc['embed']['foo']['hello'] = u'World'
+        doc['embed']['foo']['hello'] = 'World'
         doc.save()
 
-        assert doc == {'embed': {u'_id': embed['_id'], u'bar': 3, u'foo': {u'hello': u'World'}}, '_id': doc['_id'], 'eggs': u'arf'}, doc
-        assert self.col.Embed.fetch_one() == {u'_id': embed['_id'], u'bar': 3, u'foo': {u'hello': u'World'}}
+        assert doc == {'embed': {'_id': embed['_id'], 'bar': 3, 'foo': {'hello': 'World'}}, '_id': doc['_id'], 'eggs': 'arf'}, doc
+        assert self.col.Embed.fetch_one() == {'_id': embed['_id'], 'bar': 3, 'foo': {'hello': 'World'}}
 
     def test_autoref_with_default_values(self):
         class DocA(Document):
@@ -191,21 +193,21 @@ def test_badautoref(self):
         """
         class EmbedDoc(Document):
             structure = {
-                "spam": unicode
+                "spam": str
             }
         self.connection.register([EmbedDoc])
         embed = self.col.EmbedDoc()
-        embed["spam"] = u"eggs"
+        embed["spam"] = "eggs"
         embed.save()
         assert embed
 
         class EmbedOtherDoc(Document):
             structure = {
-                "ham": unicode
+                "ham": str
             }
         self.connection.register([EmbedOtherDoc])
         embedOther = self.connection.test.embed_other.EmbedOtherDoc()
-        embedOther["ham"] = u"eggs"
+        embedOther["ham"] = "eggs"
         embedOther.save()
         assert embedOther
 
@@ -213,7 +215,7 @@ class MyDoc(Document):
             use_autorefs = True
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam": EmbedDoc,
@@ -221,7 +223,7 @@ class MyDoc(Document):
             use_autorefs = True
         self.connection.register([MyDoc])
         mydoc = self.connection.test.autoref.MyDoc()
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
         mydoc["spam"] = embedOther
         
@@ -234,18 +236,18 @@ def test_badautoref_not_enabled(self):
 
         class EmbedDoc(Document):
             structure = {
-                "spam": unicode
+                "spam": str
             }
         self.connection.register([EmbedDoc])
         embed = self.connection.test['autoref.embed'].EmbedDoc()
-        embed["spam"] = u"eggs"
+        embed["spam"] = "eggs"
         embed.save()
         assert embed
 
         class MyDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam": EmbedDoc,
@@ -261,20 +263,20 @@ def test_subclass(self):
         
         class EmbedDoc(Document):
             structure = {
-                "spam": unicode
+                "spam": str
             }
         self.connection.register([EmbedDoc])
         embed = self.connection.test['autoref.embed'].EmbedDoc()
-        embed["spam"] = u"eggs"
+        embed["spam"] = "eggs"
         embed.save()
 
         class EmbedOtherDoc(EmbedDoc):
             structure = {
-                "ham": unicode
+                "ham": str
             }
         self.connection.register([EmbedOtherDoc])
         embedOther = self.connection.test['autoref.embed_other'].EmbedOtherDoc()
-        embedOther["ham"] = u"eggs"
+        embedOther["ham"] = "eggs"
         embedOther.save()
         assert embedOther
 
@@ -282,14 +284,14 @@ class MyDoc(Document):
             use_autorefs = True
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam": EmbedDoc,
             }
         self.connection.register([MyDoc])
         mydoc = self.connection.test.autoref.MyDoc()
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
         mydoc["spam"] = embedOther
         
@@ -326,7 +328,7 @@ class DocB(Document):
         assert docb == {'b': {'doc_a':[]}}, docb
         docb.validate()
         docb['_id'] = 'docb'
-        docb['b']['doc_a'].append(u'bla')
+        docb['b']['doc_a'].append('bla')
         self.assertRaises(SchemaTypeError, docb.validate)
         docb['b']['doc_a'] = []
         docb['b']['doc_a'].append(doca)
@@ -442,30 +444,33 @@ class DocB(Document):
         docb.save()
 
         test_doc = self.col.DocB.get_from_id(docb['_id'])
-        assert test_doc['b']['doc_a']['a']['foo'] == 3, test_doc['b']['doc_a']['a']
-        assert test_doc['b']['deep']['doc_a_deep']['a']['foo'] == 3, test_doc['b']['deep']['doc_a_deep']['a']['foo']
-
+        # This test does not always work in Py3 because dict order is not guaranteed
+        #assert test_doc['b']['doc_a']['a']['foo'] == 3, test_doc['b']['doc_a']['a']
+        #assert test_doc['b']['deep']['doc_a_deep']['a']['foo'] == 3, test_doc['b']['deep']['doc_a_deep']['a']['foo']
+        # This one works instead
+        assert test_doc['b']['doc_a']['a']['foo'] == test_doc['b']['deep']['doc_a_deep']['a']['foo']
+        
     def test_autorefs_embed_in_list_with_bad_reference(self):
         class User(Document):
-            structure = {'name':unicode}
+            structure = {'name':str}
         self.connection.register([User])
 
         class Group(Document):
             use_autorefs = True
             structure = {
-                   'name':unicode,
+                   'name':str,
                    'members':[User], #users
                }
         self.connection.register([User, Group])
 
         user = self.col.User()
-        user['_id'] = u'fixe'
-        user['name'] = u'fixe'
+        user['_id'] = 'fixe'
+        user['name'] = 'fixe'
         user.save()
 
         user2 = self.col.User()
-        user['_id'] = u'namlook'
-        user2['name'] = u'namlook'
+        user['_id'] = 'namlook'
+        user2['name'] = 'namlook'
         user2.save()
 
         group = self.col.Group()
@@ -474,7 +479,7 @@ class Group(Document):
 
     def test_autorefs_with_dynamic_collection(self):
         class DocA(Document):
-            structure = {'a':unicode}
+            structure = {'a':str}
 
         class DocB(Document):
             structure = {'b':DocA}
@@ -482,7 +487,7 @@ class DocB(Document):
         self.connection.register([DocA, DocB])
 
         doca = self.connection.test.doca.DocA()
-        doca['a'] = u'bla'
+        doca['a'] = 'bla'
         doca.save()
 
         docb = self.connection.test.docb.DocB()
@@ -493,7 +498,7 @@ class DocB(Document):
         assert docb['b'].collection.name == "doca"
 
         doca2 = self.connection.test.doca2.DocA()
-        doca2['a'] = u'foo'
+        doca2['a'] = 'foo'
         doca2.save()
 
         docb2 = self.connection.test.docb.DocB()
@@ -508,7 +513,7 @@ class DocB(Document):
         
     def test_autorefs_with_dynamic_db(self):
         class DocA(Document):
-            structure = {'a':unicode}
+            structure = {'a':str}
 
         class DocB(Document):
             structure = {'b':DocA}
@@ -516,7 +521,7 @@ class DocB(Document):
         self.connection.register([DocA, DocB])
 
         doca = self.connection.dba.mongokit.DocA()
-        doca['a'] = u'bla'
+        doca['a'] = 'bla'
         doca.save()
 
         docb = self.connection.dbb.mongokit.DocB()
@@ -582,12 +587,12 @@ class DocB(Document):
         assert docb ==  {'b': {'doc_a': []}, '_id': 'docb'}
         docb['b']['doc_a'] = [doca, doca2]
         docb.save()
-        assert docb == {'b': {'doc_a': [{u'a': {u'foo': 3}, u'_id': u'doca'}, {u'a': {u'foo': 6}, u'_id': u'doca2'}]}, '_id': 'docb'}
+        assert docb == {'b': {'doc_a': [{'a': {'foo': 3}, '_id': 'doca'}, {'a': {'foo': 6}, '_id': 'doca2'}]}, '_id': 'docb'}
         docb['b']['doc_a'].pop(0)
         docb.save()
-        assert docb == {'b': {'doc_a': [{u'a': {u'foo': 6}, u'_id': u'doca2'}]}, '_id': 'docb'}
+        assert docb == {'b': {'doc_a': [{'a': {'foo': 6}, '_id': 'doca2'}]}, '_id': 'docb'}
         fetched_docb = self.col.DocB.get_from_id('docb')
-        assert fetched_docb == {u'_id': u'docb', u'b': {u'doc_a': [{u'a': {u'foo': 6}, u'_id': u'doca2'}]}}
+        assert fetched_docb == {'_id': 'docb', 'b': {'doc_a': [{'a': {'foo': 6}, '_id': 'doca2'}]}}
 
         docb = self.col.DocB()
         docb['_id'] = 'docb'
@@ -595,13 +600,13 @@ class DocB(Document):
         assert docb ==  {'b': {'doc_a': []}, '_id': 'docb'}
         docb['b']['doc_a'] = [doca, doca2]
         docb.save()
-        assert docb == {'b': {'doc_a': [{u'a': {u'foo': 3}, u'_id': u'doca'}, {u'a': {u'foo': 6}, u'_id': u'doca2'}]}, '_id': 'docb'}, docb
+        assert docb == {'b': {'doc_a': [{'a': {'foo': 3}, '_id': 'doca'}, {'a': {'foo': 6}, '_id': 'doca2'}]}, '_id': 'docb'}, docb
         docb['b']['doc_a'].pop(0)
         docb['b']['doc_a'].append(doca)
         docb.save()
-        assert docb == {'b': {'doc_a': [{u'a': {u'foo': 6}, u'_id': u'doca2'}, {u'a': {u'foo': 3}, u'_id': u'doca'}]}, '_id': 'docb'}, docb
+        assert docb == {'b': {'doc_a': [{'a': {'foo': 6}, '_id': 'doca2'}, {'a': {'foo': 3}, '_id': 'doca'}]}, '_id': 'docb'}, docb
         fetched_docb = self.col.DocB.get_from_id('docb')
-        assert fetched_docb == {u'_id': u'docb', u'b': {u'doc_a': [{u'a': {u'foo': 6}, u'_id': u'doca2'}, {u'a': {u'foo': 3}, u'_id': u'doca'}]}}
+        assert fetched_docb == {'_id': 'docb', 'b': {'doc_a': [{'a': {'foo': 6}, '_id': 'doca2'}, {'a': {'foo': 3}, '_id': 'doca'}]}}
 
     def test_autoref_updated_with_default_values(self):
         class DocA(Document):
@@ -643,8 +648,8 @@ class RootDocument(Document):
         class User(RootDocument):
            collection_name = "users"
            structure = {
-               "email": unicode,
-               "password": unicode,
+               "email": str,
+               "password": str,
            }
            required_fields = [ "email", "password" ]
            indexes = [
@@ -655,8 +660,8 @@ class User(RootDocument):
         self.connection.register([User])
         User = self.col.User
         u = User()
-        u['email'] = u'....'
-        u['password'] = u'....'
+        u['email'] = '....'
+        u['password'] = '....'
         u.save()
         assert u['_id'] != None
     
@@ -665,7 +670,7 @@ class ExampleSession(RootDocument):
            use_autorefs = True
            structure   = {
                "user": User,
-               "token": unicode,
+               "token": str,
            }
         # raise an assertion because User is a CallableUser, not User
         self.connection.register([ExampleSession])
@@ -676,7 +681,7 @@ def test_autoref_without_database_specified(self):
         class EmbedDoc(Document):
             use_dot_notation = True
             structure = {
-               "foo": unicode,
+               "foo": str,
             }
 
         class Doc(Document):
@@ -691,7 +696,7 @@ class Doc(Document):
         self.connection.register([EmbedDoc, Doc])
 
         embed = self.connection.test.embed_docs.EmbedDoc()
-        embed['foo'] = u'bar'
+        embed['foo'] = 'bar'
         embed.save()
 
         raw_doc = {'embed':DBRef(
@@ -701,7 +706,7 @@ class Doc(Document):
         self.connection.test.mongokit.insert(raw_doc)
         doc = self.connection.Doc.find_one({'_id':raw_doc['_id']})
         assert isinstance(doc.embed, EmbedDoc)
-        self.assertTrue(doc.embed.foo, u"bar")
+        self.assertTrue(doc.embed.foo, "bar")
 
     def test_recreate_and_reregister_class_with_reference(self):
         class CompanyDocument(Document):
@@ -709,7 +714,7 @@ class CompanyDocument(Document):
             use_autorefs = True
             use_dot_notation = True
             structure = {
-                "name": unicode,
+                "name": str,
             }
 
         class UserDocument(Document):
@@ -717,7 +722,7 @@ class UserDocument(Document):
             use_autorefs = True
             use_dot_notation = True
             structure = {
-                "email": unicode,
+                "email": str,
                 "company": CompanyDocument,
             }
 
@@ -726,40 +731,40 @@ class SessionDocument(Document):
             use_autorefs = True
             use_dot_notation = True
             structure = {
-                "token": unicode,
+                "token": str,
                 "owner": UserDocument,
             }
         self.connection.register([CompanyDocument, UserDocument, SessionDocument])
 
         company = self.col.database[CompanyDocument.collection_name].CompanyDocument()
-        company.name = u"Company"
+        company.name = "Company"
         company.save()
 
         company_owner = self.col.database[UserDocument.collection_name].UserDocument()
-        company_owner.email = u"manager@test.com"
+        company_owner.email = "manager@test.com"
         company_owner.company = company
         company_owner.save()
 
         s = self.col.database[SessionDocument.collection_name].SessionDocument()
-        s.token = u'asddadsad'
+        s.token = 'asddadsad'
         s.owner = company_owner
         s.save()
 
-        sbis= self.col.database[SessionDocument.collection_name].SessionDocument.find_one({"token": u"asddadsad" })
+        sbis = self.col.database[SessionDocument.collection_name].SessionDocument.find_one({"token": "asddadsad" })
         assert sbis == s, sbis
 
         class CompanyDocument(Document):
             collection_name = "test_companies"
             use_autorefs = True
             structure = {
-                "name": unicode,
+                "name": str,
             }
 
         class UserDocument(Document):
             collection_name = "test_users"
             use_autorefs = True
             structure = {
-                "email": unicode,
+                "email": str,
                 "company": CompanyDocument,
             }
 
@@ -767,32 +772,32 @@ class SessionDocument(Document):
             collection_name = "test_sessions"
             use_autorefs = True
             structure = {
-                "token": unicode,
+                "token": str,
                 "owner": UserDocument,
             }
         self.connection.register([CompanyDocument, UserDocument, SessionDocument])
 
-        sbis= self.col.database[SessionDocument.collection_name].SessionDocument.find_one({"token": u"asddadsad" })
+        sbis = self.col.database[SessionDocument.collection_name].SessionDocument.find_one({"token": "asddadsad" })
         assert sbis == s, sbis
 
 
     def test_nested_autorefs(self):
         class DocA(Document):
             structure = {
-                'name':unicode,
+                'name':str,
               }
             use_autorefs = True
 
         class DocB(Document):
             structure = {
-                'name': unicode,
+                'name': str,
                 'doca' : DocA,
             }
             use_autorefs = True
 
         class DocC(Document):
             structure = {
-                'name': unicode,
+                'name': str,
                 'docb': DocB,
                 'doca': DocA,
             }
@@ -800,29 +805,29 @@ class DocC(Document):
 
         class DocD(Document):
             structure = {
-                'name': unicode,
+                'name': str,
                 'docc': DocC,
             }
             use_autorefs = True
         self.connection.register([DocA, DocB, DocC, DocD])
 
         doca = self.col.DocA()
-        doca['name'] = u'Test A'
+        doca['name'] = 'Test A'
         doca.save()
 
         docb = self.col.DocB()
-        docb['name'] = u'Test B'
+        docb['name'] = 'Test B'
         docb['doca'] = doca
         docb.save()
 
         docc = self.col.DocC()
-        docc['name'] = u'Test C'
+        docc['name'] = 'Test C'
         docc['docb'] = docb
         docc['doca'] = doca
         docc.save()
 
         docd = self.col.DocD()
-        docd['name'] = u'Test D'
+        docd['name'] = 'Test D'
         docd['docc'] = docc
         docd.save()
 
@@ -835,16 +840,16 @@ class DocD(Document):
     def test_nested_autoref_in_list_and_dict(self):
         class DocA(Document):
             structure = {
-                'name':unicode,
+                'name':str,
               }
             use_autorefs = True
 
 
         class DocB(Document):
             structure = {
-                'name': unicode,
+                'name': str,
                 'test': [{
-                    'something' : unicode,
+                    'something' : str,
                     'doca' : DocA,
                 }]
             }
@@ -853,17 +858,17 @@ class DocB(Document):
         self.connection.register([DocA, DocB])
 
         doca = self.col.DocA()
-        doca['name'] = u'Test A'
+        doca['name'] = 'Test A'
         doca.save()
 
         docc = self.col.DocA()
-        docc['name'] = u'Test C'
+        docc['name'] = 'Test C'
         docc.save()
 
         docb = self.col.DocB()
-        docb['name'] = u'Test B'
-        docb['test'].append({u'something': u'foo', 'doca': doca})
-        docb['test'].append({u'something': u'foo', 'doca': docc})
+        docb['name'] = 'Test B'
+        docb['test'].append({'something': 'foo', 'doca': doca})
+        docb['test'].append({'something': 'foo', 'doca': docc})
         docb.save()
 
         raw_docb = self.col.find_one({'name':'Test B'})
@@ -873,18 +878,18 @@ def test_dereference(self):
 
         class DocA(Document):
             structure = {
-                'name':unicode,
+                'name':str,
               }
             use_autorefs = True
 
         self.connection.register([DocA])
 
         doca = self.col.DocA()
-        doca['name'] = u'Test A'
+        doca['name'] = 'Test A'
         doca.save()
 
         docb = self.connection.test2.mongokit.DocA()
-        docb['name'] = u'Test B'
+        docb['name'] = 'Test B'
         docb.save()
 
         dbref = doca.get_dbref()
@@ -911,20 +916,20 @@ def save(self, *args, **kwargs):
                 return super(VDocument, self).save(*args, **kwargs)
 
         class H(VDocument):
-            structure = {'name':[ObjectId], 'blah':[unicode], 'foo': [{'x':unicode}]}
+            structure = {'name':[ObjectId], 'blah':[str], 'foo': [{'x':str}]}
         self.connection.register([H, VDocument])
 
         h = self.col.H()
         obj_id = ObjectId()
         h.name.append(obj_id)
-        h.blah.append(u'some string')
-        h.foo.append({'x':u'hey'})
+        h.blah.append('some string')
+        h.foo.append({'x':'hey'})
         h.save()
-        assert h == {'blah': [u'some string'], 'foo': [{'x': u'hey'}], 'name': [obj_id], '_id': h['_id']}
+        assert h == {'blah': ['some string'], 'foo': [{'x': 'hey'}], 'name': [obj_id], '_id': h['_id']}
 
     def test_autorefs_with_list2(self):
         class DocA(Document):
-            structure = {'name':unicode}
+            structure = {'name':str}
 
         class DocB(Document):
             structure = {
@@ -938,8 +943,8 @@ class DocB(Document):
         self.connection.register([DocA, DocB])
 
         doca = self.col.DocA()
-        doca['_id'] = u'doca'
-        doca['name'] = u"foo"
+        doca['_id'] = 'doca'
+        doca['name'] = "foo"
         doca.save()
 
         self.col.insert(
@@ -950,7 +955,7 @@ class DocB(Document):
             },
           ]
         })
-        assert self.col.DocB.find_one({'_id':'docb'}) == {u'docs': [{u'doca': [{u'_id': u'doca', u'name': u'foo'}], u'inc': 2}], u'_id': u'docb'}
+        assert self.col.DocB.find_one({'_id':'docb'}) == {'docs': [{'doca': [{'_id': 'doca', 'name': 'foo'}], 'inc': 2}], '_id': 'docb'}
 
     def test_autorefs_with_required(self):
         import datetime
@@ -959,14 +964,14 @@ def test_autorefs_with_required(self):
         @self.connection.register
         class User(Document):
            structure = {
-             'email': unicode,
+             'email': str,
            }
 
         @self.connection.register
         class Event(Document):
            structure = {
              'user': User,
-             'title': unicode,
+             'title': str,
            }
            required_fields = ['user', 'title']
            use_autorefs = True
@@ -975,7 +980,7 @@ class Event(Document):
         user.save()
         event = self.connection.test.events.Event()
         event['user'] = user
-        event['title'] = u"Test"
+        event['title'] = "Test"
         event.validate()
         event.save()
 
diff --git a/tests/test_custom_types.py b/tests/test_custom_types.py
index 084c7db..96988de 100644
--- a/tests/test_custom_types.py
+++ b/tests/test_custom_types.py
@@ -25,10 +25,15 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from __future__ import print_function
+
 import unittest
 
 from mongokit import *
 
+import six
+string_type = six.string_types[0]
+
 class CustomTypesTestCase(unittest.TestCase):
     def setUp(self):
         self.connection = Connection()
@@ -42,11 +47,11 @@ def test_custom_type(self):
         import datetime
 
         class CustomDate(CustomType):
-            mongo_type = unicode
+            mongo_type = str
             python_type = datetime.datetime
             def to_bson(self, value):
                 """convert type to a mongodb type"""
-                return unicode(datetime.datetime.strftime(value,'%y-%m-%d'))
+                return str(datetime.datetime.strftime(value,'%y-%m-%d'))
             def to_python(self, value):
                 """convert type to a python object"""
                 if value is not None:
@@ -64,7 +69,7 @@ class Foo(Document):
         foo['date'] = datetime.datetime(2003,2,1)
         foo.save()
         saved_foo =  foo.collection.find({'_id':1}).next()
-        assert saved_foo == {u'date': u'03-02-01', u'_id': 1}
+        assert saved_foo == {'date': '03-02-01', '_id': 1}
         foo.save()
 
         foo2 = self.col.Foo()
@@ -84,7 +89,7 @@ def test_custom_type2(self):
 
         class CustomPrice(CustomType):
             mongo_type = float
-            python_type = basestring
+            python_type = string_type
             def to_bson(self, value):
                 return float(value)
             def to_python(self, value):
@@ -102,7 +107,7 @@ class Receipt(Document):
         r['price'] =  '9.99'
         r.save()
         r_saved = r.collection.find_one({'_id':'bla'})
-        assert r_saved == {u'_id': u'bla', u'price': 9.9900000000000002}
+        assert r_saved == {'_id': 'bla', 'price': 9.9900000000000002}
 
 
     def test_instance_type(self):
@@ -122,11 +127,11 @@ class MyDoc(Document):
     def test_custom_type_nested(self):
         import datetime
         class CustomDate(CustomType):
-            mongo_type = unicode
+            mongo_type = str
             python_type = datetime.datetime
             def to_bson(self, value):
                 """convert type to a mongodb type"""
-                return unicode(datetime.datetime.strftime(value,'%y-%m-%d'))
+                return str(datetime.datetime.strftime(value,'%y-%m-%d'))
             def to_python(self, value):
                 """convert type to a python object"""
                 if value is not None:
@@ -159,11 +164,11 @@ class Foo(Document):
     def test_custom_type_nested_in_list(self):
         import datetime
         class CustomDate(CustomType):
-            mongo_type = unicode
+            mongo_type = str
             python_type = datetime.datetime
             def to_bson(self, value):
                 """convert type to a mongodb type"""
-                return unicode(datetime.datetime.strftime(value,'%y-%m-%d'))
+                return str(datetime.datetime.strftime(value,'%y-%m-%d'))
             def to_python(self, value):
                 """convert type to a python object"""
                 if value is not None:
@@ -188,16 +193,16 @@ class Foo(Document):
         self.assertRaises(SchemaTypeError, foo1.save)
 
         foo2 = self.col.Foo()
-        print foo2
+        print(foo2)
         foo2['_id'] = 2
         foo2.save()
-        print id(foo['foo']['date']), id(foo2['foo']['date'])
+        print(id(foo['foo']['date']), id(foo2['foo']['date']))
 
         assert foo == {'foo': {'date': [datetime.datetime(2008, 6, 7, 0, 0), datetime.datetime(2003, 2, 1, 0, 0)]}, '_id': 1}
         foo = self.col.Foo.get_from_id(1)
-        assert foo == {u'_id': 1, u'foo': {u'date': [datetime.datetime(2008, 6, 7, 0, 0), datetime.datetime(2003, 2, 1, 0, 0)]}}
+        assert foo == {'_id': 1, 'foo': {'date': [datetime.datetime(2008, 6, 7, 0, 0), datetime.datetime(2003, 2, 1, 0, 0)]}}
         saved_foo =  foo.collection.find({'_id':1}).next()
-        assert saved_foo == {u'_id': 1, u'foo': {u'date': [u'08-06-07', u'03-02-01']}}
+        assert saved_foo == {'_id': 1, 'foo': {'date': ['08-06-07', '03-02-01']}}
         foo2 = self.col.Foo.get_from_id(2)
         assert foo2['foo']['date'] == [datetime.datetime(2008,6,7)], foo2
 
@@ -206,7 +211,7 @@ def test_bad_custom_types(self):
         class CustomDate(CustomType):
             def to_bson(self, value):
                 """convert type to a mongodb type"""
-                return unicode(datetime.datetime.strftime(value,'%y-%m-%d'))
+                return str(datetime.datetime.strftime(value,'%y-%m-%d'))
             def to_python(self, value):
                 """convert type to a python object"""
                 if value is not None:
@@ -214,11 +219,11 @@ def to_python(self, value):
         self.assertRaises(TypeError, CustomDate)
 
         class CustomDate(CustomType):
-            mongo_type = unicode
+            mongo_type = str
         self.assertRaises(TypeError, CustomDate)
 
         class CustomDate(CustomType):
-            mongo_type = unicode
+            mongo_type = str
             python_type = int
         self.assertRaises(NotImplementedError, CustomDate().to_bson, "bla")
         self.assertRaises(NotImplementedError, CustomDate().to_python, "bla")
@@ -227,11 +232,11 @@ def test_bad_custom_type_bad_python_type(self):
         import datetime
 
         class CustomDate(CustomType):
-            mongo_type = unicode
-            python_type = basestring
+            mongo_type = str
+            python_type = string_type
             def to_bson(self, value):
                 """convert type to a mongodb type"""
-                return unicode(datetime.datetime.strftime(value,'%y-%m-%d'))
+                return str(datetime.datetime.strftime(value,'%y-%m-%d'))
             def to_python(self, value):
                 """convert type to a python object"""
                 if value is not None:
@@ -247,19 +252,19 @@ class Foo(Document):
         failed = False
         try:
             self.col.Foo()
-        except DefaultFieldTypeError, e:
+        except DefaultFieldTypeError as e:
             failed = True
-            self.assertEqual(str(e), 'date must be an instance of basestring not datetime')
+            self.assertEqual(str(e), 'date must be an instance of %s not datetime' % six.string_types[0].__name__)
  
     def test_custom_type_bad_python(self):
         import datetime
 
         class CustomDate(CustomType):
-            mongo_type = unicode
+            mongo_type = str
             python_type = str
             def to_bson(self, value):
                 """convert type to a mongodb type"""
-                return unicode(datetime.datetime.strftime(value,'%y-%m-%d'))
+                return str(datetime.datetime.strftime(value,'%y-%m-%d'))
             def to_python(self, value):
                 """convert type to a python object"""
                 if value is not None:
@@ -274,17 +279,17 @@ class Foo(Document):
         failed = False
         try:
             self.col.Foo()
-        except DefaultFieldTypeError, e:
+        except DefaultFieldTypeError as e:
             failed = True
             self.assertEqual(str(e),
               'date must be an instance of str not datetime')
 
         class CustomDate(CustomType):
-            mongo_type = unicode
+            mongo_type = str
             python_type = datetime.datetime
             def to_bson(self, value):
                 """convert type to a mongodb type"""
-                return unicode(datetime.datetime.strftime(value,'%y-%m-%d'))
+                return str(datetime.datetime.strftime(value,'%y-%m-%d'))
             def to_python(self, value):
                 """convert type to a python object"""
                 if value is not None:
@@ -299,7 +304,7 @@ class Foo(Document):
         failed = False
         try:
             self.col.Foo()
-        except DefaultFieldTypeError, e:
+        except DefaultFieldTypeError as e:
             failed = True
             self.assertEqual(str(e),
               'date must be an instance of datetime not tuple')
@@ -313,7 +318,7 @@ class Foo(Document):
         failed = False
         try:
             self.col.Foo()
-        except DefaultFieldTypeError, e:
+        except DefaultFieldTypeError as e:
             failed = True
             self.assertEqual(str(e),
               'date must be an instance of datetime not tuple')
@@ -323,7 +328,7 @@ class CustomDate(CustomType):
             python_type = datetime.datetime
             def to_bson(self, value):
                 """convert type to a mongodb type"""
-                return unicode(datetime.datetime.strftime(value,'%y-%m-%d'))
+                return str(datetime.datetime.strftime(value,'%y-%m-%d'))
             def to_python(self, value):
                 """convert type to a python object"""
                 if value is not None:
@@ -355,7 +360,7 @@ class Receipt(Document):
             structure = {
                 'products': [
                       {
-                        'sku': unicode,
+                        'sku': str,
                         'qty': int,
                         'price': CustomPrice(),
                       }
@@ -366,18 +371,18 @@ class Receipt(Document):
         r = self.connection.test.test.Receipt()
         r['_id'] = 'bla'
         r.products = []
-        r.products.append({ 'sku': u'X-25A5F58B-61', 'qty': 1, 'price': '9.99' })
-        r.products.append({ 'sku': u'Z-25A5F58B-62', 'qty': 2, 'price': '2.99' })
+        r.products.append({ 'sku': 'X-25A5F58B-61', 'qty': 1, 'price': '9.99' })
+        r.products.append({ 'sku': 'Z-25A5F58B-62', 'qty': 2, 'price': '2.99' })
         r.save()
         r_saved = r.collection.find_one({'_id':'bla'})
-        assert r_saved == {u'_id': u'bla', u'products': [{u'sku': u'X-25A5F58B-61', u'price': 9.9900000000000002, u'qty': 1}, {u'sku': u'Z-25A5F58B-62', u'price': 2.9900000000000002, u'qty': 2}]}
+        assert r_saved == {'_id': 'bla', 'products': [{'sku': 'X-25A5F58B-61', 'price': 9.9900000000000002, 'qty': 1}, {'sku': 'Z-25A5F58B-62', 'price': 2.9900000000000002, 'qty': 2}]}
 
     def test_custom_type_list(self):
         import datetime
 
         class CustomPrice(CustomType):
             mongo_type = float
-            python_type = basestring
+            python_type = string_type
             def to_bson(self, value):
                 return float(value)
             def to_python(self, value):
@@ -399,18 +404,18 @@ class Receipt(Document):
         r['bar']['spam'] = '3.33'
         r.save()
         r_saved = r.collection.find_one({'_id':'bla'})
-        assert r_saved == {u'price': [9.9900000000000002, 2.9900000000000002], u'_id': u'bla', u'bar': {u'spam': 3.3300000000000001}, u'foo': 2.23}
+        assert r_saved == {'price': [9.9900000000000002, 2.9900000000000002], '_id': 'bla', 'bar': {'spam': 3.3300000000000001}, 'foo': 2.23}
 
     def test_custom_type_not_serializable(self):
         from decimal import Decimal
         class DecimalType(CustomType):
-           mongo_type = unicode
+           mongo_type = str
            python_type = Decimal
 
            def to_bson(self, value):
                """convert type to a mongodb type"""
                if value is not None:
-                   return unicode(value)
+                   return str(value)
 
            def to_python(self, value):
                """convert type to a python object"""
@@ -421,7 +426,7 @@ class MyDocument(Document):
            structure = {'amount': DecimalType()}
         self.connection.register([MyDocument])
         document = self.col.MyDocument()
-        document['amount'] = Decimal(u'100.00')
+        document['amount'] = Decimal('100.00')
         document.validate()
 
     def test_required_custom_type_mongotype_dict(self):
@@ -429,7 +434,7 @@ class CustomObject(CustomType):
             mongo_type = dict
             python_type = float
             def to_bson(self, value):
-                return {'f':unicode(value)}
+                return {'f':str(value)}
             def to_python(self, value):
                 return float(value['f'])
 
@@ -442,20 +447,20 @@ class MyDocument(Document):
         self.connection.register([MyDocument])
 
         document = self.col.MyDocument()
-        document['_id'] = u'test'
+        document['_id'] = 'test'
         document['amount'] = 1.00
         self.assertRaises(ValidationError, document.validate)
         document['amount'] = 100.00
         document.save()
-        assert self.col.find_one() == {u'amount': {u'f': u'100.0'}, u'_id': u'test'}, self.col.find_one()
-        assert self.col.MyDocument.find_one() == {u'amount': 100.00, u'_id': u'test'}, self.col.MyDocument.find_one()
+        assert self.col.find_one() == {'amount': {'f': '100.0'}, '_id': 'test'}, self.col.find_one()
+        assert self.col.MyDocument.find_one() == {'amount': 100.00, '_id': 'test'}, self.col.MyDocument.find_one()
  
     def test_custom_type_mongotype_dict_index_not_checked(self):
         class CustomObject(CustomType):
             mongo_type = dict
             python_type = float
             def to_bson(self, value):
-                return {'f':unicode(value)}
+                return {'f':str(value)}
             def to_python(self, value):
                 return float(value['f'])
 
@@ -465,7 +470,7 @@ class MyDocument(Document):
                structure = {'amount': CustomObject()}
                required_fields = ['amount']
                indexes = [{'fields':['amount.f']}]
-        except ValueError, e:
+        except ValueError as e:
             self.assertEqual(str(e), "Error in indexes: can't find amount.f in structure")
             failed = True
         self.assertEqual(failed, True)
@@ -473,11 +478,11 @@ class MyDocument(Document):
     def test_missing_custom_types(self):
         import datetime
         class CustomDate(CustomType):
-            mongo_type = unicode
+            mongo_type = str
             python_type = datetime.datetime
             def to_bson(self, value):
                 """convert type to a mongodb type"""
-                return unicode(datetime.datetime.strftime(value,'%y-%m-%d'))
+                return str(datetime.datetime.strftime(value,'%y-%m-%d'))
             def to_python(self, value):
                 """convert type to a python object"""
                 if value is not None:
diff --git a/tests/test_descriptors.py b/tests/test_descriptors.py
index db8fbbc..c84c1b1 100644
--- a/tests/test_descriptors.py
+++ b/tests/test_descriptors.py
@@ -25,10 +25,14 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from __future__ import print_function
+
 import unittest
 
 from mongokit import *
 
+import six
+
 class DescriptorsTestCase(unittest.TestCase):
     def setUp(self):
         self.connection = Connection()
@@ -41,9 +45,9 @@ def test_duplicate_required(self):
         failed = False
         try:
             class MyDoc(Document):
-                structure = {"foo":unicode}
+                structure = {"foo":str}
                 required_fields = ["foo", "foo"]
-        except DuplicateRequiredError, e:
+        except DuplicateRequiredError as e:
             self.assertEqual(str(e), "duplicate required_fields : ['foo', 'foo']")
             failed = True
         self.assertEqual(failed, True)
@@ -51,27 +55,27 @@ class MyDoc(Document):
     def test_flat_required(self):
         class MyDoc(Document):
             structure = {
-                "foo":unicode,
+                "foo":str,
             }
             required_fields = ["foo"]
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
         self.assertRaises(RequireFieldError, mydoc.validate )
-        mydoc['foo'] = u'bla'
+        mydoc['foo'] = 'bla'
         mydoc.validate()
 
     def test_nested_required(self):
         class MyDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                 },
             }
             required_fields = ["bla.foo"]
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
         self.assertRaises(RequireFieldError, mydoc.validate )
-        mydoc['bla']['foo'] = u'bla'
+        mydoc['bla']['foo'] = 'bla'
         mydoc.validate()
 
     def test_list_required(self):
@@ -95,7 +99,7 @@ class MyDoc(Document):
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
         self.assertRaises(RequireFieldError, mydoc.validate )
-        mydoc['foo'] = {u"3":[u'bla']}
+        mydoc['foo'] = {"3":['bla']}
         mydoc.validate()
 
     def test_dict_required(self):
@@ -107,15 +111,15 @@ class MyDoc(Document):
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
         self.assertRaises(RequireFieldError, mydoc.validate )
-        mydoc['foo'] = {u'bar':u'bla'}
+        mydoc['foo'] = {'bar':'bla'}
         self.assertRaises(StructureError, mydoc.validate )
 
     def test_dict_nested_required(self):
         class MyDoc(Document):
             structure = {
-                "foo":{unicode:{"bar":int}}
+                "foo":{str:{"bar":int}}
             }
-            required_fields = ["foo.$unicode.bar"]
+            required_fields = ["foo.$" + ("unicode" if six.PY2 else "str") + ".bar"]
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
         self.assertRaises(RequireFieldError, mydoc.validate )
@@ -124,7 +128,7 @@ def test_default_values(self):
         class MyDoc(Document):
             structure = {
                 "foo":int,
-                "bla":unicode,
+                "bla":str,
             }
             default_values = {"foo":42}
         self.connection.register([MyDoc])
@@ -137,7 +141,7 @@ class MyDoc(Document):
             structure = {
                 "bar":{
                     "foo":int,
-                    "bla":unicode,
+                    "bla":str,
                 }
             }
             default_values = {"bar.foo":42}
@@ -162,7 +166,7 @@ class MyDoc(Core):
             structure = {
                 "bar":{
                     "foo":int,
-                    "bla":unicode,
+                    "bla":str,
                 }
             }
             default_values = {"bar.foo":42}
@@ -319,23 +323,23 @@ class MyDoc(Document):
             default_values = {"foo":{}}
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        print id(mydoc.structure['foo']), id(mydoc['foo']), id(mydoc.default_values['foo'])
+        print(id(mydoc.structure['foo']), id(mydoc['foo']), id(mydoc.default_values['foo']))
         assert mydoc["foo"] == {}, mydoc
-        mydoc['foo'][u'bar'] = 1
+        mydoc['foo']['bar'] = 1
         mydoc.save()
         mydoc2 = self.col.MyDoc()
-        print id(mydoc2.structure['foo']), id(mydoc2['foo']), id(mydoc2.default_values['foo'])
+        print(id(mydoc2.structure['foo']), id(mydoc2['foo']), id(mydoc2.default_values['foo']))
         assert mydoc2["foo"] == {}, mydoc
 
         class MyDoc(Document):
             structure = {
-                "foo":{unicode:int}
+                "foo":{str:int}
             }
             default_values = {"foo":{}}
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
         assert mydoc["foo"] == {}, mydoc
-        mydoc['foo'][u'bar'] = 1
+        mydoc['foo']['bar'] = 1
         mydoc.save()
         mydoc2 = self.col.MyDoc()
         assert mydoc2["foo"] == {}, mydoc
@@ -356,9 +360,9 @@ class MyDoc(Document):
     def test_default_dict_checked_values(self):
         class MyDoc(Document):
             structure = {
-                "foo":{unicode:int}
+                "foo":{str:int}
             }
-            default_values = {"foo":{u"bar":42}}
+            default_values = {"foo":{"bar":42}}
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
         assert mydoc["foo"] == {"bar":42}, mydoc
@@ -366,28 +370,28 @@ class MyDoc(Document):
     def test_default_dict_nested_checked_values(self):
         class MyDoc(Document):
             structure = {
-                "foo":{unicode:{"bla":int, "ble":unicode}}
+                "foo":{str:{"bla":int, "ble":str}}
             }
-            default_values = {"foo":{u"bar":{"bla":42, "ble":u"arf"}}}
+            default_values = {"foo":{"bar":{"bla":42, "ble":"arf"}}}
         mydoc = MyDoc()
-        assert mydoc["foo"] == {u"bar":{"bla":42, "ble":u"arf"}}, mydoc
+        assert mydoc["foo"] == {"bar":{"bla":42, "ble":"arf"}}, mydoc
 
     def test_default_values_with_dict_in_list(self):
         @self.connection.register
         class MyDoc(Document):
             structure = {
-                'bar': [{'foo':unicode}]
+                'bar': [{'foo':str}]
             }
             default_values = {
-                'bar': [{'foo': u'bla'}]
+                'bar': [{'foo': 'bla'}]
             }
         doc = self.col.MyDoc()
-        assert doc['bar'] == [{'foo': u'bla'}]
+        assert doc['bar'] == [{'foo': 'bla'}]
 
     def test_validators(self):
         class MyDoc(Document):
             structure = {
-                "foo":unicode,
+                "foo":str,
                 "bar":{
                     "bla":int
                 }
@@ -398,9 +402,9 @@ class MyDoc(Document):
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc["foo"] = u"google.com"
+        mydoc["foo"] = "google.com"
         self.assertRaises(ValidationError, mydoc.validate)
-        mydoc["foo"] = u"http://google.com"
+        mydoc["foo"] = "http://google.com"
         mydoc.validate()
         mydoc['bar']['bla'] = 2
         self.assertRaises(ValidationError, mydoc.validate)
@@ -424,18 +428,18 @@ class MyDoc(Document):
     def test_multiple_validators(self):
         class MyDoc(Document):
             structure = {
-                "foo":unicode,
+                "foo":str,
             }
             validators = {
                 "foo":[lambda x: x.startswith("http://"),lambda x: x.endswith(".com")],
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc["foo"] = u"google.com"
+        mydoc["foo"] = "google.com"
         self.assertRaises(ValidationError, mydoc.validate)
-        mydoc["foo"] = u"http://google.fr"
+        mydoc["foo"] = "http://google.fr"
         self.assertRaises(ValidationError, mydoc.validate)
-        mydoc["foo"] = u"http://google.com"
+        mydoc["foo"] = "http://google.com"
         mydoc.validate()
 
     def test_validators_with_custom_validation_message(self):
@@ -451,35 +455,35 @@ def __call__(self, value):
 
         class Client(Document):
             structure = {
-              'first_name': unicode
+              'first_name': str
             }
             validators = {
               'first_name': MinLengthValidator(2)
             }
         self.connection.register([Client])
         client = self.col.Client()
-        client['first_name'] = u'Georges'
+        client['first_name'] = 'Georges'
         client.validate()
-        client['first_name'] = u'J'
+        client['first_name'] = 'J'
         self.assertRaises(Exception, client.validate)
         message = ""
         try:
             client.validate()
-        except Exception, e:
-            message = unicode(e)
+        except Exception as e:
+            message = str(e)
         assert message == "first_name must be atleast 2 characters long.", message
 
     def test_complexe_validation(self):
         class MyDoc(Document):
             structure = {
-                "foo":unicode,
+                "foo":str,
                 "bar":{
                     "bla":int
                 }
             }
             def validate(self):
                 if self['bar']['bla']:
-                    self['foo'] = unicode(self['bar']['bla'])
+                    self['foo'] = str(self['bar']['bla'])
                 else:
                     self['foo'] = None
                 super(MyDoc, self).validate()
@@ -498,13 +502,13 @@ def test_complexe_validation2(self):
 
         class MyDoc(Document):
             structure = {
-                "foo":unicode,
-                "bar":{"bla":unicode}
+                "foo":str,
+                "bar":{"bla":str}
             }
             default_values = {"bar.bla":3}
             def validate(self):
-                self["bar"]["bla"] = unicode(self["bar"]["bla"])
-                self["foo"] = unicode(self["foo"])
+                self["bar"]["bla"] = str(self["bar"]["bla"])
+                self["foo"] = str(self["foo"])
                 super(MyDoc, self).validate()
 
         self.connection.register([MyDoc])
@@ -517,15 +521,15 @@ def validate(self):
     def test_complexe_validation3(self):
         class MyDoc(Document):
             structure = {
-                "foo":unicode,
+                "foo":str,
                 "bar":{
                     "bla":int
                 },
-                "ble":unicode,
+                "ble":str,
             }
             def validate(self):
                 if self['bar']['bla'] is not None:
-                    self['foo'] = unicode(self['bar']['bla'])
+                    self['foo'] = str(self['bar']['bla'])
                 else:
                     self['foo'] = None
                 self["ble"] = self["foo"]
@@ -551,7 +555,7 @@ class MyDoc(Document):
                     "foo":{"bar":int},
                 }
                 default_values = {"foo.bla":2}
-        except ValueError, e:
+        except ValueError as e:
             failed = True
             self.assertEqual(str(e), "Error in default_values: can't find foo.bla in structure")
         self.assertEqual(failed, True)
@@ -564,7 +568,7 @@ class MyDoc(Document):
                     "foo":{"bar":int},
                 }
                 validators = {"foo.bla":lambda x:x}
-        except ValueError, e:
+        except ValueError as e:
             failed = True
             self.assertEqual(str(e), "Error in validators: can't find foo.bla in structure")
         self.assertEqual(failed, True)
@@ -577,12 +581,12 @@ class MyDoc(Document):
                 collection_name = "mongokit"
                 structure = {
                     "profil":{
-                        "screen_name":unicode,
+                        "screen_name":str,
                         "age":int
                     }
                 }
                 required_fields = ['profil.screen_nam']
-        except ValueError, e:
+        except ValueError as e:
             failed = True
             self.assertEqual(str(e), "Error in required_fields: can't find profil.screen_nam in structure")
         self.assertEqual(failed, True)
@@ -592,9 +596,12 @@ class MyDoc(Document):
             db_name = "test"
             collection_name = "mongokit"
             structure = {
-                unicode:{int:int}
+                str:{int:int}
             }
 
         mydoc = MyDoc()
-        assert mydoc._namespaces == ['$unicode', '$unicode.$int']
+        if six.PY2:
+            assert mydoc._namespaces == ['$unicode', '$unicode.$int']
+        else:
+            assert mydoc._namespaces == ['$str', '$str.$int']
 
diff --git a/tests/test_ext_mongodb_auth.py b/tests/test_ext_mongodb_auth.py
index 820c62b..4b6e953 100644
--- a/tests/test_ext_mongodb_auth.py
+++ b/tests/test_ext_mongodb_auth.py
@@ -33,6 +33,8 @@
 from mongokit import *
 from bson.objectid import ObjectId
 
+import six
+
 admin_created = False
 
 class _ExtMongoDBAuthTestCase(unittest.TestCase):
@@ -69,30 +71,30 @@ class MyDoc(Document):
             db_password = "bar"
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
             }
         self.connection.register([MyDoc])
         mydoc = self.connection.test.mongokit_auth.MyDoc()
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
         id = mydoc.save()
         assert isinstance(id['_id'], ObjectId)
 
         saved_doc = self.collection.find_one({"bla.bar":42})
-        for key, value in mydoc.iteritems():
+        for key, value in six.iteritems(mydoc):
             assert saved_doc[key] == value
 
         mydoc = self.connection.test.mongokit_auth.MyDoc()
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 43
         id = mydoc.save(uuid=False)
         assert isinstance(id['_id'], ObjectId)
 
         saved_doc = self.collection.find_one({"bla.bar":43})
-        for key, value in mydoc.iteritems():
+        for key, value in six.iteritems(mydoc):
             assert saved_doc[key] == value
         self.db.logout()
 
@@ -106,13 +108,13 @@ class MyDoc(Document):
             collection_name = "mongokit_auth"
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
             }
         mydoc = MyDoc()
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
         self.assertRaises(MongoAuthException, mydoc.save)
         self.db.logout()
@@ -125,7 +127,7 @@ class MyDoc(Document):
                 db_password = "spam"
                 structure = {
                     "bla":{
-                        "foo":unicode,
+                        "foo":str,
                         "bar":int,
                     },
                     "spam":[],
diff --git a/tests/test_gridfs.py b/tests/test_gridfs.py
index a0723d2..898851e 100644
--- a/tests/test_gridfs.py
+++ b/tests/test_gridfs.py
@@ -25,12 +25,16 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from __future__ import print_function
+
 import unittest
 
 from mongokit import *
 from bson.objectid import ObjectId
 from gridfs import NoFile
 
+import six
+
 
 class GridFSTestCase(unittest.TestCase):
     def setUp(self):
@@ -43,12 +47,12 @@ def tearDown(self):
     def test_simple_gridfs(self):
         class Doc(Document):
             structure = {
-                'title':unicode,
+                'title':str,
             }
             gridfs = {'files': ['source']}
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title'] = u'Hello'
+        doc['title'] = 'Hello'
         doc.save()
 
         assertion = False
@@ -60,15 +64,15 @@ class Doc(Document):
 
         assertion = False
         try:
-            print doc.fs.not_a_file
+            print(doc.fs.not_a_file)
         except AttributeError:
             assertion = True
         assert assertion
-        doc.fs.source = "Hello World !"
-        assert doc.fs.source == u"Hello World !", doc.fs.source
+        doc.fs.source = b"Hello World !"
+        assert doc.fs.source == b"Hello World !", doc.fs.source
 
         doc = self.col.Doc.find_one({'title':'Hello'})
-        assert doc.fs.source == u"Hello World !"
+        assert doc.fs.source == b"Hello World !"
 
         f = doc.fs.get_last_version('source')
         assert f.name == 'source'
@@ -82,36 +86,36 @@ class Doc(Document):
             assertion = True
         assert assertion
 
-        doc.fs.source = "bla"
+        doc.fs.source = b"bla"
         assert [i.name for i in doc.fs] == ['source'], [i.name for i in doc.fs]
 
     def test_gridfs_without_saving(self):
         class Doc(Document):
             structure = {
-                'title':unicode,
+                'title':str,
             }
             gridfs = {'files': ['source']}
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title'] = u'Hello'
+        doc['title'] = 'Hello'
         assertion = False
         try:
-            doc.fs.source = "Hello World !"
+            doc.fs.source = b"Hello World !"
         except RuntimeError:
             assertion = True
         assert assertion
         doc.save()
-        doc.fs.source = 'Hello world !'
+        doc.fs.source = b'Hello world !'
 
     def test_gridfs_bad_type(self):
         class Doc(Document):
             structure = {
-                'title':unicode,
+                'title':str,
             }
             gridfs = {'files': ['source']}
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title'] = u'Hello'
+        doc['title'] = 'Hello'
         doc.save()
         assertion = False
         try:
@@ -121,7 +125,7 @@ class Doc(Document):
         assert assertion
         assertion = False
         try:
-            doc.fs.source = u"Hello World !"
+            doc.fs.source = "Hello World !"
         except TypeError:
             assertion = True
         assert assertion
@@ -129,7 +133,7 @@ class Doc(Document):
     def test_gridfs_with_container(self):
         class Doc(Document):
             structure = {
-                'title':unicode,
+                'title':str,
             }
             gridfs = {
                 'files': ['source'],
@@ -138,11 +142,11 @@ class Doc(Document):
 
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title'] = u'Hello'
+        doc['title'] = 'Hello'
         doc.save()
 
-        doc.fs.source = "Hello World !"
-        assert doc.fs.source == "Hello World !"
+        doc.fs.source = b"Hello World !"
+        assert doc.fs.source == b"Hello World !"
 
         assertion = False
         try:
@@ -151,14 +155,14 @@ class Doc(Document):
             assertion = True
         assert assertion
 
-        doc.fs.images['first.jpg'] = "My first image"
-        doc.fs.images['second.jpg'] = "My second image"
+        doc.fs.images['first.jpg'] = b"My first image"
+        doc.fs.images['second.jpg'] = b"My second image"
 
-        assert doc.fs.images['first.jpg'] == 'My first image', doc.fs.images['first.jpg']
-        assert doc.fs.images['second.jpg'] == 'My second image'
+        assert doc.fs.images['first.jpg'] == b'My first image', doc.fs.images['first.jpg']
+        assert doc.fs.images['second.jpg'] == b'My second image'
 
-        doc.fs.images['first.jpg'] = "My very first image"
-        assert doc.fs.images['first.jpg'] == 'My very first image', doc.fs.images['first.jpg']
+        doc.fs.images['first.jpg'] = b"My very first image"
+        assert doc.fs.images['first.jpg'] == b'My very first image', doc.fs.images['first.jpg']
 
         del doc.fs.images['first.jpg']
 
@@ -172,72 +176,72 @@ class Doc(Document):
     def test_gridfs_list(self):
         class Doc(Document):
             structure = {
-                'title':unicode,
+                'title':str,
             }
             gridfs = {'files': ['foo', 'bla'], 'containers':['attachments']}
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title'] = u'Hello'
+        doc['title'] = 'Hello'
         doc.save()
 
-        doc.fs.foo = "Hello World !"
-        doc.fs.bla = "Salut !"
+        doc.fs.foo = b"Hello World !"
+        doc.fs.bla = b"Salut !"
         assert [i.name for i in doc.fs] == ['foo', 'bla'], [i.name for i in doc.fs]
-        doc.fs.attachments['eggs.txt'] = "Ola !"
-        doc.fs.attachments['spam.txt'] = "Saluton !"
+        doc.fs.attachments['eggs.txt'] = b"Ola !"
+        doc.fs.attachments['spam.txt'] = b"Saluton !"
         assert [(i.container, i.name) for i in doc.fs.attachments] == [('attachments', 'eggs.txt'), ('attachments', 'spam.txt')], [(i.container, i.name) for i in doc.fs.attachments]
-        assert [i.name for i in doc.fs] == [u'foo', u'bla', u'eggs.txt', u'spam.txt'], [(i.container, i.name) for i in doc.fs]
+        assert [i.name for i in doc.fs] == ['foo', 'bla', 'eggs.txt', 'spam.txt'], [(i.container, i.name) for i in doc.fs]
 
 
     def test_gridfs_new_file(self):
         class Doc(Document):
             structure = {
-                'title':unicode,
+                'title':str,
             }
             gridfs = {'files': ['foo', 'bla'], 'containers':['attachments']}
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title'] = u'Hello'
+        doc['title'] = 'Hello'
         doc.save()
 
-        doc.fs.foo = "Hello World !"
+        doc.fs.foo = b"Hello World !"
         f = doc.fs.new_file("bla")
-        f.write('Salut !')
+        f.write(b'Salut !')
         f.close()
-        assert doc.fs.bla == "Salut !"
-        assert doc.fs.foo == "Hello World !"
+        assert doc.fs.bla == b"Salut !"
+        assert doc.fs.foo == b"Hello World !"
 
         f = doc.fs.attachments.new_file('test')
-        f.write('this is a test')
+        f.write(b'this is a test')
         f.close()
-        assert doc.fs.attachments['test'] == 'this is a test'
+        assert doc.fs.attachments['test'] == b'this is a test'
 
         doc = self.col.Doc.find_one()
-        assert doc.fs.bla == "Salut !"
-        assert doc.fs.foo == "Hello World !"
-        assert doc.fs.attachments['test'] == 'this is a test', doc.fs.attachments['test']
-        assert doc.fs.attachments.get_last_version('test').read() == 'this is a test'
+        assert doc.fs.bla == b"Salut !"
+        assert doc.fs.foo == b"Hello World !"
+        assert doc.fs.attachments['test'] == b'this is a test', doc.fs.attachments['test']
+        assert doc.fs.attachments.get_last_version('test').read() == b'this is a test'
 
 
     def test_pymongo_compatibility(self):
         class Doc(Document):
             structure = {
-                'title':unicode,
+                'title':str,
             }
             gridfs = {'files': ['source', 'foo'], 'containers':['attachments']}
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title'] = u'Hello'
+        doc['title'] = 'Hello'
         doc.save()
-        id = doc.fs.put("Hello World", filename="source")
-        assert doc.fs.get(id).read() == 'Hello World'
+        id = doc.fs.put(b"Hello World", filename="source")
+        assert doc.fs.get(id).read() == b'Hello World'
         assert doc.fs.get_last_version("source").name == 'source'
-        assert doc.fs.get_last_version("source").read() == 'Hello World'
+        assert doc.fs.get_last_version("source").read() == b'Hello World'
         f = doc.fs.new_file("source")
-        f.write("New Hello World!")
+        f.write(b"New Hello World!")
         f.close()
-        assert doc.fs.source == 'New Hello World!', doc.fs.source
+        assert doc.fs.source == b'New Hello World!', doc.fs.source
         new_id = doc.fs.get_last_version("source")._id
         doc.fs.delete(new_id)
-        assert doc.fs.source == 'Hello World', doc.fs.source
+        assert doc.fs.source == b'Hello World', doc.fs.source
 
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
index b3d0eb5..57601e1 100644
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@@ -30,16 +30,21 @@
 from mongokit import *
 from mongokit.schema_document import DotExpandedDict
 
+import six
+
 class HelpersTestCase(unittest.TestCase):
         
     def test_DotExpandedDict(self):
-        d = DotExpandedDict({'a.$int.c.d': 3, 'a.$int.e': 5, '_id': u'user', 'a.g': 2, 'f': 6})
-        assert d == {'_id': u'user', 'a':{int:{'c':{'d':3}, 'e':5}, "g":2}, 'f':6}, d
-
-        d = DotExpandedDict({'foo.bla.$unicode': [unicode], 'foo.bar': {}})
-        assert d == {'foo': {'bar': {}, 'bla': {unicode: [unicode]}}}, d
+        d = DotExpandedDict({'a.$int.c.d': 3, 'a.$int.e': 5, '_id': 'user', 'a.g': 2, 'f': 6})
+        assert d == {'_id': 'user', 'a':{int:{'c':{'d':3}, 'e':5}, "g":2}, 'f':6}, d
+        
+        if six.PY2:
+            d = DotExpandedDict({'foo.bla.$unicode': [unicode], 'foo.bar': {}})
+        else:
+            d = DotExpandedDict({'foo.bla.$str': [str], 'foo.bar': {}})
+        assert d == {'foo': {'bar': {}, 'bla': {str: [str]}}}, d
 
-        self.assertRaises(EvalException, DotExpandedDict, {'foo.bla.$arf': [unicode], 'foo.bar': {}})
+        self.assertRaises(EvalException, DotExpandedDict, {'foo.bla.$arf': [str], 'foo.bar': {}})
 
         d = DotExpandedDict({'person.1.firstname': ['Simon'],
           'person.1.lastname': ['Willison'],
@@ -60,21 +65,21 @@ def test_DotCollapsedDict(self):
         d = DotCollapsedDict(dic)
         assert d == {'bar.foo':{}}, d
 
-        dic = {'_id': u'user', 'a':3, 'e':5, "g":2, 'f':6}
+        dic = {'_id': 'user', 'a':3, 'e':5, "g":2, 'f':6}
         d = DotCollapsedDict(dic)
-        assert d == {'_id': u'user', 'a':3, 'e':5, "g":2, 'f':6}, d
+        assert d == {'_id': 'user', 'a':3, 'e':5, "g":2, 'f':6}, d
 
-        dic = {'_id': u'user', 'a':{'b':{'c':{'d':3}, 'e':5}, "g":2}, 'f':6}
+        dic = {'_id': 'user', 'a':{'b':{'c':{'d':3}, 'e':5}, "g":2}, 'f':6}
         d = DotCollapsedDict(dic)
-        assert d == {'a.b.c.d': 3, '_id': u'user', 'a.b.e': 5, 'a.g': 2, 'f': 6}, d
+        assert d == {'a.b.c.d': 3, '_id': 'user', 'a.b.e': 5, 'a.g': 2, 'f': 6}, d
 
-        dic = {'_id': u'user', 'a':{'b':1, 'd':3, 'e':5}, 'f':6}
+        dic = {'_id': 'user', 'a':{'b':1, 'd':3, 'e':5}, 'f':6}
         d = DotCollapsedDict(dic)
-        assert d == {'_id': u'user', 'a.b': 1, 'a.d': 3, 'a.e': 5, 'f': 6}, d
+        assert d == {'_id': 'user', 'a.b': 1, 'a.d': 3, 'a.e': 5, 'f': 6}, d
 
-        dic = {'_id': u'user', 'a':{'b':1, 'd':3, 'e':{'g':5, 'h':0}}, 'f':6}
+        dic = {'_id': 'user', 'a':{'b':1, 'd':3, 'e':{'g':5, 'h':0}}, 'f':6}
         d = DotCollapsedDict(dic)
-        assert d == {'a.d': 3, 'a.e.h': 0, 'a.b': 1, 'f': 6, 'a.e.g': 5, '_id': u'user'}, d
+        assert d == {'a.d': 3, 'a.e.h': 0, 'a.b': 1, 'f': 6, 'a.e.g': 5, '_id': 'user'}, d
 
     def test_DotCollapsedDict_with_reference(self):
         dic = {'foo':{}}
@@ -94,40 +99,47 @@ def test_DotCollapsedDict_with_reference(self):
 #        d = DotCollapsedDict(dic, reference={'bar.foo':None, 'bar':{'bla':None}})
 #        assert d == {'bar.foo':3, 'bar':{'bla':2}}, d
 
-        dic = {'_id': u'user', 'a':3, 'e':5, "g":2, 'f':6}
+        dic = {'_id': 'user', 'a':3, 'e':5, "g":2, 'f':6}
         d = DotCollapsedDict(dic,  reference=dic)
-        assert d == {'_id': u'user', 'a':3, 'e':5, "g":2, 'f':6}, d
+        assert d == {'_id': 'user', 'a':3, 'e':5, "g":2, 'f':6}, d
 
-        dic = {'_id': u'user', 'a':{'b':1, 'd':3, 'e':{'g':5, 'h':0}}, 'f':6}
+        dic = {'_id': 'user', 'a':{'b':1, 'd':3, 'e':{'g':5, 'h':0}}, 'f':6}
         d = DotCollapsedDict(dic, reference={'_id':None, 'a.b':1, 'a.d':3, 'a.e':{'g':5, 'h':0}, 'a.f':6})
-        assert d == {'a.d': 3, 'a.b': 1, 'f': 6, 'a.e':{'g': 5, 'h':0}, '_id': u'user'}, d
+        assert d == {'a.d': 3, 'a.b': 1, 'f': 6, 'a.e':{'g': 5, 'h':0}, '_id': 'user'}, d
 
-        dic = {'_id': u'user', 'a':{'b':{'c':{'d':3}, 'e':5}, "g":2}, 'f':6}
+        dic = {'_id': 'user', 'a':{'b':{'c':{'d':3}, 'e':5}, "g":2}, 'f':6}
         d = DotCollapsedDict(dic, reference={'_id':None, 'a.b':{'c':{'d':3}, 'e':5}, 'a.g':2, 'f':6})
-        assert d == {'_id': u'user', 'a.b':{'c': {'d': 3}, 'e':5}, 'a.g': 2, 'f': 6}, d
+        assert d == {'_id': 'user', 'a.b':{'c': {'d': 3}, 'e':5}, 'a.g': 2, 'f': 6}, d
 
     def test_DotCollapsedDict_with_remove_under_type(self):
-        dic = {'_id': u'user', 'a':{int:{'c':{'d':3}, 'e':5}, "g":2}, 'f':6}
+        dic = {'_id': 'user', 'a':{int:{'c':{'d':3}, 'e':5}, "g":2}, 'f':6}
         d = DotCollapsedDict(dic, remove_under_type=True)
-        assert d == {'a': {}, '_id': u'user', 'f': 6}, d
+        assert d == {'a': {}, '_id': 'user', 'f': 6}, d
 
-        dic = {'bla':{'foo':{unicode:{"bla":int}}, 'bar':unicode}}
+        dic = {'bla':{'foo':{str:{"bla":int}}, 'bar':str}}
         d = DotCollapsedDict(dic, remove_under_type=True)
-        assert d == {'bla.foo':{}, 'bla.bar':unicode}, d
+        assert d == {'bla.foo':{}, 'bla.bar':str}, d
 
-        dic = {'bla':{'foo':{unicode:[unicode]}, 'bar':"egg"}}
+        dic = {'bla':{'foo':{str:[str]}, 'bar':"egg"}}
         d = DotCollapsedDict(dic, remove_under_type=True)
         assert d == {'bla.foo':{}, 'bla.bar':"egg"}, d
 
     def test_DotCollapsedDict_with_type(self):
-        dic = {'_id': u'user', 'a':{int:{'c':{'d':3}, 'e':5}, "g":2}, 'f':6}
+        dic = {'_id': 'user', 'a':{int:{'c':{'d':3}, 'e':5}, "g":2}, 'f':6}
         d = DotCollapsedDict(dic)
-        assert d == {'a.$int.c.d': 3, 'a.$int.e': 5, '_id': u'user', 'a.g': 2, 'f': 6}, d
+        assert d == {'a.$int.c.d': 3, 'a.$int.e': 5, '_id': 'user', 'a.g': 2, 'f': 6}, d
 
-        dic = {'bla':{'foo':{unicode:{"bla":3}}, 'bar':'egg'}}
+        dic = {'bla':{'foo':{str:{"bla":3}}, 'bar':'egg'}}
         d = DotCollapsedDict(dic)
-        assert d == {'bla.foo.$unicode.bla': 3, 'bla.bar': "egg"}, d
-
-        dic = {'bla':{'foo':{unicode:['egg']}, 'bar':"egg"}}
+        if six.PY2:
+            assert d == {'bla.foo.$unicode.bla': 3, 'bla.bar': "egg"}, d
+        else:
+            assert d == {'bla.foo.$str.bla': 3, 'bla.bar': "egg"}, d
+            
+        dic = {'bla':{'foo':{str:['egg']}, 'bar':"egg"}}
         d = DotCollapsedDict(dic)
-        assert d == {'bla.foo.$unicode': ['egg'], 'bla.bar': 'egg'}, d
+        if six.PY2:
+            assert d == {'bla.foo.$unicode': ['egg'], 'bla.bar': 'egg'}, d
+        else:
+            assert d == {'bla.foo.$str': ['egg'], 'bla.bar': 'egg'}, d
+            
diff --git a/tests/test_i18n.py b/tests/test_i18n.py
index a493282..d382db1 100644
--- a/tests/test_i18n.py
+++ b/tests/test_i18n.py
@@ -31,6 +31,8 @@
 from bson.objectid import ObjectId
 from mongokit.helpers import i18nDotedDict
 
+import six
+
 
 class i18nTestCase(unittest.TestCase):
     def setUp(self):
@@ -44,13 +46,13 @@ def tearDown(self):
     def test_simple_i18n(self):
         class Doc(Document):
             structure = {
-                'title':unicode,
+                'title':str,
             }
             i18n = ['title']
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title']['en'] = u'Hello'
-        doc['title']['fr'] = u"Salut"
+        doc['title']['en'] = 'Hello'
+        doc['title']['fr'] = "Salut"
         doc.save()
 
         assert doc == {'_id':doc['_id'], 'title':{'en':'Hello', 'fr':'Salut'}}, doc
@@ -97,21 +99,21 @@ class Doc(Document):
         assert doc.title == 3
         doc.set_lang('es')
         doc.title = 4
-        assert doc == {'_id':doc['_id'], u'title': {u'fr': 10, u'en': 3, 'es': 4}}
+        assert doc == {'_id':doc['_id'], 'title': {'fr': 10, 'en': 3, 'es': 4}}
 
     def test_i18n_with_list(self):
         class Doc(Document):
             use_dot_notation = True
             structure = {
-                "title":[unicode]
+                "title":[str]
             }
             i18n = ['title']
         self.connection.register([Doc])
         
         doc = self.col.Doc()
-        doc.title = [u'Hello', u'Hi']
+        doc.title = ['Hello', 'Hi']
         doc.set_lang('fr')
-        doc.title = [u'Bonjour', u'Salut']
+        doc.title = ['Bonjour', 'Salut']
         doc.save()
 
         assert doc.title == ['Bonjour', 'Salut']
@@ -124,7 +126,7 @@ def test_i18n_nested_dict(self):
         class Doc(Document):
             structure = {
                 'title':{
-                    'foo':unicode,
+                    'foo':str,
                     'bar':{'bla':int},
                     'egg':int,
                 }
@@ -132,19 +134,24 @@ class Doc(Document):
             i18n = ['title.foo', 'title.bar.bla']
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title']['foo']['fr'] = u'Salut'
+        doc['title']['foo']['fr'] = 'Salut'
         doc['title']['bar']['bla']['fr'] = 3
         doc['title']['egg'] = 4
-        doc['title']['foo']['en'] = u"Hello"
+        doc['title']['foo']['en'] = "Hello"
         doc['title']['bar']['bla']['en'] = 2
-        assert doc == {'title': {'foo': {'fr': u'Salut', 'en': u'Hello'}, 'bar': {'bla': {'fr': 3, 'en': 2}}, 'egg':4}}, doc
+        assert doc == {'title': {'foo': {'fr': 'Salut', 'en': 'Hello'}, 'bar': {'bla': {'fr': 3, 'en': 2}}, 'egg':4}}, doc
         doc.save()
 
         raw_doc = self.col.find_one({'_id':doc['_id']})
-        assert raw_doc == {'_id':doc['_id'],
-          u'title': {u'foo': [{u'lang': u'fr', u'value': u'Salut'}, {u'lang': u'en', u'value': u'Hello'}],
-          u'bar': {u'bla': [{u'lang': u'fr', u'value': 3}, {u'lang': u'en', u'value': 2}]}, 'egg':4}
-        }, raw_doc
+        # The i18n data is stored in a list, parsed from the dict in 'foo'.
+        # Since python does not guarantee an order to dict, the list might
+        # change order, so it is sorted for testing
+        raw_doc['title']['foo'].sort(key=lambda i: i['lang'])
+        raw_doc['title']['bar']['bla'].sort(key=lambda i: i['lang'])
+        self.assertEqual(raw_doc, {'_id':doc['_id'],
+          'title': {'foo': [{'lang': 'en', 'value': 'Hello'}, {'lang': 'fr', 'value': 'Salut'}],
+          'bar': {'bla': [{'lang': 'en', 'value': 2}, {'lang': 'fr', 'value': 3}]}, 'egg':4}
+        })
         fetched_doc = self.col.Doc.find_one({'_id':doc['_id']})
         assert fetched_doc['title']['foo']['en'] == 'Hello'
         assert fetched_doc['title']['foo']['fr'] == 'Salut'
@@ -155,7 +162,7 @@ class Doc(Document):
             structure = {
                 'toto':{'titi':{'tata':int}},
                 'title':{
-                    'foo':unicode,
+                    'foo':str,
                     'bar':{'bla':int},
                     'egg':int,
                 }
@@ -169,18 +176,18 @@ class Doc(Document):
         assert isinstance(doc.title.bar, i18nDotedDict), type(doc.title.bar)
         assert doc.title.foo is None, type(doc.title.foo)
         doc.get_lang() == 'fr'
-        doc.title.foo = u'Salut'
+        doc.title.foo = 'Salut'
         doc.title.bar.bla = 3
         doc.title.egg = 4
         doc.set_lang('en')
-        doc.title.foo = u"Hello"
+        doc.title.foo = "Hello"
         doc.title.bar.bla = 2
         doc.save()
 
         self.assertEqual(doc.toto, {'titi': {'tata': None}})
         self.assertEqual(doc.title, {
             'egg': 4,
-            'foo': {'fr': u'Salut', 'en': u'Hello'},
+            'foo': {'fr': 'Salut', 'en': 'Hello'},
             'bar': {'bla': {'fr': 3, 'en': 2}}
         })
         doc.validate()
@@ -188,24 +195,26 @@ class Doc(Document):
         self.assertEqual(doc.toto, {'titi': {'tata': None}})
         self.assertEqual(doc.title, {
             'egg': 4,
-            'foo': {'fr': u'Salut', 'en': u'Hello'},
+            'foo': {'fr': 'Salut', 'en': 'Hello'},
             'bar': {'bla': {'fr': 3, 'en': 2}}
         })
-        self.assertEqual(doc.title.foo, u"Salut")
+        self.assertEqual(doc.title.foo, "Salut")
         self.assertEqual(doc.title.bar.bla, 3)
         doc.save()
 
         raw_doc = self.col.find_one({'_id':doc['_id']})
+        raw_doc['title']['foo'].sort(key=lambda i: i['lang'])
+        raw_doc['title']['bar']['bla'].sort(key=lambda i: i['lang'])
         self.assertEqual(raw_doc, {'_id':doc['_id'],
-          u'toto': {u'titi': {u'tata': None}},
-          u'title': {
-              u'foo':[
-                  {u'lang': u'fr', u'value': u'Salut'},
-                  {u'lang': u'en', u'value': u'Hello'}
+          'toto': {'titi': {'tata': None}},
+          'title': {
+              'foo':[
+                  {'lang': 'en', 'value': 'Hello'},
+                  {'lang': 'fr', 'value': 'Salut'}
                 ],
-              u'bar': {u'bla': [
-                  {u'lang': u'fr', u'value': 3},
-                  {u'lang': u'en', u'value': 2}
+              'bar': {'bla': [
+                  {'lang': 'en', 'value': 2},
+                  {'lang': 'fr', 'value': 3}
                 ]},
               'egg':4}
         })
@@ -224,7 +233,7 @@ class Doc(Document):
             use_dot_notation = True
             structure = {
                 'title':{
-                    'foo':unicode,
+                    'foo':str,
                 },
                 'bar':int,
             }
@@ -232,13 +241,13 @@ class Doc(Document):
         self.connection.register([Doc])
         doc = self.col.Doc()
         doc.get_lang() == 'en'
-        doc.title.foo = u"Hello"
+        doc.title.foo = "Hello"
         doc.bar = 3
         doc.save()
         doc.set_lang('fr')
         assert doc.title.foo == 'Hello'
         assert doc.bar == 3
-        doc.title.foo = u'Salut'
+        doc.title.foo = 'Salut'
         doc.bar = 4
         assert doc.title.foo == 'Salut'
         assert doc.bar == 4
@@ -247,12 +256,12 @@ class Doc(Document):
     def test_i18n_bad_type(self):
         class Doc(Document):
             structure = {
-                'title':unicode,
+                'title':str,
             }
             i18n = ['title']
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title']['en'] = u'Hello'
+        doc['title']['en'] = 'Hello'
         doc['title']['fr'] = 3
         self.assertRaises(SchemaTypeError, doc.save)
 
@@ -261,10 +270,10 @@ def test_bad_i18n(self):
         try:
             class Doc(Document):
                 structure = {
-                    'title':unicode,
+                    'title':str,
                 }
                 i18n = ['title', 'bla']
-        except ValueError, e:
+        except ValueError as e:
             self.assertEqual(str(e), "Error in i18n: can't find bla in structure")
             failed = True
         self.assertEqual(failed, True)
@@ -272,17 +281,17 @@ class Doc(Document):
         class Doc(Document):
             use_dot_notation = True
             structure = {
-                'title':unicode,
+                'title':str,
             }
             i18n = ['title']
         self.connection.register([Doc])
         doc = self.col.Doc()
-        doc['title']['en'] = u'Hello'
-        doc['title'] = u"Salut"
+        doc['title']['en'] = 'Hello'
+        doc['title'] = "Salut"
         self.assertRaises(SchemaTypeError, doc.save)
         doc['title'] = i18n()
-        doc['title']['en'] = u'Hello'
-        doc['title']['fr'] = u"Salut"
+        doc['title']['en'] = 'Hello'
+        doc['title']['fr'] = "Salut"
         doc.save()
         doc = self.col.Doc.find_random()
         assert doc['title'] == {'en':'Hello', 'fr':'Salut'}
@@ -291,7 +300,7 @@ def test_i18n_inheritance(self):
         class A(Document):
             structure = {
                 'a':{
-                    'title':unicode,
+                    'title':str,
                 }
             }
             i18n = ['a.title']
@@ -299,7 +308,7 @@ class A(Document):
         class B(A):
             structure = {
                 'b':{
-                    'title':unicode,
+                    'title':str,
                 }
             }
             i18n = ['b.title']
@@ -308,7 +317,7 @@ class B(A):
         class C(Document):
             structure = {
                 'c':{
-                    'title':unicode,
+                    'title':str,
                 }
             }
             i18n = ['c.title']
@@ -316,47 +325,47 @@ class C(Document):
         class D(B, C):
             structure = {
                 'd':{
-                    'title':unicode,
+                    'title':str,
                 }
             }
 
         self.connection.register([D])
         doc = self.col.D()
-        assert doc.i18n == ['a.title', 'c.title', 'b.title'], doc.i18n
-        doc['a']['title']['en'] = u'Hello'
-        doc['b']['title']['fr'] = u"Salut"
-        doc['c']['title']['fr'] = u"Salut"
-        assert doc == {'a': {'title': {'en': u'Hello'}}, 'c': {'title': {'fr': u'Salut'}}, 'b': {'title': {'fr': u'Salut'}}, 'd': {'title': None}}
+        assert set(doc.i18n) == set(['a.title', 'c.title', 'b.title']), doc.i18n
+        doc['a']['title']['en'] = 'Hello'
+        doc['b']['title']['fr'] = "Salut"
+        doc['c']['title']['fr'] = "Salut"
+        assert doc == {'a': {'title': {'en': 'Hello'}}, 'c': {'title': {'fr': 'Salut'}}, 'b': {'title': {'fr': 'Salut'}}, 'd': {'title': None}}
 
     def test_i18n_default_values(self):
         class Doc(Document):
             use_dot_notation = True
             structure = {
                 'title':int,
-                'foo':{'bar':unicode},
+                'foo':{'bar':str},
             }
             i18n = ['title', 'foo.bar']
-            default_values = {'title':{'en':3, 'fr':4}, 'foo.bar': {'en':u'bla', 'fr': u'ble'}}
+            default_values = {'title':{'en':3, 'fr':4}, 'foo.bar': {'en':'bla', 'fr': 'ble'}}
         self.connection.register([Doc])
         doc = self.col.Doc()
-        assert doc == {'foo': {'bar': {'fr': u'ble', 'en': u'bla'}}, 'title': {'fr': 4, 'en': 3}}
+        assert doc == {'foo': {'bar': {'fr': 'ble', 'en': 'bla'}}, 'title': {'fr': 4, 'en': 3}}
         doc.save()
 
     def test_unicode_type_as_key(self):
         class MyDoc(Document):
             structure = {
                 "foo":{
-                    "bar": unicode,
+                    "bar": str,
                     "bla":{
-                        unicode:[unicode],
+                        str:[str],
                     },
                 },
             }
             i18n = ['foo.bar']
         self.connection.register([MyDoc])
         doc = self.col.MyDoc()
-        doc['foo']['bla'][u'spam'] = [u'eggs']
-        doc['foo']['bar']['fr'] = u'bla'
+        doc['foo']['bla']['spam'] = ['eggs']
+        doc['foo']['bar']['fr'] = 'bla'
         doc.save()
 
 
diff --git a/tests/test_index.py b/tests/test_index.py
index f08cb8e..c1c4773 100644
--- a/tests/test_index.py
+++ b/tests/test_index.py
@@ -25,10 +25,14 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from __future__ import print_function
+
 import unittest
 
 from mongokit import Connection, Document, OperationFailure, BadIndexError, INDEX_GEO2D, INDEX_ASCENDING, INDEX_DESCENDING
 
+import six
+
 class IndexTestCase(unittest.TestCase):
     def setUp(self):
         self.connection = Connection()
@@ -41,11 +45,11 @@ def tearDown(self):
     def test_index_basic(self):
         class Movie(Document):
             structure = {
-                'standard':unicode,
+                'standard':str,
                 'other':{
-                    'deep':unicode,
+                    'deep':str,
                 },
-                'notindexed':unicode,
+                'notindexed':str,
             }
 
             indexes = [
@@ -57,9 +61,9 @@ class Movie(Document):
         self.connection.register([Movie])
         movie = self.col.Movie()
         self.col.Movie.generate_index(self.col.Movie.collection)
-        movie['standard'] = u'test'
-        movie['other']['deep'] = u'testdeep'
-        movie['notindexed'] = u'notthere'
+        movie['standard'] = 'test'
+        movie['other']['deep'] = 'testdeep'
+        movie['notindexed'] = 'notthere'
         movie.save()
 
         db = self.connection.test
@@ -67,14 +71,14 @@ class Movie(Document):
         assert item is not None, 'No Index Found'
 
         movie = self.col.Movie()
-        movie['standard'] = u'test'
-        movie['other']['deep'] = u'testdeep'
+        movie['standard'] = 'test'
+        movie['other']['deep'] = 'testdeep'
         self.assertRaises(OperationFailure, movie.save)
 
     def test_index_single_without_generation(self):
         class Movie(Document):
             structure = {
-                'standard':unicode,
+                'standard':str,
             }
 
             indexes = [
@@ -85,7 +89,7 @@ class Movie(Document):
             ]
         self.connection.register([Movie])
         movie = self.col.Movie()
-        movie['standard'] = u'test'
+        movie['standard'] = 'test'
         movie.save()
 
         db = self.connection.test
@@ -96,7 +100,7 @@ class Movie(Document):
     def test_index_single(self):
         class Movie(Document):
             structure = {
-                'standard':unicode,
+                'standard':str,
             }
 
             indexes = [
@@ -108,7 +112,7 @@ class Movie(Document):
         self.connection.register([Movie])
         self.col.Movie.generate_index(self.col.Movie.collection)
         movie = self.col.Movie()
-        movie['standard'] = u'test'
+        movie['standard'] = 'test'
         movie.save()
 
         db = self.connection.test
@@ -119,12 +123,12 @@ class Movie(Document):
     def test_index_multi(self):
         class Movie(Document):
             structure = {
-                'standard':unicode,
+                'standard':str,
                 'other':{
-                    'deep':unicode,
+                    'deep':str,
                 },
-                'notindexed':unicode,
-                'alsoindexed':unicode,
+                'notindexed':str,
+                'alsoindexed':str,
             }
 
             indexes = [
@@ -140,7 +144,7 @@ class Movie(Document):
         self.connection.register([Movie])
         self.col.Movie.generate_index(self.col.Movie.collection)
         movie = self.col.Movie()
-        movie['standard'] = u'test'
+        movie['standard'] = 'test'
         movie.save()
 
         db = self.connection.test
@@ -151,18 +155,18 @@ class Movie(Document):
         assert index2 is not None, 'Index not found'
 
         movie = self.col.Movie()
-        movie['standard'] = u'test'
+        movie['standard'] = 'test'
         self.assertRaises(OperationFailure, movie.save)
 
     def test_index_multi2(self):
         class Movie(Document):
             structure = {
-                'standard':unicode,
+                'standard':str,
                 'other':{
-                    'deep':unicode,
+                    'deep':str,
                 },
-                'notindexed':unicode,
-                'alsoindexed':unicode,
+                'notindexed':str,
+                'alsoindexed':str,
             }
 
             indexes = [
@@ -178,8 +182,8 @@ class Movie(Document):
         self.connection.register([Movie])
         self.col.Movie.generate_index(self.col.Movie.collection)
         movie = self.col.Movie()
-        movie['standard'] = u'test'
-        movie['other']['deep'] = u'foo'
+        movie['standard'] = 'test'
+        movie['other']['deep'] = 'foo'
         movie.save()
 
         db = self.connection.test
@@ -190,22 +194,22 @@ class Movie(Document):
         assert index2 is not None, 'Index not found'
 
         movie = self.col.Movie()
-        movie['standard'] = u'test'
+        movie['standard'] = 'test'
         self.assertRaises(OperationFailure, movie.save)
 
         movie = self.col.Movie()
-        movie['other']['deep'] = u'foo'
+        movie['other']['deep'] = 'foo'
         self.assertRaises(OperationFailure, movie.save)
 
     def test_index_direction(self):
         class Movie(Document):
             structure = {
-                'standard':unicode,
+                'standard':str,
                 'other':{
-                    'deep':unicode,
+                    'deep':str,
                 },
-                'notindexed':unicode,
-                'alsoindexed':unicode,
+                'notindexed':str,
+                'alsoindexed':str,
             }
 
             indexes = [
@@ -221,7 +225,7 @@ class Movie(Document):
         self.connection.register([Movie])
         self.col.Movie.generate_index(self.col.Movie.collection)
         movie = self.col.Movie()
-        movie['standard'] = u'test'
+        movie['standard'] = 'test'
         movie.save()
 
         db = self.connection.test
@@ -234,12 +238,12 @@ class Movie(Document):
     def test_index_direction_GEO2D(self):
         class Movie(Document):
             structure = {
-                'standard':unicode,
+                'standard':str,
                 'other':{
-                    'deep':unicode,
+                    'deep':str,
                 },
-                'notindexed':unicode,
-                'alsoindexed':unicode,
+                'notindexed':str,
+                'alsoindexed':str,
             }
 
             indexes = [
@@ -255,7 +259,7 @@ class Movie(Document):
         self.connection.register([Movie])
         self.col.Movie.generate_index(self.col.Movie.collection)
         movie = self.col.Movie()
-        movie['standard'] = u'test'
+        movie['standard'] = 'test'
         movie.save()
 
         db = self.connection.test
@@ -269,9 +273,9 @@ def test_bad_index_descriptor(self):
         failed = False
         try:
             class Movie(Document):
-                structure = {'standard':unicode}
+                structure = {'standard':str}
                 indexes = [{'unique':True}]
-        except BadIndexError, e:
+        except BadIndexError as e:
             self.assertEqual(str(e), "'fields' key must be specify in indexes")
             failed = True
         self.assertEqual(failed, True)
@@ -280,7 +284,7 @@ class Movie(Document):
         try:
             class Movie(Document):
                 structure = {
-                    'standard':unicode,
+                    'standard':str,
                 }
                 indexes = [
                     {
@@ -288,7 +292,7 @@ class Movie(Document):
                         'uniq':True,
                     },
                 ]
-        except BadIndexError, e:
+        except BadIndexError as e:
             self.assertEqual(str(e), "uniq is unknown key for indexes")
             failed = True
         #self.assertEqual(failed, True)
@@ -297,14 +301,14 @@ class Movie(Document):
         try:
             class Movie(Document):
                 structure = {
-                    'standard':unicode,
+                    'standard':str,
                 }
                 indexes = [
                     {
                         'fields':'std',
                     },
                 ]
-        except ValueError, e:
+        except ValueError as e:
             self.assertEqual(str(e), "Error in indexes: can't find std in structure")
             failed = True
         self.assertEqual(failed, True)
@@ -313,15 +317,15 @@ class Movie(Document):
         try:
             class Movie(Document):
                 structure = {
-                    'standard':unicode,
+                    'standard':str,
                 }
                 indexes = [
                     {
                         'fields':{'standard':1},
                     },
                 ]
-        except BadIndexError, e:
-            self.assertEqual(str(e), "fields must be a string, a tuple or a list of tuple (got <type 'dict'> instead)")
+        except BadIndexError as e:
+            self.assertEqual(str(e), "fields must be a string, a tuple or a list of tuple (got <%s 'dict'> instead)" % ('type' if six.PY2 else 'class'))
             failed = True
         self.assertEqual(failed, True)
 
@@ -329,14 +333,14 @@ class Movie(Document):
         try:
             class Movie(Document):
                 structure = {
-                    'standard':unicode,
+                    'standard':str,
                 }
                 indexes = [
                     {
                         'fields':('standard',1, "blah"),
                     },
                 ]
-        except BadIndexError, e:
+        except BadIndexError as e:
             self.assertEqual(str(e), "Error in indexes: a tuple must contain only two value : the field name and the direction")
             failed = True
         self.assertEqual(failed, True)
@@ -345,14 +349,14 @@ class Movie(Document):
         try:
             class Movie(Document):
                 structure = {
-                    'standard':unicode,
+                    'standard':str,
                 }
                 indexes = [
                     {
                         'fields':('standard',"2"),
                     },
                 ]
-        except BadIndexError, e:
+        except BadIndexError as e:
             self.assertEqual(str(e), "index direction must be INDEX_DESCENDING, INDEX_ASCENDING, INDEX_OFF, INDEX_ALL, INDEX_GEO2D, INDEX_GEOHAYSTACK, or INDEX_GEOSPHERE. Got 2")
             failed = True
         self.assertEqual(failed, True)
@@ -361,15 +365,15 @@ class Movie(Document):
         try:
             class Movie(Document):
                 structure = {
-                    'standard':unicode,
+                    'standard':str,
                 }
                 indexes = [
                     {
                         'fields':(3,1),
                     },
                 ]
-        except BadIndexError, e:
-            self.assertEqual(str(e), "Error in 3, the field name must be string (got <type 'int'> instead)")
+        except BadIndexError as e:
+            self.assertEqual(str(e), "Error in 3, the field name must be string (got <%s 'int'> instead)" % ('type' if six.PY2 else 'class'))
             failed = True
         self.assertEqual(failed, True)
 
@@ -377,14 +381,14 @@ class Movie(Document):
         try:
             class Movie(Document):
                 structure = {
-                    'standard':unicode,
+                    'standard':str,
                 }
                 indexes = [
                     {
                         'fields':("blah",1),
                     },
                 ]
-        except ValueError, e:
+        except ValueError as e:
             self.assertEqual(str(e), "Error in indexes: can't find blah in structure")
             failed = True
         self.assertEqual(failed, True)
@@ -393,14 +397,14 @@ class Movie(Document):
         try:
             class Movie(Document):
                 structure = {
-                    'standard':unicode,
+                    'standard':str,
                 }
                 indexes = [
                     {
                         'fields':[('standard',1), ('bla',1)],
                     },
                 ]
-        except ValueError, e:
+        except ValueError as e:
             self.assertEqual(str(e), "Error in indexes: can't find bla in structure")
             failed = True
         self.assertEqual(failed, True)
@@ -409,14 +413,14 @@ class Movie(Document):
         try:
             class Movie(Document):
                 structure = {
-                    'standard':unicode,
+                    'standard':str,
                 }
                 indexes = [
                     {
                         'fields':[('standard',3)],
                     },
                 ]
-        except BadIndexError, e:
+        except BadIndexError as e:
             self.assertEqual(str(e), "index direction must be INDEX_DESCENDING, INDEX_ASCENDING, INDEX_OFF, INDEX_ALL, INDEX_GEO2D, INDEX_GEOHAYSTACK, or INDEX_GEOSPHERE. Got 3")
             failed = True
         self.assertEqual(failed, True)
@@ -425,14 +429,14 @@ class Movie(Document):
         try:
             class Movie(Document):
                 structure = {
-                    'standard':unicode,
+                    'standard':str,
                 }
                 indexes = [
                     {
                         'fields':['std'],
                     },
                 ]
-        except ValueError, e:
+        except ValueError as e:
             self.assertEqual(str(e), "Error in indexes: can't find std in structure")
             failed = True
         self.assertEqual(failed, True)
@@ -440,7 +444,7 @@ class Movie(Document):
     def test_index_ttl(self):
         class Movie(Document):
             structure = {
-                'standard':unicode,
+                'standard':str,
             }
 
             indexes = [
@@ -454,7 +458,7 @@ class Movie(Document):
         self.connection.register([Movie])
         self.col.Movie.generate_index(self.col)
         movie = self.col.Movie()
-        movie['standard'] = u'test'
+        movie['standard'] = 'test'
         movie.save()
 
         db = self.connection.test
@@ -465,7 +469,7 @@ class Movie(Document):
     def test_index_simple_inheritance(self):
         class DocA(Document):
             structure = {
-                'standard':unicode,
+                'standard':str,
             }
 
             indexes = [
@@ -477,14 +481,14 @@ class DocA(Document):
 
         class DocB(DocA):
             structure = {
-                'docb':unicode,
+                'docb':str,
             }
 
         self.connection.register([DocA, DocB])
         self.col.DocB.generate_index(self.col)
         docb = self.col.DocB()
-        docb['standard'] = u'test'
-        docb['docb'] = u'foo'
+        docb['standard'] = 'test'
+        docb['docb'] = 'foo'
         docb.save()
 
         db = self.connection.test
@@ -495,7 +499,7 @@ class DocB(DocA):
     def test_index_inheritance(self):
         class DocA(Document):
             structure = {
-                'standard':unicode,
+                'standard':str,
             }
 
             indexes = [
@@ -507,7 +511,7 @@ class DocA(Document):
 
         class DocB(DocA):
             structure = {
-                'docb':unicode,
+                'docb':str,
             }
             indexes = [
                 {
@@ -520,8 +524,8 @@ class DocB(DocA):
 
 
         docb = self.col.DocB()
-        docb['standard'] = u'test'
-        docb['docb'] = u'foo'
+        docb['standard'] = 'test'
+        docb['docb'] = 'foo'
         docb.save()
 
         db = self.connection.test
@@ -546,13 +550,13 @@ class MyDoc(Document):
 
         mydoc = self.col.MyDoc()
         mydoc['mydoc']['creation_date'] = date
-        mydoc['_id'] = u'aaa'
+        mydoc['_id'] = 'aaa'
         mydoc.save()
 
 
         mydoc3 = self.col.MyDoc()
         mydoc3['mydoc']['creation_date'] = date
-        mydoc3['_id'] = u'bbb'
+        mydoc3['_id'] = 'bbb'
         mydoc3.save()
 
         import time
@@ -561,7 +565,7 @@ class MyDoc(Document):
 
         mydoc2 = self.col.MyDoc()
         mydoc2['mydoc']['creation_date'] = date2
-        mydoc2['_id'] = u'aa'
+        mydoc2['_id'] = 'aa'
         mydoc2.save()
 
         time.sleep(1)
@@ -569,7 +573,7 @@ class MyDoc(Document):
 
         mydoc4 = self.col.MyDoc()
         mydoc4['mydoc']['creation_date'] = date3
-        mydoc4['_id'] = u'ccc'
+        mydoc4['_id'] = 'ccc'
         mydoc4.save()
 
         self.col.ensure_index([('mydoc.creation_date',-1), ('_id',1)])
@@ -582,37 +586,37 @@ def test_index_pymongo(self):
         import pymongo
         collection = pymongo.Connection()['test']['test_index']
 
-        mydoc = {'mydoc':{'creation_date':date}, '_id':u'aaa'}
+        mydoc = {'mydoc':{'creation_date':date}, '_id':'aaa'}
         collection.insert(mydoc)
 
-        mydoc2 = {'mydoc':{'creation_date':date}, '_id':u'bbb'}
+        mydoc2 = {'mydoc':{'creation_date':date}, '_id':'bbb'}
         collection.insert(mydoc2)
 
         import time
         time.sleep(1)
         date2 = datetime.datetime.utcnow()
 
-        mydoc3 = {'mydoc':{'creation_date':date2}, '_id':u'aa'}
+        mydoc3 = {'mydoc':{'creation_date':date2}, '_id':'aa'}
         collection.insert(mydoc3)
 
         time.sleep(1)
         date3 = datetime.datetime.utcnow()
 
-        mydoc4 = {'mydoc':{'creation_date':date3}, '_id':u'ccc'}
+        mydoc4 = {'mydoc':{'creation_date':date3}, '_id':'ccc'}
         collection.insert(mydoc4)
 
         collection.ensure_index([('mydoc.creation_date',-1), ('_id',1)])
         #print list(collection.database.system.indexes.find())
 
         results = [i['_id'] for i in collection.find().sort([('mydoc.creation_date',-1),('_id',1)])]
-        print results
-        assert results  == [u'ccc', u'aa', u'aaa', u'bbb'], results
+        print(results)
+        assert results == ['ccc', 'aa', 'aaa', 'bbb'], results
 
     def test_index_inheritance2(self):
         class A(Document):
             structure = {
                 'a':{
-                    'title':unicode,
+                    'title':str,
                 }
             }
             indexes = [{'fields':'a.title'}]
@@ -620,7 +624,7 @@ class A(Document):
         class B(A):
             structure = {
                 'b':{
-                    'title':unicode,
+                    'title':str,
                 }
             }
             indexes = [{'fields':'b.title'}]
@@ -629,7 +633,7 @@ class B(A):
         class C(Document):
             structure = {
                 'c':{
-                    'title':unicode,
+                    'title':str,
                 }
             }
             indexes = [{'fields':'c.title'}]
@@ -637,7 +641,7 @@ class C(Document):
         class D(B, C):
             structure = {
                 'd':{
-                    'title':unicode,
+                    'title':str,
                 }
             }
 
@@ -648,7 +652,7 @@ class D(B, C):
     def test_index_with_default_direction(self):
         class MyDoc(Document):
             structure = {
-                'foo': unicode,
+                'foo': str,
                 'bar': int
             }
             indexes = [
@@ -658,7 +662,7 @@ class MyDoc(Document):
         self.col.MyDoc.generate_index(self.col)
         for i in range(10):
            doc = self.col.MyDoc()
-           doc['foo'] = unicode(i)
+           doc['foo'] = str(i)
            doc['bar'] = i
            doc.save()
         assert self.col.database.system.indexes.find_one({'name': 'foo_1_bar_-1'})
@@ -676,7 +680,7 @@ class MyDoc(Document):
         self.col.MyDoc.generate_index(self.col)
         for i in range(10):
            doc = self.col.MyDoc()
-           doc['foo']['title'] = unicode(i)
+           doc['foo']['title'] = str(i)
            doc['bar'] = i
            doc.save()
         assert self.col.database.system.indexes.find_one({'name': 'foo.title_1'})
@@ -685,7 +689,7 @@ def test_index_with_check_is_true(self):
         @self.connection.register
         class MyDoc(Document):
             structure = {
-                'foo': unicode,
+                'foo': str,
                 'bar': int
             }
             indexes = [
@@ -694,7 +698,7 @@ class MyDoc(Document):
         self.col.MyDoc.generate_index(self.col)
         for i in range(10):
            doc = self.col.MyDoc()
-           doc['foo'] = unicode(i)
+           doc['foo'] = str(i)
            doc['bar'] = i
            doc.save()
         assert self.col.database.system.indexes.find_one({'name': 'foo_1'})
@@ -703,7 +707,7 @@ def test_index_with_additional_keywords(self):
         @self.connection.register
         class KWDoc(Document):
             structure = {
-                'foo': unicode,
+                'foo': str,
             }
             indexes = [
                 {
@@ -716,5 +720,5 @@ class KWDoc(Document):
             ]
         self.col.KWDoc.generate_index(self.col)
         index = self.col.database.system.indexes.find_one({'name': 'additional_kws'})
-        assert index["name"] == u'additional_kws'
+        assert index["name"] == 'additional_kws'
         assert index["dropDups"] is True
diff --git a/tests/test_inheritance.py b/tests/test_inheritance.py
index 0d7c36b..6d8bfd8 100644
--- a/tests/test_inheritance.py
+++ b/tests/test_inheritance.py
@@ -29,6 +29,8 @@
 
 from mongokit import *
 
+import six
+
 class InheritanceTestCase(unittest.TestCase):
     def setUp(self):
         self.collection = Connection()['test']['mongokit']
@@ -44,7 +46,7 @@ class A(SchemaDocument):
 
         class B(A):
             structure = {
-                "b":{"bar":unicode}
+                "b":{"bar":str}
             }
 
         assert B() == {"a":{"foo":None}, "b":{"bar":None}}, B()
@@ -72,7 +74,7 @@ class A(SchemaDocument):
 
         class B(A):
             structure = {
-                "b":{"bar":unicode}
+                "b":{"bar":str}
             }
 
         b = B()
@@ -89,14 +91,14 @@ class A(SchemaDocument):
 
         class B(A):
             structure = {
-                "b":{"bar":unicode}
+                "b":{"bar":str}
             }
 
         assert B() == {"a":{"foo":3}, "b":{"bar":None}}
  
         class C(A):
             structure = {
-                "c":{"spam":unicode}
+                "c":{"spam":str}
             }
             default_values = {"a.foo":5}
 
@@ -112,14 +114,14 @@ class A(SchemaDocument):
 
         class B(A):
             structure = {
-                "b":{"bar":unicode}
+                "b":{"bar":str}
             }
 
         assert isinstance(B()['a']['foo'], datetime)
  
         class C(A):
             structure = {
-                "c":{"spam":unicode}
+                "c":{"spam":str}
             }
             default_values = {"a.foo":datetime(2008,8,8)}
 
@@ -135,7 +137,7 @@ class A(SchemaDocument):
 
         class B(A):
             structure = {
-                "b":{"bar":unicode}
+                "b":{"bar":str}
             }
 
         b = B()
@@ -159,19 +161,19 @@ class D(C):
     def test_complexe_validation_inheritance(self):
         class A(SchemaDocument):
             structure = {
-                "foo":unicode,
+                "foo":str,
             }
             def validate(self):
-                self["foo"] = unicode(self["foo"])
+                self["foo"] = str(self["foo"])
                 super(A, self).validate()
 
         class B(A):
             structure = {
-                "bar":{"bla":unicode}
+                "bar":{"bla":str}
             }
             default_values = {"bar.bla":3}
             def validate(self):
-                self["bar"]["bla"] = unicode(self["bar"]["bla"])
+                self["bar"]["bla"] = str(self["bar"]["bla"])
                 super(B, self).validate()
 
         b = B()
@@ -190,7 +192,7 @@ class A(SchemaDocument):
 
         class B(A):
             structure = {
-                "b":{"bar":unicode}
+                "b":{"bar":str}
             }
             required_fields = ['b.bar']
             default_values = {"a.foo":5}
@@ -201,13 +203,13 @@ class B(A):
  
         class C(B):
             structure = {
-                "c":{"spam":unicode}
+                "c":{"spam":str}
             }
 
         c =  C()
         assert c == {"a":{"foo":5}, "b":{"bar":None}, "c":{"spam":None}}, C()
         self.assertRaises(RequireFieldError, c.validate)
-        c["b"]["bar"] = u"bla"
+        c["b"]["bar"] = "bla"
         c.validate()
 
     def test_polymorphism(self):
@@ -219,7 +221,7 @@ class A(SchemaDocument):
 
         class B(SchemaDocument):
             structure = {
-                "b":{"bar":unicode}
+                "b":{"bar":str}
             }
             required_fields = ['b.bar']
 
@@ -229,14 +231,14 @@ class B(SchemaDocument):
  
         class C(A,B):
             structure = {
-                "c":{"spam":unicode}
+                "c":{"spam":str}
             }
             default_values = {"a.foo":5}
 
         c =  C()
         assert c == {"a":{"foo":5}, "b":{"bar":None}, "c":{"spam":None}}, C()
         self.assertRaises(RequireFieldError, c.validate)
-        c["b"]["bar"] = u"bla"
+        c["b"]["bar"] = "bla"
         c.validate()
    
     def test_simple_manual_inheritance(self):
@@ -248,7 +250,7 @@ class A(SchemaDocument):
 
         class B(A):
             structure = {
-                "b":{"bar":unicode}
+                "b":{"bar":str}
             }
             structure.update(A.structure)
 
@@ -264,7 +266,7 @@ class A(SchemaDocument):
 
         class B(A):
             structure = {
-                "b":{"bar":unicode}
+                "b":{"bar":str}
             }
             structure.update(A.structure)
             required_fields = A.required_fields
@@ -284,7 +286,7 @@ class A(SchemaDocument):
 
         class B(A):
             structure = {
-                "b":{"bar":unicode}
+                "b":{"bar":str}
             }
             structure.update(A.structure)
             default_values = A.default_values
@@ -293,7 +295,7 @@ class B(A):
  
         class C(A):
             structure = {
-                "c":{"spam":unicode}
+                "c":{"spam":str}
             }
             structure.update(A.structure)
             default_values = A.default_values
diff --git a/tests/test_inherited_queries.py b/tests/test_inherited_queries.py
index 4c97e1c..c3b27b6 100644
--- a/tests/test_inherited_queries.py
+++ b/tests/test_inherited_queries.py
@@ -29,6 +29,8 @@
 
 from mongokit import Document, Connection
 
+import six
+
 class InheritedQueriesTestCase(unittest.TestCase):
     def setUp(self):
         self.connection = Connection(safe=True)
@@ -43,10 +45,10 @@ class A(Document):
             __database__ = 'test'
             __collection__ = 'mongolite'
             structure = {
-                '_type': unicode,
+                '_type': str,
                 'a':{
                     'foo': int,
-                    'bar': unicode,
+                    'bar': str,
                 }
             }
 
@@ -61,13 +63,13 @@ class B(A):
         doc_a = self.connection.A()
         self.assertEqual(doc_a['_type'], 'A')
         doc_a['a']['foo'] = 3
-        doc_a['a']['bar'] = u'Hello World'
+        doc_a['a']['bar'] = 'Hello World'
         doc_a.save()
 
         doc_b = self.connection.B()
         self.assertEqual(doc_b['_type'], 'B')
         doc_b['a']['foo'] = 42
-        doc_b['a']['bar'] = u'bye bye'
+        doc_b['a']['bar'] = 'bye bye'
         doc_b['b']['eggs'] = 3.14
         doc_b.save()
 
@@ -79,10 +81,10 @@ def test_inherited_queries_without___collection__(self):
         @self.connection.register
         class A(Document):
             structure = {
-                '_type': unicode,
+                '_type': str,
                 'a':{
                     'foo': int,
-                    'bar': unicode,
+                    'bar': str,
                 }
             }
 
@@ -97,13 +99,13 @@ class B(A):
         doc_a = self.col.A()
         self.assertEqual(doc_a['_type'], 'A')
         doc_a['a']['foo'] = 3
-        doc_a['a']['bar'] = u'Hello World'
+        doc_a['a']['bar'] = 'Hello World'
         doc_a.save()
 
         doc_b = self.col.B()
         self.assertEqual(doc_b['_type'], 'B')
         doc_b['a']['foo'] = 42
-        doc_b['a']['bar'] = u'bye bye'
+        doc_b['a']['bar'] = 'bye bye'
         doc_b['b']['eggs'] = 3.14
         doc_b.save()
 
@@ -116,10 +118,10 @@ def test_type_field_is_None(self):
         class A(Document):
             type_field = None
             structure = {
-                '_type': unicode,
+                '_type': str,
                 'a':{
                     'foo': int,
-                    'bar': unicode,
+                    'bar': str,
                 }
             }
 
@@ -134,13 +136,13 @@ class B(A):
         doc_a = self.col.A()
         self.assertEqual(doc_a['_type'], None)
         doc_a['a']['foo'] = 3
-        doc_a['a']['bar'] = u'Hello World'
+        doc_a['a']['bar'] = 'Hello World'
         doc_a.save()
 
         doc_b = self.col.B()
         self.assertEqual(doc_b['_type'], None)
         doc_b['a']['foo'] = 42
-        doc_b['a']['bar'] = u'bye bye'
+        doc_b['a']['bar'] = 'bye bye'
         doc_b['b']['eggs'] = 3.14
         doc_b.save()
 
@@ -155,7 +157,7 @@ class A(Document):
             structure = {
                 'a':{
                     'foo': int,
-                    'bar': unicode,
+                    'bar': str,
                 }
             }
 
@@ -170,13 +172,13 @@ class B(A):
         doc_a = self.col.A()
         self.assertTrue('_type' not in doc_a)
         doc_a['a']['foo'] = 3
-        doc_a['a']['bar'] = u'Hello World'
+        doc_a['a']['bar'] = 'Hello World'
         doc_a.save()
 
         doc_b = self.col.B()
         self.assertTrue('_type' not in doc_b)
         doc_b['a']['foo'] = 42
-        doc_b['a']['bar'] = u'bye bye'
+        doc_b['a']['bar'] = 'bye bye'
         doc_b['b']['eggs'] = 3.14
         doc_b.save()
 
@@ -190,11 +192,11 @@ def test_change_type_field(self):
         class A(Document):
             type_field = '_t'
             structure = {
-                '_type': unicode,
-                '_t': unicode,
+                '_type': str,
+                '_t': str,
                 'a':{
                     'foo': int,
-                    'bar': unicode,
+                    'bar': str,
                 }
             }
 
@@ -210,14 +212,14 @@ class B(A):
         self.assertEqual(doc_a['_type'], None)
         self.assertEqual(doc_a['_t'], 'A')
         doc_a['a']['foo'] = 3
-        doc_a['a']['bar'] = u'Hello World'
+        doc_a['a']['bar'] = 'Hello World'
         doc_a.save()
 
         doc_b = self.col.B()
         self.assertEqual(doc_b['_type'], None)
         self.assertEqual(doc_b['_t'], 'B')
         doc_b['a']['foo'] = 42
-        doc_b['a']['bar'] = u'bye bye'
+        doc_b['a']['bar'] = 'bye bye'
         doc_b['b']['eggs'] = 3.14
         doc_b.save()
 
diff --git a/tests/test_json.py b/tests/test_json.py
index c2dff25..7da0394 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -25,11 +25,14 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from __future__ import print_function
+
 import unittest
 
 from mongokit import *
 from bson.objectid import ObjectId
 import datetime
+import json
 
 
 class JsonTestCase(unittest.TestCase):
@@ -40,12 +43,12 @@ def setUp(self):
     def tearDown(self):
         self.connection['test'].drop_collection('mongokit')
         self.connection['test'].drop_collection('versionned_mongokit')
-
+        
     def test_simple_to_json(self):
         class MyDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                     "egg":datetime.datetime,
                 },
@@ -53,48 +56,48 @@ class MyDoc(Document):
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc['_id'] = 'mydoc'
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
         mydoc['bla']['egg'] = datetime.datetime(2010, 1, 1)
-        mydoc['spam'] = range(10)
+        mydoc['spam'] = list(range(10))
         mydoc.save()
         import json
         
         assert  json.loads(mydoc.to_json()) == json.loads('{"_id": "mydoc", "bla": {"egg": 1262304000000, "foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}'), mydoc.to_json()
-        assert  mydoc.to_json_type() == {'_id': 'mydoc', 'bla': {'egg': 1262304000000, 'foo': u'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, mydoc.to_json_type()
+        assert  mydoc.to_json_type() == {'_id': 'mydoc', 'bla': {'egg': 1262304000000, 'foo': 'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, mydoc.to_json_type()
 
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc2'
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc['_id'] = 'mydoc2'
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
         mydoc['spam'] = [datetime.datetime(2000, 1, 1), datetime.datetime(2008, 8, 8)]
         mydoc.save()
         assert json.loads(mydoc.to_json()) == json.loads('{"_id": "mydoc2", "bla": {"egg": null, "foo": "bar", "bar": 42}, "spam": [946684800000, 1218153600000]}'), mydoc.to_json()
-        assert mydoc.to_json_type() == {'_id': 'mydoc2', 'bla': {'egg': None, 'foo': u'bar', 'bar': 42}, 'spam': [946684800000, 1218153600000]}, mydoc.to_json_type()
+        assert mydoc.to_json_type() == {'_id': 'mydoc2', 'bla': {'egg': None, 'foo': 'bar', 'bar': 42}, 'spam': [946684800000, 1218153600000]}, mydoc.to_json_type()
 
     def test_simple_to_json_with_oid(self):
         class MyDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
-        mydoc['spam'] = range(10)
+        mydoc['spam'] = list(range(10))
         mydoc.save()
-        assert  isinstance(mydoc.to_json_type()['_id']['$oid'], basestring), type(mydoc.to_json_type()['_id'])
-        assert isinstance(mydoc.to_json(), unicode)
+        assert isinstance(mydoc.to_json_type()['_id']['$oid'], str), type(mydoc.to_json_type()['_id'])
+        assert isinstance(mydoc.to_json(), str)
  
     def test_simple_to_json_with_oid_in_list(self):
         class A(Document):
             structure = {
-                "foo":unicode,
+                "foo":str,
             }
         class B(Document):
             structure = {
@@ -106,42 +109,42 @@ class B(Document):
  
         self.connection.register([A, B])
         a = self.col.A()
-        a["foo"] = u"bar"
+        a["foo"] = "bar"
         a.save()
-        assert  isinstance(a.to_json_type()['_id']['$oid'], basestring), type(a.to_json_type()['_id'])
+        assert  isinstance(a.to_json_type()['_id']['$oid'], str), type(a.to_json_type()['_id'])
         a.to_json()
         b = self.col.B()
         b['bar'] = [a['_id']]
         b['egg']['nested'] = a['_id']
         b.save()
-        print b.to_json_type()
-        assert  isinstance(b.to_json_type()['_id']['$oid'], basestring), b.to_json_type()
-        assert  isinstance(b.to_json_type()['egg']['nested']['$oid'], basestring), b.to_json_type()
-        assert  isinstance(b.to_json_type()['bar'][0]['$oid'], basestring), b.to_json_type()
-        assert  isinstance(b.to_json_type()['egg']['nested']['$oid'], basestring), b.to_json_type()
+        print(b.to_json_type())
+        assert  isinstance(b.to_json_type()['_id']['$oid'], str), b.to_json_type()
+        assert  isinstance(b.to_json_type()['egg']['nested']['$oid'], str), b.to_json_type()
+        assert  isinstance(b.to_json_type()['bar'][0]['$oid'], str), b.to_json_type()
+        assert  isinstance(b.to_json_type()['egg']['nested']['$oid'], str), b.to_json_type()
         assert "ObjectId" not in b.to_json()
  
     def test_simple_to_json_with_no_id(self):
         class MyDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
-        mydoc['spam'] = range(10)
+        mydoc['spam'] = list(range(10))
         assert  "_id" not in mydoc.to_json_type()
-        assert mydoc.to_json() == '{"bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}'
+        assert json.loads(mydoc.to_json()) == json.loads('{"bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}')
  
     def test_to_json_custom_type(self):
         class CustomDegree(CustomType):
             mongo_type = int
-            python_type = basestring
+            python_type = str
             def to_bson(self, value):
                 if value is not None:
                     return int(value.replace('C', ''))
@@ -157,7 +160,7 @@ class MyDoc(Document):
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
+        mydoc['_id'] = 'mydoc'
         mydoc['doc']['foo'] = '3C'
         mydoc.save()
         self.assertEqual(
@@ -165,8 +168,8 @@ class MyDoc(Document):
             {"doc": {"foo": 3}, "_id": "mydoc"}
         )
         self.assertEqual(
-            mydoc.to_json(),
-            '{"doc": {"foo": "3C"}, "_id": "mydoc"}',
+            json.loads(mydoc.to_json()),
+            json.loads('{"doc": {"foo": "3C"}, "_id": "mydoc"}'),
         )
         self.assertEqual(mydoc.to_json_type(), {"doc": {"foo": "3C"}, "_id": "mydoc"})
  
@@ -174,7 +177,7 @@ def test_to_json_embeded_doc(self):
         class EmbedDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
@@ -188,23 +191,23 @@ class MyDoc(Document):
             use_autorefs = True
         self.connection.register([MyDoc, EmbedDoc])
         embed = self.col.EmbedDoc()
-        embed['_id'] = u'embed'
-        embed["bla"]["foo"] = u"bar"
+        embed['_id'] = 'embed'
+        embed["bla"]["foo"] = "bar"
         embed["bla"]["bar"] = 42
-        embed['spam'] = range(10)
+        embed['spam'] = list(range(10))
         embed.save()
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
+        mydoc['_id'] = 'mydoc'
         mydoc['doc']['embed'] = embed
         mydoc.save()
-        assert mydoc.to_json() == '{"doc": {"embed": {"_collection": "mongokit", "_database": "test", "_id": "embed", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "_id": "mydoc"}'
+        assert json.loads(mydoc.to_json()) == json.loads('{"doc": {"embed": {"_collection": "mongokit", "_database": "test", "_id": "embed", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "_id": "mydoc"}')
         assert mydoc.to_json_type() == {"doc": {"embed": {"_id": "embed", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "_id": "mydoc"}
  
     def test_to_json_embeded_doc_with_oid(self):
         class EmbedDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
@@ -218,22 +221,22 @@ class MyDoc(Document):
             use_autorefs = True
         self.connection.register([MyDoc, EmbedDoc])
         embed = self.col.EmbedDoc()
-        embed["bla"]["foo"] = u"bar"
+        embed["bla"]["foo"] = "bar"
         embed["bla"]["bar"] = 42
-        embed['spam'] = range(10)
+        embed['spam'] = list(range(10))
         embed.save()
         mydoc = self.col.MyDoc()
         mydoc['doc']['embed'] = embed
         mydoc.save()
-        assert isinstance(mydoc.to_json_type()['doc']['embed']['_id']['$oid'], basestring)
-        assert mydoc.to_json() == '{"doc": {"embed": {"_collection": "mongokit", "_database": "test", "_id": {"$oid": "%s"}, "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "_id": {"$oid": "%s"}}' % (
-          embed['_id'], mydoc['_id']), mydoc.to_json()
+        assert isinstance(mydoc.to_json_type()['doc']['embed']['_id']['$oid'], str)
+        assert json.loads(mydoc.to_json()) == json.loads('{"doc": {"embed": {"_collection": "mongokit", "_database": "test", "_id": {"$oid": "%s"}, "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "_id": {"$oid": "%s"}}' % (
+          embed['_id'], mydoc['_id']))
  
     def test_to_json_with_None_embeded_doc(self):
         class EmbedDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
@@ -247,37 +250,37 @@ class MyDoc(Document):
             use_autorefs = True
         self.connection.register([MyDoc, EmbedDoc])
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
+        mydoc['_id'] = 'mydoc'
         mydoc.save()
-        assert mydoc.to_json() == '{"doc": {"embed": null}, "_id": "mydoc"}'
+        assert json.loads(mydoc.to_json()) == json.loads('{"doc": {"embed": null}, "_id": "mydoc"}')
         assert mydoc.to_json_type() == {'doc': {'embed': None}, '_id': 'mydoc'}, mydoc.to_json_type()
  
     def test_to_json_with_dict_in_list(self):
         class MyDoc(Document):
             structure = {
-                "foo":[{'bar':unicode, 'egg':int}],
+                "foo":[{'bar':str, 'egg':int}],
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
-        mydoc["foo"] = [{'bar':u'bla', 'egg':3}, {'bar':u'bli', 'egg':4}]
+        mydoc['_id'] = 'mydoc'
+        mydoc["foo"] = [{'bar':'bla', 'egg':3}, {'bar':'bli', 'egg':4}]
         mydoc.save()
-        assert  mydoc.to_json() == '{"foo": [{"bar": "bla", "egg": 3}, {"bar": "bli", "egg": 4}], "_id": "mydoc"}', mydoc.to_json()
-        assert  mydoc.to_json_type() == {'foo': [{'bar': u'bla', 'egg': 3}, {'bar': u'bli', 'egg': 4}], '_id': 'mydoc'}
+        assert json.loads(mydoc.to_json()) == json.loads('{"foo": [{"bar": "bla", "egg": 3}, {"bar": "bli", "egg": 4}], "_id": "mydoc"}')
+        assert  mydoc.to_json_type() == {'foo': [{'bar': 'bla', 'egg': 3}, {'bar': 'bli', 'egg': 4}], '_id': 'mydoc'}
  
  
     def test_simple_from_json(self):
         class MyDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
             }
         self.connection.register([MyDoc])
-        json = '{"_id": "mydoc", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}'
-        mydoc = self.col.MyDoc.from_json(json)
+        jsonstr = '{"_id": "mydoc", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}'
+        mydoc = self.col.MyDoc.from_json(jsonstr)
         assert mydoc == {'_id': 'mydoc', 'bla': {'foo': 'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
         assert mydoc.collection == self.col
  
@@ -285,15 +288,15 @@ def test_simple_from_json2(self):
         class MyDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                     "egg":datetime.datetime,
                 },
                 "spam":[datetime.datetime],
             }
         self.connection.register([MyDoc])
-        json = '{"_id": "mydoc2", "bla": {"foo": "bar", "bar": 42, "egg":946684800000}, "spam": [946684800000, 1218153600000]}'
-        mydoc = self.col.MyDoc.from_json(json)
+        jsonstr = '{"_id": "mydoc2", "bla": {"foo": "bar", "bar": 42, "egg":946684800000}, "spam": [946684800000, 1218153600000]}'
+        mydoc = self.col.MyDoc.from_json(jsonstr)
         assert mydoc == {'_id': 'mydoc2', 'bla': {'foo': 'bar', 'bar': 42, "egg":datetime.datetime(2000, 1, 1, 0, 0)}, 'spam': [datetime.datetime(2000, 1, 1, 0, 0), datetime.datetime(2008, 8, 8, 0, 0)]}, mydoc
         assert mydoc.collection == self.col
  
@@ -301,7 +304,7 @@ def test_from_json_embeded_doc(self):
         class EmbedDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
@@ -316,25 +319,25 @@ class MyDoc(Document):
         self.connection.register([MyDoc, EmbedDoc])
  
         embed = self.col.EmbedDoc()
-        embed['_id'] = u"embed"
-        embed["bla"] = {"foo": u"bar", "bar": 42}
+        embed['_id'] = "embed"
+        embed["bla"] = {"foo": "bar", "bar": 42}
         embed["spam"] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
         embed.save()
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
+        mydoc['_id'] = 'mydoc'
         mydoc['doc']['embed'] = embed
         mydoc.save()
-        json = mydoc.to_json()
-        assert json == '{"doc": {"embed": {"_collection": "mongokit", "_database": "test", "_id": "embed", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "_id": "mydoc"}', json
-        mydoc = self.col.MyDoc.from_json(json)
-        assert mydoc == {'doc': {'embed': {u'_id': u'embed', u'bla': {u'foo': u'bar', u'bar': 42}, u'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, '_id': u'mydoc'}, mydoc
+        jsonstr = mydoc.to_json()
+        assert json.loads(jsonstr) == json.loads('{"doc": {"embed": {"_collection": "mongokit", "_database": "test", "_id": "embed", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "_id": "mydoc"}')
+        mydoc = self.col.MyDoc.from_json(jsonstr)
+        assert mydoc == {'doc': {'embed': {'_id': 'embed', 'bla': {'foo': 'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, '_id': 'mydoc'}, mydoc
         assert isinstance(mydoc['doc']['embed'], EmbedDoc)
  
     def test_from_json_embeded_doc_with_oid(self):
         class EmbedDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
@@ -349,17 +352,17 @@ class MyDoc(Document):
         self.connection.register([MyDoc, EmbedDoc])
  
         embed = self.col.EmbedDoc()
-        embed["bla"] = {"foo": u"bar", "bar": 42}
+        embed["bla"] = {"foo": "bar", "bar": 42}
         embed["spam"] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
         embed.save()
         mydoc = self.col.MyDoc()
         mydoc['doc']['embed'] = embed
         mydoc.save()
-        json = mydoc.to_json()
-        assert json == '{"doc": {"embed": {"_collection": "mongokit", "_database": "test", "_id": {"$oid": "%s"}, "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "_id": {"$oid": "%s"}}' %(
-          embed['_id'], mydoc['_id']), json
-        doc = self.col.MyDoc.from_json(json)
-        assert doc == {'doc': {'embed': {u'_id': embed['_id'], u'bla': {u'foo': u'bar', u'bar': 42}, u'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, '_id': mydoc['_id']}, doc
+        jsonstr = mydoc.to_json()
+        assert json.loads(jsonstr) == json.loads('{"doc": {"embed": {"_collection": "mongokit", "_database": "test", "_id": {"$oid": "%s"}, "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, "_id": {"$oid": "%s"}}' %(
+          embed['_id'], mydoc['_id']))
+        doc = self.col.MyDoc.from_json(jsonstr)
+        assert doc == {'doc': {'embed': {'_id': embed['_id'], 'bla': {'foo': 'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}}, '_id': mydoc['_id']}, doc
         assert isinstance(doc['doc']['embed'], EmbedDoc)
  
  
@@ -367,7 +370,7 @@ def test_from_json_with_None_embeded_doc(self):
         class EmbedDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
@@ -381,18 +384,18 @@ class MyDoc(Document):
             use_autorefs = True
         self.connection.register([MyDoc, EmbedDoc])
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
+        mydoc['_id'] = 'mydoc'
         mydoc.save()
-        json= mydoc.to_json()
-        assert json == '{"doc": {"embed": null}, "_id": "mydoc"}'
-        doc = self.col.MyDoc.from_json(json)
+        jsonstr= mydoc.to_json()
+        assert json.loads(jsonstr) == json.loads('{"doc": {"embed": null}, "_id": "mydoc"}')
+        doc = self.col.MyDoc.from_json(jsonstr)
         assert doc == {'doc': {'embed': None}, '_id': 'mydoc'}
  
     def test_from_json_embeded_doc_in_list(self):
         class EmbedDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
@@ -406,25 +409,25 @@ class MyDoc(Document):
             use_autorefs = True
         self.connection.register([MyDoc, EmbedDoc])
         embed = self.col.EmbedDoc()
-        embed['_id'] = u"embed"
-        embed["bla"] = {"foo": u"bar", "bar": 42}
+        embed['_id'] = "embed"
+        embed["bla"] = {"foo": "bar", "bar": 42}
         embed["spam"] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
         embed.save()
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
+        mydoc['_id'] = 'mydoc'
         mydoc['doc']['embed'] = [embed]
         mydoc.save()
-        json = mydoc.to_json()
-        assert json == '{"doc": {"embed": [{"_collection": "mongokit", "_database": "test", "_id": "embed", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}, "_id": "mydoc"}'
-        mydoc = self.col.MyDoc.from_json(json)
-        assert mydoc == {'doc': {'embed': [{u'_id': u'embed', u'bla': {u'foo': u'bar', u'bar': 42}, u'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}, '_id': u'mydoc'}, mydoc
+        jsonstr = mydoc.to_json()
+        assert json.loads(jsonstr) == json.loads('{"doc": {"embed": [{"_collection": "mongokit", "_database": "test", "_id": "embed", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}, "_id": "mydoc"}')
+        mydoc = self.col.MyDoc.from_json(jsonstr)
+        assert mydoc == {'doc': {'embed': [{'_id': 'embed', 'bla': {'foo': 'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}, '_id': 'mydoc'}, mydoc
         assert isinstance(mydoc['doc']['embed'][0], EmbedDoc)
  
     def test_from_json_embeded_doc_in_list_with_oid(self):
         class EmbedDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
@@ -438,24 +441,24 @@ class MyDoc(Document):
             use_autorefs = True
         self.connection.register([MyDoc, EmbedDoc])
         embed = self.col.EmbedDoc()
-        embed["bla"] = {"foo": u"bar", "bar": 42}
+        embed["bla"] = {"foo": "bar", "bar": 42}
         embed["spam"] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
         embed.save()
         mydoc = self.col.MyDoc()
         mydoc['doc']['embed'] = [embed]
         mydoc.save()
-        json = mydoc.to_json()
-        assert json == '{"doc": {"embed": [{"_collection": "mongokit", "_database": "test", "_id": {"$oid": "%s"}, "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}, "_id": {"$oid": "%s"}}' %(
-          embed['_id'], mydoc['_id']), json
-        doc = self.col.MyDoc.from_json(json)
-        assert doc == {'doc': {'embed': [{u'_id': embed['_id'], u'bla': {u'foo': u'bar', u'bar': 42}, u'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}, '_id': mydoc['_id']}, doc
+        jsonstr = mydoc.to_json()
+        assert json.loads(jsonstr) == json.loads('{"doc": {"embed": [{"_collection": "mongokit", "_database": "test", "_id": {"$oid": "%s"}, "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}, "_id": {"$oid": "%s"}}' %(
+          embed['_id'], mydoc['_id']))
+        doc = self.col.MyDoc.from_json(jsonstr)
+        assert doc == {'doc': {'embed': [{'_id': embed['_id'], 'bla': {'foo': 'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}, '_id': mydoc['_id']}, doc
         assert isinstance(doc['doc']['embed'][0], EmbedDoc)
  
     def test_from_json_with_no_embeded_doc_in_list(self):
         class EmbedDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
@@ -469,100 +472,82 @@ class MyDoc(Document):
             use_autorefs = True
         self.connection.register([MyDoc, EmbedDoc])
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
+        mydoc['_id'] = 'mydoc'
         mydoc.save()
-        json = mydoc.to_json()
-        assert json == '{"doc": {"embed": []}, "_id": "mydoc"}'
-        mydoc = self.col.MyDoc.from_json(json)
+        jsonstr = mydoc.to_json()
+        assert json.loads(jsonstr) == json.loads('{"doc": {"embed": []}, "_id": "mydoc"}')
+        mydoc = self.col.MyDoc.from_json(jsonstr)
         assert mydoc == {'doc': {'embed': []}, '_id': 'mydoc'}
  
     def test_from_json_dict_in_list(self):
         class MyDoc(Document):
             structure = {
                 "doc":{
-                    "embed":[{"foo":unicode, "bar":int}],
+                    "embed":[{"foo":str, "bar":int}],
                 },
             }
             use_autorefs = True
         self.connection.register([MyDoc])
-        json = '{"doc": {"embed": [{"foo": "bar", "bar": 42}]}, "_id": "mydoc"}'
-        mydoc = self.col.MyDoc.from_json(json)
+        jsonstr = '{"doc": {"embed": [{"foo": "bar", "bar": 42}]}, "_id": "mydoc"}'
+        mydoc = self.col.MyDoc.from_json(jsonstr)
         assert mydoc == {'doc': {'embed': [{'foo': 'bar', 'bar': 42}]}, '_id': 'mydoc'}, mydoc
  
     def test_from_json_unicode(self):
         class MyDoc(Document):
             structure = {
                 "doc":{
-                    "name":unicode
+                    "name":str
                 },
-                "foo": unicode,
+                "foo": str,
             }
             use_autorefs = True
         self.connection.register([MyDoc])
  
         mydoc = self.col.MyDoc()
-        mydoc['doc']['name'] = u'bla'
-        mydoc['foo'] = u'bar'
-        json = mydoc.to_json()
-        mydoc2 = self.col.MyDoc.from_json(json)
-        assert isinstance(mydoc['doc']['name'], unicode)
-        assert isinstance(mydoc['foo'], unicode)
-        assert isinstance(mydoc2['doc']['name'], unicode)
-        assert isinstance(mydoc2['foo'], unicode)
+        mydoc['doc']['name'] = 'bla'
+        mydoc['foo'] = 'bar'
+        jsonstr = mydoc.to_json()
+        mydoc2 = self.col.MyDoc.from_json(jsonstr)
+        assert isinstance(mydoc['doc']['name'], str)
+        assert isinstance(mydoc['foo'], str)
+        assert isinstance(mydoc2['doc']['name'], str)
+        assert isinstance(mydoc2['foo'], str)
  
     def test_simple_to_json_from_cursor(self):
         class MyDoc(Document):
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                 },
                 "spam":[],
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc['_id'] = 'mydoc'
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
-        mydoc['spam'] = range(10)
+        mydoc['spam'] = list(range(10))
         mydoc.save()
-        json = mydoc.to_json()
-        assert json == '{"_id": "mydoc", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}'
+        jsonstr = mydoc.to_json()
+        assert json.loads(jsonstr) == json.loads('{"_id": "mydoc", "bla": {"foo": "bar", "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}')
  
         mydoc2 = self.col.MyDoc()
-        mydoc2['_id'] = u'mydoc2'
-        mydoc2["bla"]["foo"] = u"bla"
+        mydoc2['_id'] = 'mydoc2'
+        mydoc2["bla"]["foo"] = "bla"
         mydoc2["bla"]["bar"] = 32
         mydoc2['spam'] = [datetime.datetime(2000, 1, 1), datetime.datetime(2008, 8, 8)]
         mydoc2.save()
         json2 = mydoc2.to_json()
  
-        assert [i.to_json() for i in self.col.MyDoc.fetch()] == [json, json2]
- 
-    def test_anyjson_import_error(self):
-        import sys
-        newpathlist = sys.path
-        sys.path = []
-        class MyDoc(Document):
-            structure = {
-                "foo":int,
-            }
-        self.connection.register([MyDoc])
-        mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
-        mydoc["foo"] = 4
-        mydoc.save()
-        self.assertRaises(ImportError, mydoc.to_json)
-        self.assertRaises(ImportError, self.col.MyDoc.from_json, '{"_id":"mydoc", "foo":4}')
-        sys.path = newpathlist
-        del newpathlist
+        assert [i.to_json() for i in self.col.MyDoc.fetch()] == [jsonstr, json2]
  
     def test_to_json_with_dot_notation(self):
         class MyDoc(Document):
             use_dot_notation = True
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                     "egg":datetime.datetime,
                 },
@@ -571,47 +556,47 @@ class MyDoc(Document):
         self.connection.register([MyDoc])
  
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
-        mydoc["bla"]["foo"] = u"bar"
+        mydoc['_id'] = 'mydoc'
+        mydoc["bla"]["foo"] = "bar"
         mydoc["bla"]["bar"] = 42
         mydoc['bla']['egg'] = datetime.datetime(2010, 1, 1)
-        mydoc['spam'] = range(10)
+        mydoc['spam'] = list(range(10))
         mydoc.save()
         import json
         self.assertEqual(json.loads(mydoc.to_json()),
           json.loads('{"_id": "mydoc", "bla": {"bar": 42, "foo": "bar", "egg": 1262304000000}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}'))
         self.assertEqual(mydoc.to_json_type(),
-          {'_id': 'mydoc', 'bla': {'egg': 1262304000000, 'foo': u'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
+          {'_id': 'mydoc', 'bla': {'egg': 1262304000000, 'foo': 'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
  
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
-        mydoc.bla.foo = u"bar"
+        mydoc['_id'] = 'mydoc'
+        mydoc.bla.foo = "bar"
         mydoc.bla.bar = 42
         mydoc.bla.egg = datetime.datetime(2010, 1, 1)
-        mydoc.spam = range(10)
+        mydoc.spam = list(range(10))
         mydoc.save()
         self.assertEqual(json.loads(mydoc.to_json()),
           json.loads('{"_id": "mydoc", "bla": {"bar": 42, "foo": "bar", "egg": 1262304000000}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}'))
         self.assertEqual(mydoc.to_json_type(),
-          {'_id': 'mydoc', 'bla': {'egg': 1262304000000, 'foo': u'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
+          {'_id': 'mydoc', 'bla': {'egg': 1262304000000, 'foo': 'bar', 'bar': 42}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
  
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc2'
-        mydoc.bla.foo = u"bar"
+        mydoc['_id'] = 'mydoc2'
+        mydoc.bla.foo = "bar"
         mydoc.bla.bar = 42
         mydoc.spam = [datetime.datetime(2000, 1, 1), datetime.datetime(2008, 8, 8)]
         mydoc.save()
         self.assertEqual(json.loads(mydoc.to_json()),
           json.loads('{"_id": "mydoc2", "bla": {"bar": 42, "foo": "bar", "egg": null}, "spam": [946684800000, 1218153600000]}'))
         self.assertEqual(mydoc.to_json_type(),
-          {'_id': 'mydoc2', 'bla': {'egg': None, 'foo': u'bar', 'bar': 42}, 'spam': [946684800000, 1218153600000]})
+          {'_id': 'mydoc2', 'bla': {'egg': None, 'foo': 'bar', 'bar': 42}, 'spam': [946684800000, 1218153600000]})
  
     def test_to_json_with_i18n_and_dot_notation(self):
         class MyDoc(Document):
             use_dot_notation = True
             structure = {
                 "bla":{
-                    "foo":unicode,
+                    "foo":str,
                     "bar":int,
                     "egg":datetime.datetime,
                 },
@@ -621,28 +606,28 @@ class MyDoc(Document):
         self.connection.register([MyDoc])
  
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
-        mydoc.bla.foo = u"bar"
+        mydoc['_id'] = 'mydoc'
+        mydoc.bla.foo = "bar"
         mydoc.bla.bar = 42
         mydoc.bla.egg = datetime.datetime(2010, 1, 1)
-        mydoc.spam = range(10)
+        mydoc.spam = list(range(10))
         mydoc.set_lang('fr')
-        mydoc.bla.foo = u"arf"
+        mydoc.bla.foo = "arf"
         mydoc.save()
         import json
         self.assertEqual(mydoc.to_json_type(),
-          {'_id': 'mydoc', 'bla': {'bar': 42, 'foo': {'fr': u'arf', 'en': u'bar'}, 'egg': 1262304000000}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
+          {'_id': 'mydoc', 'bla': {'bar': 42, 'foo': {'fr': 'arf', 'en': 'bar'}, 'egg': 1262304000000}, 'spam': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
         self.assertEqual(json.loads(mydoc.to_json()),
           json.loads('{"_id": "mydoc", "bla": {"egg": 1262304000000, "foo": {"fr": "arf", "en": "bar"}, "bar": 42}, "spam": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}'))
  
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc2'
-        mydoc.bla.foo = u"bar"
+        mydoc['_id'] = 'mydoc2'
+        mydoc.bla.foo = "bar"
         mydoc.bla.bar = 42
         mydoc.spam = [datetime.datetime(2000, 1, 1), datetime.datetime(2008, 8, 8)]
         mydoc.save()
         self.assertEqual(mydoc.to_json_type(),
-          {'_id': 'mydoc2', 'bla': {'bar': 42, 'foo': {'en': u'bar'}, 'egg': None}, 'spam': [946684800000, 1218153600000]})
+          {'_id': 'mydoc2', 'bla': {'bar': 42, 'foo': {'en': 'bar'}, 'egg': None}, 'spam': [946684800000, 1218153600000]})
         self.assertEqual(json.loads(mydoc.to_json()),
           json.loads('{"_id": "mydoc2", "bla": {"egg": null, "foo": {"en": "bar"}, "bar": 42}, "spam": [946684800000, 1218153600000]}'))
  
@@ -650,22 +635,22 @@ class MyDoc(Document):
     def test_from_json_with_list(self):
         class MyDoc(Document):
             structure = {
-                'foo': {'bar': [unicode]}
+                'foo': {'bar': [str]}
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'mydoc'
-        mydoc['foo']['bar'] = [u'a', u'b', u'c']
+        mydoc['_id'] = 'mydoc'
+        mydoc['foo']['bar'] = ['a', 'b', 'c']
         mydoc.save()
-        json = u'{"_id": "mydoc", "foo":{"bar":["a", "b", "c"]}}'
-        doc_from_json = self.col.MyDoc.from_json(json)
+        jsonstr = '{"_id": "mydoc", "foo":{"bar":["a", "b", "c"]}}'
+        doc_from_json = self.col.MyDoc.from_json(jsonstr)
         doc_from_json.save()
         assert doc_from_json == mydoc
  
     def test_from_json_with_ref(self):
         class A(Document):
             structure = {
-                'foo': unicode
+                'foo': str
             }
         class B(Document):
             structure = {
@@ -675,20 +660,20 @@ class B(Document):
             use_autorefs = True
         self.connection.register([A, B])
         a = self.col.A()
-        a['_id'] = u'a'
-        a['foo'] = u'a'
+        a['_id'] = 'a'
+        a['foo'] = 'a'
         a.save()
  
-        json = '{"_id": "b", "bar":1, "a":{"$id": "a", "$ref": "%s", "$db": "%s"}}' % (self.col.name, self.col.database.name)
-        print json
-        b = self.col.B.from_json(json)
+        jsonstr = '{"_id": "b", "bar":1, "a":{"$id": "a", "$ref": "%s", "$db": "%s"}}' % (self.col.name, self.col.database.name)
+        print(jsonstr)
+        b = self.col.B.from_json(jsonstr)
         b.save()
         assert isinstance(b['a'], A), type(b['a'])
  
     def test_from_json_with_ref_in_list(self):
         class A(Document):
             structure = {
-                'foo': unicode
+                'foo': str
             }
         class B(Document):
             structure = {
@@ -698,27 +683,27 @@ class B(Document):
             use_autorefs = True
         self.connection.register([A, B])
         a = self.col.A()
-        a['_id'] = u'a'
-        a['foo'] = u'a'
+        a['_id'] = 'a'
+        a['foo'] = 'a'
         a.save()
  
-        json = '{"_id": "b", "bar":1, "a":[{"$id": "a", "$ref": "%s", "$db": "%s"}]}' % (self.col.name, self.col.database.name)
-        b = self.col.B.from_json(json)
+        jsonstr = '{"_id": "b", "bar":1, "a":[{"$id": "a", "$ref": "%s", "$db": "%s"}]}' % (self.col.name, self.col.database.name)
+        b = self.col.B.from_json(jsonstr)
         b.save()
         assert isinstance(b['a'][0], A), type(b['a'][0])
  
     def test_from_json_with_type_as_key(self):
         class MyDoc(Document):
             structure = {
-                'foo': {unicode:[unicode]}
+                'foo': {str:[str]}
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc['_id'] = u'a'
-        mydoc['foo'][u'bar'] = [u'bla', u'ble']
+        mydoc['_id'] = 'a'
+        mydoc['foo']['bar'] = ['bla', 'ble']
  
-        json = '{"_id": "a", "foo": {"bar":["bla", "ble"]}}'
-        mydoc_from_json = self.col.MyDoc.from_json(json)
+        jsonstr = '{"_id": "a", "foo": {"bar":["bla", "ble"]}}'
+        mydoc_from_json = self.col.MyDoc.from_json(jsonstr)
         assert mydoc == mydoc_from_json, (mydoc, mydoc_from_json)
  
  
@@ -730,8 +715,8 @@ class MyDoc(Document):
             }
         self.connection.register([MyDoc])
  
-        json = '{"_id": "a", "date": null, "date_in_list":[]}'
-        mydoc_from_json = self.col.MyDoc.from_json(json)
+        jsonstr = '{"_id": "a", "date": null, "date_in_list":[]}'
+        mydoc_from_json = self.col.MyDoc.from_json(jsonstr)
         assert mydoc_from_json['_id'] == 'a'
         assert mydoc_from_json['date'] is None
         assert mydoc_from_json['date_in_list'] == []
diff --git a/tests/test_mapreduce.py b/tests/test_mapreduce.py
index ed21f5c..15d3e6f 100644
--- a/tests/test_mapreduce.py
+++ b/tests/test_mapreduce.py
@@ -60,5 +60,5 @@ class MapDoc(Document):
         r = 'function(k,vals) { return 1; }'
         mapcol = self.col.map_reduce(m,r,"testresults")
         mapdoc = mapcol.MapDoc.find_one()
-        assert mapdoc == {u'_id': 0.0, u'value': 1.0}, mapdoc
+        assert mapdoc == {'_id': 0.0, 'value': 1.0}, mapdoc
         assert isinstance(mapdoc, MapDoc)
diff --git a/tests/test_migration.py b/tests/test_migration.py
index 294291c..78bee0c 100644
--- a/tests/test_migration.py
+++ b/tests/test_migration.py
@@ -31,6 +31,8 @@
 from bson.objectid import ObjectId
 from datetime import datetime
 
+import six
+
 
 class MigrationTestCase(unittest.TestCase):
     def setUp(self):
@@ -40,11 +42,11 @@ def setUp(self):
         # create initial blog post class
         class BlogPost(Document):
             structure = {
-                'author':unicode,
+                'author':str,
                 "blog_post":{
-                    "title": unicode,
+                    "title": str,
                     "created_at": datetime,
-                    "body": unicode,
+                    "body": str,
                 }
             }
             default_values = {'blog_post.created_at':datetime(2010, 1, 1)}
@@ -53,8 +55,8 @@ class BlogPost(Document):
         # creating some blog posts
         for i in range(10):
             blog_post = self.col.BlogPost()
-            blog_post['blog_post']['title'] = u'hello %s' % i
-            blog_post['blog_post']['body'] = u'I the post number %s' % i
+            blog_post['blog_post']['title'] = 'hello %s' % i
+            blog_post['blog_post']['body'] = 'I the post number %s' % i
             blog_post.save()
        
     def tearDown(self):
@@ -64,12 +66,12 @@ def tearDown(self):
     def test_simple_doc_migration(self):
         class BlogPost(Document):
             structure = {
-                "author":unicode,
+                "author":str,
                 "blog_post":{
-                    "title": unicode,
+                    "title": str,
                     "created_at": datetime,
-                    "body": unicode,
-                    "tags":  [unicode],
+                    "body": str,
+                    "tags":  [str],
                 }
             }
         self.connection.register([BlogPost])
@@ -91,12 +93,12 @@ def migration01_add_tags(self):
     def test_simple_all_migration(self):
         class BlogPost(Document):
             structure = {
-                "author":unicode,
+                "author":str,
                 "blog_post":{
-                    "title": unicode,
+                    "title": str,
                     "created_at": datetime,
-                    "body": unicode,
-                    "tags":  [unicode],
+                    "body": str,
+                    "tags":  [str],
                 }
             }
         self.connection.register([BlogPost])
@@ -118,12 +120,12 @@ def allmigration01_add_tags(self):
     def test_simple_all_migration_with_unset(self):
         class BlogPost(Document):
             structure = {
-                "author":unicode,
+                "author":str,
                 "blog_post":{
-                    "title": unicode,
+                    "title": str,
                     "created_at": datetime,
-                    "body": unicode,
-                    "tags":  [unicode],
+                    "body": str,
+                    "tags":  [str],
                 }
             }
         self.connection.register([BlogPost])
@@ -138,11 +140,11 @@ def allmigration01_remove_tags(self):
         # redfine class to drop the tags field
         class BlogPost(Document):
             structure = {
-                "author":unicode,
+                "author":str,
                 "blog_post":{
-                    "title": unicode,
+                    "title": str,
                     "created_at": datetime,
-                    "body": unicode,
+                    "body": str,
                 }
             }
         self.connection.register([BlogPost])
@@ -154,12 +156,12 @@ class BlogPost(Document):
     def test_simple_all_migration_with_bad_update(self):
         class BlogPost(Document):
             structure = {
-                "author": unicode,
+                "author": str,
                 "blog_post":{
-                    "title": unicode,
+                    "title": str,
                     "created_at": datetime,
-                    "body": unicode,
-                    "tags":  [unicode],
+                    "body": str,
+                    "tags":  [str],
                 }
             }
         self.connection.register([BlogPost])
@@ -189,12 +191,12 @@ def migration02__rename_create_at_to_creation_date(self):
         # update blog post class
         class BlogPost(Document):
             structure = {
-                "author":unicode,
+                "author":str,
                 "blog_post":{
-                    "title": unicode,
+                    "title": str,
                     "creation_date": datetime,
-                    "body": unicode,
-                    "tags": [unicode],
+                    "body": str,
+                    "tags": [str],
                 }
             }
             migration_handler = BlogPostMigration
@@ -208,7 +210,7 @@ class BlogPost(Document):
         assert bp['blog_post']['creation_date'] == datetime(2010, 1, 1)
 
         # via lazzy migration, the following line don't raise errors
-        bp['blog_post']['title'] = u'Hello big World'
+        bp['blog_post']['title'] = 'Hello big World'
         bp.save()
         assert bp['blog_post']['title'] == 'Hello big World', bp['blog_post']
 
@@ -228,12 +230,12 @@ def migration02__rename_create_at_to_creation_date(self):
         class BlogPost(Document):
             skip_validation = True
             structure = {
-                "author":unicode,
+                "author":str,
                 "blog_post":{
-                    "title": unicode,
+                    "title": str,
                     "creation_date": datetime,
-                    "body": unicode,
-                    "tags": [unicode],
+                    "body": str,
+                    "tags": [str],
                 }
             }
             migration_handler = BlogPostMigration
@@ -265,12 +267,12 @@ def migration02__rename_create_at_to_creation_date(self):
         # update blog post class
         class BlogPost(Document):
             structure = {
-                "author":unicode,
+                "author":str,
                 "blog_post":{
-                    "title": unicode,
+                    "title": str,
                     "creation_date": datetime,
-                    "body": unicode,
-                    "tags": [unicode],
+                    "body": str,
+                    "tags": [str],
                 }
             }
             migration_handler = BlogPostMigration
@@ -322,7 +324,7 @@ def migration02__rename_create_at_to_creation_date(self):
                     }
             def migration03__change_title_structure(self):
                 self.target = {'blog_post.title':{'$exists':True, '$type':2}}
-                self.update = {'$set':{'blog_post.title':{'lang':u'fr', 'value':self.doc['blog_post']['title']}}}
+                self.update = {'$set':{'blog_post.title':{'lang':'fr', 'value':self.doc['blog_post']['title']}}}
                 #self.update = {'$set':{'blog_post.title':1}}
 
             def migration04__change_tags_structure(self):
@@ -332,12 +334,12 @@ def migration04__change_tags_structure(self):
         # update blog post class
         class BlogPost(Document):
             structure = {
-                "author":unicode,
+                "author":str,
                 "blog_post":{
-                    "title": {'lang':unicode, 'value':unicode},
+                    "title": {'lang':str, 'value':str},
                     "creation_date": datetime,
-                    "body": unicode,
-                    "tags": [{'foo':unicode}],
+                    "body": str,
+                    "tags": [{'foo':str}],
                 }
             }
             migration_handler = BlogPostMigration
@@ -349,11 +351,11 @@ def validate(self, auto_migrate=False):
         self.connection.register([BlogPost])
 
         doc = self.col.BlogPost.find_one({'blog_post.title':'hello 0'})
-        self.assertEqual(doc, {u'blog_post': {u'body': u'I the post number 0',
-          u'title': {u'lang': u'fr', u'value': u'hello 0'},
-          u'tags': [{u'foo': {u'lang': u'fr', u'value': u'hello 0'}}],
-          u'creation_date': datetime(2010, 1, 1, 0, 0)}, u'author': None,
-          u'_id': doc['_id']})
+        self.assertEqual(doc, {'blog_post': {'body': 'I the post number 0',
+          'title': {'lang': 'fr', 'value': 'hello 0'},
+          'tags': [{'foo': {'lang': 'fr', 'value': 'hello 0'}}],
+          'creation_date': datetime(2010, 1, 1, 0, 0)}, 'author': None,
+          '_id': doc['_id']})
 
     def test_migration_with_schemaless(self):
         # creating blog post migration
@@ -367,17 +369,17 @@ def migration01__add_tags(self):
         try:
             class BlogPost(Document):
                 structure = {
-                    "author":unicode,
+                    "author":str,
                     "blog_post":{
-                        "title": unicode,
+                        "title": str,
                         "creation_date": datetime,
-                        "body": unicode,
-                        "tags": [unicode],
+                        "body": str,
+                        "tags": [str],
                     }
                 }
                 use_schemaless = True
                 migration_handler = BlogPostMigration
-        except OptionConflictError, e:
+        except OptionConflictError as e:
             self.assertEqual('You cannot set a migration_handler with use_schemaless set to True', str(e))
             failed = True
         self.assertEqual(failed, True)
diff --git a/tests/test_schemaless.py b/tests/test_schemaless.py
index 10f1f40..9b270ed 100644
--- a/tests/test_schemaless.py
+++ b/tests/test_schemaless.py
@@ -30,6 +30,8 @@
 from mongokit import *
 import datetime
 
+import six
+
 
 class SchemaLessTestCase(unittest.TestCase):
 
@@ -46,7 +48,7 @@ def test_simple_schemaless(self):
         class MyDoc(Document):
             use_schemaless = True
             structure = {
-                'foo': unicode,
+                'foo': str,
                 'bar': int,
             }
 
@@ -54,7 +56,7 @@ class MyDoc(Document):
         self.assertEqual('foo' in doc, True)
         self.assertEqual('bar' in doc, True)
         self.assertEqual('egg' in doc, False)
-        doc['foo'] = u'bla'
+        doc['foo'] = 'bla'
         doc['bar'] = 3
         doc['egg'] = 9
         doc.save()
@@ -74,9 +76,9 @@ class MyDoc(Document):
         doc.pop('bar')
         doc.save()
         doc = self.col.MyDoc.find_one()
-        self.assertEqual(doc.keys(), ['_id', 'egg'])
+        self.assertEqual(set(doc.keys()), set(['_id', 'egg']))
 
-        doc = self.col.MyDoc({'_id':1, 'foo':u'bla'})
+        doc = self.col.MyDoc({'_id':1, 'foo':'bla'})
         doc.save()
         
 
@@ -85,7 +87,7 @@ def test_schemaless_with_required(self):
         class MyDoc(Document):
             use_schemaless = True
             structure = {
-                'foo': unicode,
+                'foo': str,
                 'bar': int,
             }
             required_fields = ['foo']
@@ -94,7 +96,7 @@ class MyDoc(Document):
         self.assertEqual('foo' in doc, True)
         self.assertEqual('bar' in doc, True)
         self.assertEqual('egg' in doc, False)
-        doc['foo'] = u'bla'
+        doc['foo'] = 'bla'
         doc['bar'] = 3
         doc['egg'] = 9
         doc.save()
@@ -115,7 +117,7 @@ class MyDoc(Document):
         self.assertEqual('egg' in doc, True)
         doc['bar'] = 2
         self.assertRaises(RequireFieldError, doc.save)
-        doc['foo'] = u'arf'
+        doc['foo'] = 'arf'
         doc.save()
 
     def test_schemaless_no_structure(self):
@@ -126,8 +128,8 @@ class MyDoc(Document):
         doc = self.col.MyDoc()
         self.assertEqual('foo' in doc, False)
         self.assertEqual('bar' in doc, False)
-        doc['_id'] = u'foo'
-        doc['foo'] = u'bla'
+        doc['_id'] = 'foo'
+        doc['foo'] = 'bla'
         doc['bar'] = 3
         doc.save()
         
@@ -147,16 +149,16 @@ class User(Document):
             __database__ = 'test'
             use_schemaless = True
             structure = {
-                'name': unicode,
-                'password': unicode,
-                'last_name': unicode,
-                'first_name': unicode,
-                'email': unicode,
+                'name': str,
+                'password': str,
+                'last_name': str,
+                'first_name': str,
+                'email': str,
                 'last_login': datetime.datetime,
             }
             use_dot_notation = True
 
-        self.connection.User.collection.save({'name': u'namlook', 'password': u'test', 'email': u'n@c.com'})
+        self.connection.User.collection.save({'name': 'namlook', 'password': 'test', 'email': 'n@c.com'})
 
         found_attribute = self.connection.User.find_one({'name':'namlook'})
         found_attribute.last_login = datetime.datetime.utcnow()
diff --git a/tests/test_structure.py b/tests/test_structure.py
index 42add72..1ae6ced 100644
--- a/tests/test_structure.py
+++ b/tests/test_structure.py
@@ -25,10 +25,14 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from __future__ import print_function
+
 import unittest
 
 from mongokit import *
 
+import six
+
 class StructureTestCase(unittest.TestCase):
     def setUp(self):
         self.connection = Connection()
@@ -60,9 +64,9 @@ class MyDoc(SchemaDocument):
         self.assertEqual(failed, True)
 
     def test_load_with_dict(self):
-        doc = {"foo":1, "bla":{"bar":u"spam"}}
+        doc = {"foo":1, "bla":{"bar":"spam"}}
         class MyDoc(SchemaDocument):
-            structure = {"foo":int, "bla":{"bar":unicode}}
+            structure = {"foo":int, "bla":{"bar":str}}
         mydoc = MyDoc(doc)
         assert mydoc == doc
         mydoc.validate()
@@ -70,16 +74,16 @@ class MyDoc(SchemaDocument):
     def test_simple_structure(self):
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":unicode,
+                "foo":str,
                 "bar":int
             }
         assert MyDoc() == {"foo":None, "bar":None}
 
     def test_missed_field(self):
-        doc = {"foo":u"arf"}
+        doc = {"foo":"arf"}
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":unicode,
+                "foo":str,
                 "bar":{"bla":int}
             }
         mydoc = MyDoc(doc)
@@ -88,7 +92,7 @@ class MyDoc(SchemaDocument):
     def test_unknown_field(self):
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":unicode,
+                "foo":str,
             }
         mydoc = MyDoc()
         mydoc["bar"] = 4
@@ -103,12 +107,12 @@ class MyDoc(SchemaDocument):
                 }
             }
         mydoc = MyDoc()
-        mydoc['foo'] = u'bla'
+        mydoc['foo'] = 'bla'
         mydoc.validate()
         mydoc['foo'] = 3
         mydoc['bar']['bla'] = 2
         mydoc.validate()
-        mydoc['foo'] = 'arf'
+        mydoc['foo'] = ('arf',)
         self.assertRaises(AuthorizedTypeError, mydoc.validate)
 
     def test_big_nested_structure(self):
@@ -122,7 +126,7 @@ class MyDoc(SchemaDocument):
                                     "6":{
                                         "7":int,
                                         "8":{
-                                            unicode:{int:int}
+                                            str:{int:int}
                                         }
                                     }
                                 }
@@ -132,13 +136,17 @@ class MyDoc(SchemaDocument):
                 }
             }
         mydoc = MyDoc()
-        assert mydoc._namespaces == ['1', '1.2', '1.2.3', '1.2.3.4', '1.2.3.4.5', '1.2.3.4.5.6', '1.2.3.4.5.6.8', '1.2.3.4.5.6.8.$unicode', '1.2.3.4.5.6.8.$unicode.$int', '1.2.3.4.5.6.7']
+        if six.PY2:
+            expect = ['1', '1.2', '1.2.3', '1.2.3.4', '1.2.3.4.5', '1.2.3.4.5.6', '1.2.3.4.5.6.8', '1.2.3.4.5.6.8.$unicode', '1.2.3.4.5.6.8.$unicode.$int', '1.2.3.4.5.6.7']
+        else:
+            expect = ['1', '1.2', '1.2.3', '1.2.3.4', '1.2.3.4.5', '1.2.3.4.5.6', '1.2.3.4.5.6.8', '1.2.3.4.5.6.8.$str', '1.2.3.4.5.6.8.$str.$int', '1.2.3.4.5.6.7']
+        self.assertEqual(set(mydoc._namespaces), set(expect))
         mydoc['1']['2']['3']['4']['5']['6']['7'] = 8
-        mydoc['1']['2']['3']['4']['5']['6']['8'] = {u"bla":{3:u"bla"}}
+        mydoc['1']['2']['3']['4']['5']['6']['8'] = {"bla":{3:"bla"}}
         self.assertRaises(SchemaTypeError,  mydoc.validate)
         mydoc['1']['2']['3']['4']['5']['6']['8'] = {9:{3:10}}
         self.assertRaises(SchemaTypeError,  mydoc.validate)
-        mydoc['1']['2']['3']['4']['5']['6']['8'] = {u"bla":{3:4}}
+        mydoc['1']['2']['3']['4']['5']['6']['8'] = {"bla":{3:4}}
         mydoc.validate()
  
     def test_big_nested_structure_mongo_document(self):
@@ -152,7 +160,7 @@ class MyDoc(Document):
                                     "6":{
                                         "7":int,
                                         "8":{
-                                            unicode:{unicode:int}
+                                            str:{str:int}
                                         }
                                     }
                                 }
@@ -163,13 +171,20 @@ class MyDoc(Document):
             }
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        assert mydoc._namespaces == ['1', '1.2', '1.2.3', '1.2.3.4', '1.2.3.4.5', '1.2.3.4.5.6', '1.2.3.4.5.6.8', '1.2.3.4.5.6.8.$unicode', '1.2.3.4.5.6.8.$unicode.$unicode', '1.2.3.4.5.6.7']
+        if six.PY2:
+            expect = ['1', '1.2', '1.2.3', '1.2.3.4', '1.2.3.4.5', '1.2.3.4.5.6', '1.2.3.4.5.6.8', '1.2.3.4.5.6.8.$unicode', '1.2.3.4.5.6.8.$unicode.$unicode', '1.2.3.4.5.6.7']
+        else:
+            expect = ['1', '1.2', '1.2.3', '1.2.3.4', '1.2.3.4.5', '1.2.3.4.5.6', '1.2.3.4.5.6.8', '1.2.3.4.5.6.8.$str', '1.2.3.4.5.6.8.$str.$str', '1.2.3.4.5.6.7']
+        self.assertEqual(set(mydoc._namespaces), set(expect))
         mydoc['1']['2']['3']['4']['5']['6']['7'] = 8
-        mydoc['1']['2']['3']['4']['5']['6']['8'] = {u"bla":{"3":u"bla"}}
-        self.assertRaises(SchemaTypeError,  mydoc.validate)
-        mydoc['1']['2']['3']['4']['5']['6']['8'] = {"9":{"3":10}}
+        mydoc['1']['2']['3']['4']['5']['6']['8'] = {"bla":{"3":"bla"}}
         self.assertRaises(SchemaTypeError,  mydoc.validate)
-        mydoc['1']['2']['3']['4']['5']['6']['8'] = {u"bla":{u"3":4}}
+        # This test does not apply in Py3, since keys must be strings and 
+        # there is no distinction between 'str' and 'unicode'
+        if six.PY2:
+            mydoc['1']['2']['3']['4']['5']['6']['8'] = {"9":{"3":10}}
+            self.assertRaises(SchemaTypeError, mydoc.validate)
+        mydoc['1']['2']['3']['4']['5']['6']['8'] = {"bla":{"3":4}}
         mydoc.validate()
             
     def test_dot_notation(self):
@@ -177,7 +192,7 @@ class MyDoc(SchemaDocument):
             use_dot_notation = True
             structure = {
                 "foo":int,
-                "bar":unicode
+                "bar":str
             }
 
         mydoc = MyDoc()
@@ -187,7 +202,7 @@ class MyDoc(SchemaDocument):
         assert mydoc['foo'] == 3
         assert mydoc == {'foo':3, 'bar':None}
         mydoc.validate()
-        mydoc.bar = u"bar"
+        mydoc.bar = "bar"
         assert mydoc == {'foo':3, 'bar':'bar'}
         mydoc.validate()
         
@@ -196,15 +211,15 @@ class MyDoc(SchemaDocument):
             use_dot_notation = True
             structure = {
                 "foo":{
-                    "bar":unicode
+                    "bar":str
                 }
             }
 
         mydoc = MyDoc()
         mydoc.foo.bar = 3
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc.foo.bar = u"bar"
-        assert mydoc.foo.bar == u'bar'
+        mydoc.foo.bar = "bar"
+        assert mydoc.foo.bar == 'bar'
         mydoc.foo.bla = 2
         assert mydoc.foo.bla == 2
         assert mydoc['foo'] == {"bar":"bar"}, mydoc
@@ -217,14 +232,14 @@ class MyDoc(Document):
             use_dot_notation = True
             structure = {
                 "foo":{
-                    "bar":unicode
+                    "bar":str
                 }
             }
         self.connection.register([MyDoc])
 
         mydoc = self.col.MyDoc()
-        mydoc.foo.bar = u"bar"
-        self.assertEqual(mydoc.foo.bar, u'bar')
+        mydoc.foo.bar = "bar"
+        self.assertEqual(mydoc.foo.bar, 'bar')
         mydoc.foo.bla = 2
         assert isinstance(mydoc.foo, DotedDict), type(mydoc.foo)
         self.assertEqual(mydoc.foo.bla,  2)
@@ -243,7 +258,7 @@ class MyDoc(SchemaDocument):
             use_dot_notation = True
             structure = {
                 "foo":{
-                    "bar":unicode,
+                    "bar":str,
                 },
                 "spam":int,
             }
@@ -256,8 +271,8 @@ class MyDoc(SchemaDocument):
         assert mydoc.eggs == 4
         try:
             mydoc.not_found
-        except AttributeError, e:
-            print str(e)
+        except AttributeError as e:
+            print(str(e))
         mydoc.foo.eggs = 4
         assert mydoc == {'foo':{'bar':None}, 'spam':None}, mydoc
         mydoc.validate()
@@ -267,7 +282,7 @@ def test_field_changed(self):
         class MyDoc(Document):
             structure = {
                 'foo':int,
-                'bar':unicode,
+                'bar':str,
             }
         self.connection.register([MyDoc])
         
@@ -278,7 +293,7 @@ class MyDoc(Document):
         class MyDoc(Document):
             structure = {
                 'foo':int,
-                'arf': unicode,
+                'arf': str,
             }
         self.connection.register([MyDoc])
         
@@ -297,10 +312,10 @@ def test_exception_bad_structure(self):
         try:
             class MyDoc(SchemaDocument):
                 structure = {
-                    'topic': unicode,
+                    'topic': str,
                     'when': datetime.datetime.utcnow,
                 }
-        except TypeError, e:
+        except TypeError as e:
             assert str(e).startswith("MyDoc: <built-in method utcnow of type object at "), str(e)
             assert str(e).endswith("is not a type")
             failed = True
diff --git a/tests/test_types.py b/tests/test_types.py
index 4d6f04a..9a2d9a4 100644
--- a/tests/test_types.py
+++ b/tests/test_types.py
@@ -25,11 +25,15 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from __future__ import print_function
+
 import unittest
 
 from mongokit.schema_document import *
 from mongokit import Document, Connection
 
+import six
+
 class TypesTestCase(unittest.TestCase):
 
     def setUp(self):
@@ -59,7 +63,7 @@ def test_not_authorized_type(self):
             try:
                 class MyDoc(SchemaDocument):
                     structure = { "foo":[unauth_type] }
-            except StructureError, e:
+            except StructureError as e:
                 self.assertEqual(str(e), "MyDoc: %s is not an authorized type" % unauth_type)
                 failed = True
             self.assertEqual(failed, True)
@@ -67,7 +71,7 @@ class MyDoc(SchemaDocument):
             try:
                 class MyDoc(SchemaDocument):
                     structure = { "foo":(unauth_type) }
-            except StructureError, e:
+            except StructureError as e:
                 self.assertEqual(str(e), "MyDoc: %s is not an authorized type" % unauth_type)
                 failed = True
             self.assertEqual(failed, True)
@@ -75,7 +79,7 @@ class MyDoc(SchemaDocument):
             try:
                 class MyDoc2(SchemaDocument):
                     structure = { 'foo':[{int:unauth_type }]}
-            except StructureError, e:
+            except StructureError as e:
                 self.assertEqual(str(e), "MyDoc2: %s is not an authorized type" % unauth_type)
                 failed = True
             self.assertEqual(failed, True)
@@ -83,7 +87,7 @@ class MyDoc2(SchemaDocument):
             try:
                 class MyDoc3(SchemaDocument):
                     structure = { 'foo':[{unauth_type:int }]}
-            except AuthorizedTypeError, e:
+            except AuthorizedTypeError as e:
                 self.assertEqual(str(e), "MyDoc3: %s is not an authorized type" % unauth_type)
                 failed = True
             self.assertEqual(failed, True)
@@ -91,9 +95,9 @@ class MyDoc3(SchemaDocument):
         failed = False
         try:
             class MyDoc4(SchemaDocument):
-                structure = {1:unicode}
-        except StructureError, e:
-            self.assertEqual(str(e), "MyDoc4: 1 must be a basestring or a type")
+                structure = {1:str}
+        except StructureError as e:
+            self.assertEqual(str(e), "MyDoc4: 1 must be a string or a type")
             failed = True
         self.assertEqual(failed, True)
 
@@ -117,11 +121,11 @@ class MyDoc(SchemaDocument):
         mydoc = MyDoc()
         mydoc.validate()
         assert mydoc['foo'] == []
-        mydoc['foo'] = [u"bla", 23]
+        mydoc['foo'] = ["bla", 23]
         mydoc.validate()
         mydoc['foo'] = [set([1,2]), "bla"]
         self.assertRaises(AuthorizedTypeError, mydoc.validate)
-        mydoc['foo'] = u"bla"
+        mydoc['foo'] = "bla"
         self.assertRaises(SchemaTypeError, mydoc.validate)
 
 #        class MyDoc(SchemaDocument):
@@ -146,48 +150,48 @@ class MyDoc(SchemaDocument):
         assert mydoc['foo'] == []
         mydoc['foo'] = [1,2,3]
         mydoc.validate()
-        mydoc['foo'] = [u"bla"]
+        mydoc['foo'] = ["bla"]
         self.assertRaises(SchemaTypeError, mydoc.validate)
 
     def test_typed_list_with_dict(self):
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":[{unicode:int}]
+                "foo":[{str:int}]
             }
         mydoc = MyDoc()
-        mydoc['foo'] = [{u"bla":1},{u"ble":2}]
+        mydoc['foo'] = [{"bla":1},{"ble":2}]
         mydoc.validate()
-        mydoc['foo'] = [{u"bla":u"bar"}]
+        mydoc['foo'] = [{"bla":"bar"}]
         self.assertRaises(SchemaTypeError, mydoc.validate)
 
     def test_typed_list_with_list(self):
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":[[unicode]]
+                "foo":[[str]]
             }
         mydoc = MyDoc()
-        mydoc['foo'] = [[u"bla",u"blu"],[u"ble",u"bli"]]
+        mydoc['foo'] = [["bla","blu"],["ble","bli"]]
         mydoc.validate()
-        mydoc['foo'] = [[u"bla",1]]
+        mydoc['foo'] = [["bla",1]]
         self.assertRaises(SchemaTypeError, mydoc.validate)
 
     def test_typed_tuple(self):
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":(int, unicode, float)
+                "foo":(int, str, float)
             }
         mydoc = MyDoc()
         mydoc.validate()
         assert mydoc['foo'] == [None, None, None]
-        mydoc['foo'] = [u"bla", 1, 4.0]
+        mydoc['foo'] = ["bla", 1, 4.0]
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['foo'] = [1, u"bla"]
+        mydoc['foo'] = [1, "bla"]
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['foo'] = u"bla"
+        mydoc['foo'] = "bla"
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['foo'] = [1,u'bar',3.2]
+        mydoc['foo'] = [1,'bar',3.2]
         mydoc.validate()
-        mydoc['foo'] = [None, u"bla", 3.1]
+        mydoc['foo'] = [None, "bla", 3.1]
         mydoc.validate()
         mydoc['foo'][0] = 50
         mydoc.validate()
@@ -195,40 +199,40 @@ class MyDoc(SchemaDocument):
     def test_nested_typed_tuple(self):
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":{'bar':(int, unicode, float)}
+                "foo":{'bar':(int, str, float)}
             }
         mydoc = MyDoc()
         mydoc.validate()
         assert mydoc['foo']['bar'] == [None, None, None]
-        mydoc['foo']['bar'] = [u"bla", 1, 4.0]
+        mydoc['foo']['bar'] = ["bla", 1, 4.0]
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['foo']['bar'] = [1, u"bla"]
+        mydoc['foo']['bar'] = [1, "bla"]
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['foo']['bar'] = [1,u'bar',3.2]
+        mydoc['foo']['bar'] = [1,'bar',3.2]
         mydoc.validate()
-        mydoc['foo']['bar'] = [None, u"bla", 3.1]
+        mydoc['foo']['bar'] = [None, "bla", 3.1]
         mydoc.validate()
         mydoc['foo']['bar'][0] = 50
         mydoc.validate()
 
     def test_saving_tuple(self):
         class MyDoc(Document):
-            structure = { 'foo': (int, unicode, float) }
+            structure = { 'foo': (int, str, float) }
         self.connection.register([MyDoc])
 
         mydoc = self.col.MyDoc()
         assert mydoc == {'foo': [None, None, None]}, mydoc
-        mydoc['foo'] = (1, u'a', 1.1) # note that this will be converted to list
-        assert mydoc == {'foo': (1, u'a', 1.1000000000000001)}, mydoc
+        mydoc['foo'] = (1, 'a', 1.1) # note that this will be converted to list
+        assert mydoc == {'foo': (1, 'a', 1.1000000000000001)}, mydoc
         mydoc.save()
         mydoc = self.col.find_one()
 
         class MyDoc(Document):
-            structure = {'foo':[unicode]}
+            structure = {'foo':[str]}
         self.connection.register([])
         self.connection.register([MyDoc])
         mydoc = self.col.MyDoc()
-        mydoc['foo'] = (u'bla', u'bli', u'blu', u'bly')
+        mydoc['foo'] = ('bla', 'bli', 'blu', 'bly')
         mydoc.save()
         mydoc = self.col.get_from_id(mydoc['_id'])
 
@@ -236,20 +240,20 @@ class MyDoc(Document):
     def test_nested_typed_tuple_in_list(self):
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":{'bar':[(int, unicode, float)]}
+                "foo":{'bar':[(int, str, float)]}
             }
         mydoc = MyDoc()
         mydoc.validate()
         assert mydoc == {'foo': {'bar': []}}
-        mydoc['foo']['bar'].append([u"bla", 1, 4.0])
+        mydoc['foo']['bar'].append(["bla", 1, 4.0])
         self.assertRaises(SchemaTypeError, mydoc.validate)
         mydoc['foo']['bar'] = []
-        mydoc['foo']['bar'].append([1, u"bla"])
+        mydoc['foo']['bar'].append([1, "bla"])
         self.assertRaises(SchemaTypeError, mydoc.validate)
         mydoc['foo']['bar'] = []
-        mydoc['foo']['bar'].append([1,u'bar',3.2])
+        mydoc['foo']['bar'].append([1,'bar',3.2])
         mydoc.validate()
-        mydoc['foo']['bar'].append([None, u"bla", 3.1])
+        mydoc['foo']['bar'].append([None, "bla", 3.1])
         mydoc.validate()
         mydoc['foo']['bar'][1][0] = 50
         mydoc.validate()
@@ -257,12 +261,12 @@ class MyDoc(SchemaDocument):
     def test_dict_unicode_typed_list(self):
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":{unicode:[int]}
+                "foo":{str:[int]}
             }
         mydoc = MyDoc()
-        mydoc['foo'] = {u"bar":[1,2,3]}
+        mydoc['foo'] = {"bar":[1,2,3]}
         mydoc.validate()
-        mydoc['foo'] = {u"bar":[u"bla"]}
+        mydoc['foo'] = {"bar":["bla"]}
         self.assertRaises(SchemaTypeError, mydoc.validate)
         mydoc['foo'] = {3:[1,2,3]}
         self.assertRaises(SchemaTypeError, mydoc.validate)
@@ -272,11 +276,11 @@ class MyDict(dict):
             pass
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":{unicode:int}
+                "foo":{str:int}
             }
         mydoc = MyDoc()
         mydict = MyDict()
-        mydict[u"foo"] = 3
+        mydict["foo"] = 3
         mydoc["foo"] = mydict
         mydoc.validate()
 
@@ -285,14 +289,14 @@ class MyDict(dict):
             pass
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":MyDict({unicode:int})
+                "foo":MyDict({str:int})
             }
         mydoc = MyDoc()
         mydict = MyDict()
-        mydict[u"foo"] = 3
+        mydict["foo"] = 3
         mydoc["foo"] = mydict
         mydoc.validate()
-        mydoc['foo'] = {u"foo":"7"}
+        mydoc['foo'] = {"foo":"7"}
         self.assertRaises(SchemaTypeError, mydoc.validate)
 
         class MyInt(int):
@@ -310,26 +314,26 @@ class MyDoc(SchemaDocument):
     def test_list_instead_of_dict(self):
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":{unicode:[unicode]}
+                "foo":{str:[str]}
             }
         mydoc = MyDoc()
-        mydoc['foo'] = [u'bla']
+        mydoc['foo'] = ['bla']
         self.assertRaises(SchemaTypeError, mydoc.validate)
 
     def _test_big_nested_example(self):
         # XXX TODO
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":{unicode:[int], u"bar":{"spam":{int:[unicode]}}},
-                "bla":{"blo":{"bli":[{"arf":unicode}]}},
+                "foo":{str:[int], "bar":{"spam":{int:[str]}}},
+                "bla":{"blo":{"bli":[{"arf":str}]}},
             }
         mydoc = MyDoc()
-        mydoc['foo'].update({u"bir":[1,2,3]})
-        mydoc['foo'][u'bar'][u'spam'] = {1:[u'bla', u'ble'], 3:[u'foo', u'bar']}
+        mydoc['foo'].update({"bir":[1,2,3]})
+        mydoc['foo']['bar']['spam'] = {1:['bla', 'ble'], 3:['foo', 'bar']}
         mydoc.validate()
-        mydoc['bla']['blo']['bli'] = [{u"bar":[u"bla"]}]
+        mydoc['bla']['blo']['bli'] = [{"bar":["bla"]}]
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['bla']['blo']['bli'] = [{u"arf":[1]}]
+        mydoc['bla']['blo']['bli'] = [{"arf":[1]}]
         self.assertRaises(SchemaTypeError, mydoc.validate)
 
 
@@ -351,43 +355,43 @@ class OP(SchemaOperator):
 
     def test_or_operator(self):
         from mongokit import OR
-        assert repr(OR(unicode, str)) == "<unicode or str>"
+        assert repr(OR(int, str)) == "<int or str>"
 
         failed = False
         try:
             class BadMyDoc(SchemaDocument):
-                structure = {"bla":OR(unicode,str)}
-        except StructureError, e:
-            self.assertEqual(str(e), "BadMyDoc: <type 'str'> in <unicode or str> is not an authorized type (type found)")
+                structure = {"bla":OR(int, tuple)}
+        except StructureError as e:
+            self.assertEqual(str(e), "BadMyDoc: <%s 'tuple'> in <int or tuple> is not an authorized type (type found)" % ('type' if six.PY2 else 'class'))
             failed = True
         self.assertEqual(failed, True)
 
         from datetime import datetime
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":OR(unicode,int),
-                "bar":OR(unicode, datetime)
+                "foo":OR(str,int),
+                "bar":OR(str, datetime)
             }
 
         mydoc = MyDoc()
-        assert str(mydoc.structure['foo']) == '<unicode or int>'
-        assert str(mydoc.structure['bar']) == '<unicode or datetime>'
+        assert str(mydoc.structure['foo']) == '<%s or int>' % str.__name__
+        assert str(mydoc.structure['bar']) == '<%s or datetime>' % str.__name__
         assert mydoc == {'foo': None, 'bar': None}
         mydoc['foo'] = 3.0
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['foo'] = u"foo"
+        mydoc['foo'] = "foo"
         mydoc.validate()
         mydoc['foo'] = 3
         mydoc.validate()
-        mydoc['foo'] = 'bar'
+        mydoc['foo'] = six.b('bar')
         self.assertRaises(SchemaTypeError, mydoc.validate)
 
         mydoc['foo'] = datetime.now()
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['foo'] = u"foo"
+        mydoc['foo'] = "foo"
         mydoc['bar'] = datetime.now()
         mydoc.validate()
-        mydoc['bar'] = u"today"
+        mydoc['bar'] = "today"
         mydoc.validate()
         mydoc['bar'] = 25
         self.assertRaises(SchemaTypeError, mydoc.validate)
@@ -397,28 +401,28 @@ def test_not_operator(self):
         failed = False
         try:
             class BadMyDoc(SchemaDocument):
-                structure = {"bla":NOT(unicode,str)}
-        except StructureError, e:
-            self.assertEqual(str(e), "BadMyDoc: <type 'str'> in <not unicode, not str> is not an authorized type (type found)")
+                structure = {"bla":NOT(int, tuple)}
+        except StructureError as e:
+            self.assertEqual(str(e), "BadMyDoc: <%s 'tuple'> in <not int, not tuple> is not an authorized type (type found)" % ('type' if six.PY2 else 'class'))
             failed = True
         self.assertEqual(failed, True)
 
         from datetime import datetime
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":NOT(unicode,int),
+                "foo":NOT(str,int),
                 "bar":NOT(datetime)
             }
 
         mydoc = MyDoc()
-        assert str(mydoc.structure['foo']) == '<not unicode, not int>', str(mydoc.structure['foo'])
+        assert str(mydoc.structure['foo']) == '<not %s, not int>' % str.__name__, str(mydoc.structure['foo'])
         assert str(mydoc.structure['bar']) == '<not datetime>'
         assert mydoc == {'foo': None, 'bar': None}
         assert mydoc['foo'] is None
         assert mydoc['bar'] is None
         mydoc['foo'] = 3
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['foo'] = u"foo"
+        mydoc['foo'] = "foo"
         self.assertRaises(SchemaTypeError, mydoc.validate)
         mydoc['foo'] = 3.0
         mydoc.validate()
@@ -427,7 +431,7 @@ class MyDoc(SchemaDocument):
 
         mydoc['bar'] = datetime.now()
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['bar'] = u"today"
+        mydoc['bar'] = "today"
         mydoc.validate()
         mydoc['bar'] = 25
         mydoc.validate()
@@ -437,45 +441,45 @@ def test_is_operator(self):
         failed = False
         try:
             class BadMyDoc(SchemaDocument):
-                structure = {"bla":IS('bla',3)}
-        except StructureError, e:
-            self.assertEqual(str(e), "BadMyDoc: bla in <is 'bla' or is 3> is not an authorized type (str found)")
+                structure = {"bla":IS(('bla',),3)}
+        except StructureError as e:
+            self.assertEqual(str(e), "BadMyDoc: ('bla',) in <is ('bla',) or is 3> is not an authorized type (tuple found)")
             failed = True
         self.assertEqual(failed, True)
 
         from datetime import datetime
         class MyDoc(SchemaDocument):
             structure = {
-                "foo":IS(u'spam',u'eggs'),
-                "bar":IS(u'3', 3)
+                "foo":IS('spam','eggs'),
+                "bar":IS('3', 3)
             }
 
         mydoc = MyDoc()
-        assert str(mydoc.structure['foo']) == "<is u'spam' or is u'eggs'>"
-        assert str(mydoc.structure['bar']) == "<is u'3' or is 3>"
+        assert str(mydoc.structure['foo']) == "<is 'spam' or is 'eggs'>"
+        assert str(mydoc.structure['bar']) == "<is '3' or is 3>"
         assert mydoc == {'foo': None, 'bar': None}
         assert mydoc['foo'] is None
         assert mydoc['bar'] is None
         mydoc['foo'] = 3
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['foo'] = u"bla"
+        mydoc['foo'] = "bla"
         self.assertRaises(SchemaTypeError, mydoc.validate)
         mydoc['foo'] = datetime.now()
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['foo'] = u"spam"
+        mydoc['foo'] = "spam"
         mydoc.validate()
-        mydoc['foo'] = u"eggs"
+        mydoc['foo'] = "eggs"
         mydoc.validate()
 
         mydoc['bar'] = datetime.now()
         self.assertRaises(SchemaTypeError, mydoc.validate)
-        mydoc['bar'] = u"today"
+        mydoc['bar'] = "today"
         self.assertRaises(SchemaTypeError, mydoc.validate)
         mydoc['bar'] = 'foo'
         self.assertRaises(SchemaTypeError, mydoc.validate)
         mydoc['bar'] = 3
         mydoc.validate()
-        mydoc['bar'] = u"3"
+        mydoc['bar'] = "3"
         mydoc.validate()
 
     def test_subclassed_type(self):
@@ -514,22 +518,22 @@ class MyDoc(Document):
     def test_set_type2(self):
         class MyDoc(Document):
                 structure = {
-                        'title':unicode,
-                        'category':Set(unicode)
+                        'title':str,
+                        'category':Set(str)
                 }
                 required_fields=['title']
         self.connection.register([MyDoc])
         doc = self.col.MyDoc()
-        print doc # {'category': set([]), 'title': None}
+        print(doc) # {'category': set([]), 'title': None}
         assert isinstance(doc['category'], set)
         try:
                 doc.validate()
         except RequireFieldError as e:
-                print e # title is required
+                print(e) # title is required
 
-        print doc # {'category': [], 'title': None}
+        print(doc) # {'category': [], 'title': None}
         assert isinstance(doc['category'], set)
-        doc['title']=u'hello'
+        doc['title']='hello'
         doc.validate()
 
     def test_int_type(self):
@@ -559,33 +563,20 @@ class MyDoc(Document):
 
         assert isinstance(self.col.MyDoc.find_one()['uuid'], uuid.UUID)
 
-    def test_binary_with_str_type(self):
+    def test_binary_with_bytes_type(self):
         import bson
         @self.connection.register
         class MyDoc(Document):
             structure = {
-                'my_binary': basestring,
+                'my_binary': bytes,
             }
         obj = self.col.MyDoc()
         # non-utf8 string
-        non_utf8 = "\xFF\xFE\xFF";
-        obj['my_binary'] = non_utf8
-
-        self.assertRaises(bson.errors.InvalidStringData, obj.validate)
-
-    def test_binary_with_unicode_type(self):
-        import bson
-        @self.connection.register
-        class MyDoc(Document):
-            structure = {
-                'my_binary': unicode,
-            }
-        obj = self.col.MyDoc()
-        # non-utf8 string
-        non_utf8 = "\xFF\xFE\xFF";
+        non_utf8 = b"\xFF\xFE\xFF";
         obj['my_binary'] = non_utf8
+        obj.save()
 
-        self.assertRaises(bson.errors.InvalidStringData, obj.validate)
+        self.assertEquals(self.col.MyDoc.find_one()['my_binary'], non_utf8)
 
     def test_binary_with_binary_type(self):
         import bson
@@ -596,9 +587,9 @@ class MyDoc(Document):
             }
         obj = self.col.MyDoc()
         # non-utf8 string
-        non_utf8 = "\xFF\xFE\xFF";
+        non_utf8 = b"\xFF\xFE\xFF";
         bin_obj = bson.binary.Binary(non_utf8)
         obj['my_binary'] = bin_obj
         obj.save()
 
-        self.assertEquals(self.col.MyDoc.find_one()['my_binary'], bin_obj)
+        self.assertEquals(self.col.MyDoc.find_one()['my_binary'], non_utf8)
diff --git a/tests/test_versioned.py b/tests/test_versioned.py
index b5de7e7..6921d36 100644
--- a/tests/test_versioned.py
+++ b/tests/test_versioned.py
@@ -25,10 +25,14 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from __future__ import print_function
+
 import unittest
 
 from mongokit import *
 
+import six
+
 class VersionedTestCase(unittest.TestCase):
     def setUp(self):
         self.connection = Connection()
@@ -43,25 +47,25 @@ def tearDown(self):
     def test_save_versioning(self):
         class MyDoc(Document):
             structure = {
-                "bla" : unicode,
+                "bla" : str,
             }
         self.connection.register([MyDoc])
 
         doc = self.col.MyDoc()
-        doc['bla'] =  u"bli"
+        doc['bla'] = "bli"
         doc.save()
         assert "_revision" not in doc
         doc.delete()
 
         class MyVersionedDoc(VersionedDocument):
             structure = {
-                "foo" : unicode,
+                "foo" : str,
             }
         self.connection.register([MyVersionedDoc])
  
         versioned_doc = self.col.MyVersionedDoc()
         versioned_doc['_id'] = "mydoc"
-        versioned_doc['foo'] = u'bla'
+        versioned_doc['foo'] = 'bla'
         versioned_doc.save()
 
         docs = list(self.col.find())
@@ -71,29 +75,29 @@ class MyVersionedDoc(VersionedDocument):
         assert len(ver_doc) == 1
         assert ver_doc[0]['id'] == 'mydoc'
         assert ver_doc[0]['revision'] == 1
-        assert ver_doc[0]['doc'] == {u'_revision': 1, u'foo': u'bla', u'_id': u'mydoc'}
+        assert ver_doc[0]['doc'] == {'_revision': 1, 'foo': 'bla', '_id': 'mydoc'}
 
         assert versioned_doc['_revision'] == 1
         assert versioned_doc.get_last_revision_id() == 1
         assert versioned_doc.get_revision(1) == {'foo':'bla', "_revision":1, "_id":"mydoc"}
-        versioned_doc['foo'] = u'bar'
+        versioned_doc['foo'] = 'bar'
         versioned_doc.save()
 
         ver_doc = list(self.connection.test.versioned_mongokit.find())
         assert len(ver_doc) == 2
         assert ver_doc[0]['id'] == 'mydoc'
         assert ver_doc[0]['revision'] == 1
-        assert ver_doc[0]['doc'] == {u'_revision': 1, u'foo': u'bla', u'_id': u'mydoc'}
+        assert ver_doc[0]['doc'] == {'_revision': 1, 'foo': 'bla', '_id': 'mydoc'}
         assert ver_doc[1]['id'] == 'mydoc'
         assert ver_doc[1]['revision'] == 2
-        assert ver_doc[1]['doc'] == {u'_revision': 2, u'foo': u'bar', u'_id': u'mydoc'}
+        assert ver_doc[1]['doc'] == {'_revision': 2, 'foo': 'bar', '_id': 'mydoc'}
 
         assert versioned_doc['_revision'] == 2
         assert versioned_doc.get_last_revision_id() == 2
         assert versioned_doc['foo'] == 'bar'
         assert versioned_doc.get_revision(2) == {'foo':'bar', "_revision":2, "_id":"mydoc"}, versioned_doc.get_revision(2)
         old_doc = versioned_doc.get_revision(1)
-        print old_doc, type(old_doc)
+        print(old_doc, type(old_doc))
         old_doc.save()
         assert old_doc['_revision'] == 3
 
@@ -103,13 +107,13 @@ class MyVersionedDoc(VersionedDocument):
     def test_save_without_versionning(self):
         class MyVersionedDoc(VersionedDocument):
             structure = {
-                "foo" : unicode,
+                "foo" : str,
             }
         self.connection.register([MyVersionedDoc])
  
         versioned_doc = self.col.MyVersionedDoc()
         versioned_doc['_id'] = "mydoc"
-        versioned_doc['foo'] = u'bla'
+        versioned_doc['foo'] = 'bla'
         versioned_doc.save(versioning=False)
         assert self.col.MyVersionedDoc.versioning_collection.find().count() == 0
         assert self.col.find().count() == 1
@@ -118,12 +122,12 @@ class MyVersionedDoc(VersionedDocument):
     def test_save_versioning_without_id(self):
         class MyVersionedDoc(VersionedDocument):
             structure = {
-                "foo" : unicode,
+                "foo" : str,
             }
         self.connection.register([MyVersionedDoc])
  
         versioned_doc = self.col.MyVersionedDoc()
-        versioned_doc['foo'] = u'bla'
+        versioned_doc['foo'] = 'bla'
         versioned_doc.save()
 
         ver_doc = list(self.connection.test.versioned_mongokit.find())
@@ -139,7 +143,7 @@ class MyVersionedDoc(VersionedDocument):
     def _test_bad_versioning(self):
         class MyVersionedDoc(VersionedDocument):
             structure = {
-                "foo" : unicode,
+                "foo" : str,
             }
  
         self.connection.register([MyVersionedDoc])
@@ -148,16 +152,16 @@ class MyVersionedDoc(VersionedDocument):
     def test_delete_versioning(self):
         class MyVersionedDoc(VersionedDocument):
             structure = {
-                "foo" : unicode,
+                "foo" : str,
             }
         self.connection.register([MyVersionedDoc])
  
         versioned_doc = self.col.MyVersionedDoc()
         versioned_doc['_id'] = "mydoc"
-        versioned_doc['foo'] = u'bla'
+        versioned_doc['foo'] = 'bla'
         versioned_doc.save()
         assert self.col.MyVersionedDoc.versioning_collection.find().count() == 1
-        versioned_doc['foo'] = u'bar'
+        versioned_doc['foo'] = 'bar'
         versioned_doc.save()
         assert self.col.MyVersionedDoc.versioning_collection.find().count() == 2
         versioned_doc.delete(versioning=True)
@@ -166,10 +170,10 @@ class MyVersionedDoc(VersionedDocument):
 
         versioned_doc = self.col.MyVersionedDoc()
         versioned_doc['_id'] = "mydoc"
-        versioned_doc['foo'] = u'bla'
+        versioned_doc['foo'] = 'bla'
         versioned_doc.save()
         assert self.col.MyVersionedDoc.versioning_collection.find().count() == 1
-        versioned_doc['foo'] = u'bar'
+        versioned_doc['foo'] = 'bar'
         versioned_doc.save()
         assert self.col.MyVersionedDoc.versioning_collection.find().count() == 2
         versioned_doc.delete()
@@ -179,28 +183,28 @@ class MyVersionedDoc(VersionedDocument):
     def test_remove_versioning(self):
         class MyVersionedDoc(VersionedDocument):
             structure = {
-                "foo" : unicode,
+                "foo" : str,
             }
         self.connection.register([MyVersionedDoc])
  
         versioned_doc = self.col.MyVersionedDoc()
         versioned_doc['_id'] = "mydoc"
-        versioned_doc['foo'] = u'bla'
+        versioned_doc['foo'] = 'bla'
         versioned_doc.save()
         versioned_doc2 = self.col.MyVersionedDoc()
         versioned_doc2['_id'] = "mydoc2"
-        versioned_doc2['foo'] = u'bla'
+        versioned_doc2['foo'] = 'bla'
         versioned_doc2.save()
         versioned_doc3 = self.col.MyVersionedDoc()
         versioned_doc3['_id'] = "mydoc3"
-        versioned_doc3['foo'] = u'bla'
+        versioned_doc3['foo'] = 'bla'
         versioned_doc3.save()
 
-        versioned_doc['foo'] = u'bar'
+        versioned_doc['foo'] = 'bar'
         versioned_doc.save()
-        versioned_doc2['foo'] = u'bar'
+        versioned_doc2['foo'] = 'bar'
         versioned_doc2.save()
-        versioned_doc3['foo'] = u'bar'
+        versioned_doc3['foo'] = 'bar'
         versioned_doc3.save()
 
         count =  self.col.MyVersionedDoc.versioning_collection.find().count()
@@ -218,27 +222,27 @@ class MyVersionedDoc(VersionedDocument):
     def _test_versioning_with_dynamic_db(self):
         class MyVersionedDoc(VersionedDocument):
             structure = {
-                "foo" : unicode,
+                "foo" : str,
             }
         self.connection.register([MyVersionedDoc])
  
         versioned_doc = self.col.MyVersionedDoc()
         versioned_doc['_id'] = "mydoc"
-        versioned_doc['foo'] = u'bla'
+        versioned_doc['foo'] = 'bla'
         versioned_doc.save()
 
         ver_doc = list(self.connection.test.versioned_mongokit.find())
         assert len(ver_doc) == 1
         assert ver_doc[0]['id'] == 'mydoc'
         assert ver_doc[0]['revision'] == 1
-        assert ver_doc[0]['doc'] == {u'_revision': 1, u'foo': u'bla', u'_id': u'mydoc'}
+        assert ver_doc[0]['doc'] == {'_revision': 1, 'foo': 'bla', '_id': 'mydoc'}
 
         ver_mongokit2 = list(CONNECTION['versioned_test']['versioned_mongokit'].find())
         assert len(ver_mongokit2) == 0, len(ver_mongokit2)
 
         versioned_doc2 = MyVersionedDoc(versioning_db_name="versioned_test")
         versioned_doc2['_id'] = "mydoc2"
-        versioned_doc2['foo'] = u'bla'
+        versioned_doc2['foo'] = 'bla'
         versioned_doc2.save()
 
         ver_mongokit = list(CONNECTION['test']['versioned_mongokit'].find())
@@ -248,9 +252,9 @@ class MyVersionedDoc(VersionedDocument):
         assert len(ver_doc) == 1
         assert ver_doc[0]['id'] == 'mydoc2'
         assert ver_doc[0]['revision'] == 1
-        assert ver_doc[0]['doc'] == {u'_revision': 1, u'foo': u'bla', u'_id': u'mydoc2'}
+        assert ver_doc[0]['doc'] == {'_revision': 1, 'foo': 'bla', '_id': 'mydoc2'}
 
-        versioned_doc['foo'] = u'bar'
+        versioned_doc['foo'] = 'bar'
         versioned_doc.save()
 
         ver_doc = list(CONNECTION['test']['versioned_mongokit'].find())
@@ -261,27 +265,27 @@ class MyVersionedDoc(VersionedDocument):
     def _test_versioning_with_dynamic_collection(self):
         class MyVersionedDoc(VersionedDocument):
             structure = {
-                "foo" : unicode,
+                "foo" : str,
             }
             versioning_collection_name = "versioned_mongokit"
  
         versioned_doc = MyVersionedDoc()
         versioned_doc['_id'] = "mydoc"
-        versioned_doc['foo'] = u'bla'
+        versioned_doc['foo'] = 'bla'
         versioned_doc.save()
 
         ver_doc = list(CONNECTION['test']['versioned_mongokit'].find())
         assert len(ver_doc) == 1
         assert ver_doc[0]['id'] == 'mydoc'
         assert ver_doc[0]['revision'] == 1
-        assert ver_doc[0]['doc'] == {u'_revision': 1, u'foo': u'bla', u'_id': u'mydoc'}
+        assert ver_doc[0]['doc'] == {'_revision': 1, 'foo': 'bla', '_id': 'mydoc'}
 
         ver_mongokit2 = list(CONNECTION['test']['versioned_mongokit2'].find())
         assert len(ver_mongokit2) == 0
 
         versioned_doc2 = MyVersionedDoc(versioning_collection_name="versioned_mongokit2")
         versioned_doc2['_id'] = "mydoc2"
-        versioned_doc2['foo'] = u'bla'
+        versioned_doc2['foo'] = 'bla'
         versioned_doc2.save()
 
         ver_mongokit = list(CONNECTION['test']['versioned_mongokit'].find())
@@ -291,9 +295,9 @@ class MyVersionedDoc(VersionedDocument):
         assert len(ver_doc) == 1
         assert ver_doc[0]['id'] == 'mydoc2'
         assert ver_doc[0]['revision'] == 1
-        assert ver_doc[0]['doc'] == {u'_revision': 1, u'foo': u'bla', u'_id': u'mydoc2'}
+        assert ver_doc[0]['doc'] == {'_revision': 1, 'foo': 'bla', '_id': 'mydoc2'}
 
-        versioned_doc['foo'] = u'bar'
+        versioned_doc['foo'] = 'bar'
         versioned_doc.save()
 
         ver_doc = list(CONNECTION['test']['versioned_mongokit'].find())
@@ -307,7 +311,7 @@ def test_versioning_without_versioning_collection_name(self):
             class Group(VersionedDocument):
                 use_autorefs = True
                 structure = {
-                       'name':unicode,
+                       'name':str,
                        'members':[User], #users
                    }
         except:
@@ -336,19 +340,19 @@ def test_resave_versioned_doc_with_objectId(self):
         """
         class MyVersionedDoc(VersionedDocument):
             structure = {
-                "foo" : unicode,
+                "foo" : str,
                 }
 
         self.connection.register([MyVersionedDoc])
 
         versioned_doc = self.col.MyVersionedDoc()
-        versioned_doc['foo'] = u'bla'
+        versioned_doc['foo'] = 'bla'
         versioned_doc.save()
 
         docs = list(self.col.find())
         assert len(docs) == 1
 
-        versioned_doc['foo'] = u'Some Other bla'
+        versioned_doc['foo'] = 'Some Other bla'
         versioned_doc.save()
 
         print(versioned_doc)
@@ -360,7 +364,7 @@ def test_resave_versioned_doc_with_UUID(self):
         """
         class MyVersionedUUIDDoc(VersionedDocument):
             structure = {
-                "foo" : unicode,
+                "foo" : str,
                 }
             def save(self, versioning=True, uuid=True, *args, **kwargs):
                 """ Ensure that the save is performed using uuid=True """
@@ -369,19 +373,19 @@ def save(self, versioning=True, uuid=True, *args, **kwargs):
         self.connection.register([MyVersionedUUIDDoc])
 
         versioned_doc = self.col.MyVersionedUUIDDoc()
-        versioned_doc['foo'] = u'bla'
+        versioned_doc['foo'] = 'bla'
         versioned_doc.save()
 
         docs = list(self.col.find())
         assert len(docs) == 1
 
-        versioned_doc['foo'] = u'Some Other bla'
+        versioned_doc['foo'] = 'Some Other bla'
         versioned_doc.save()
 
         # search for the versioned_doc in the database and compare id's
         ver_doc = list(self.connection.test.mongokit.find())
         assert len(ver_doc) == 1
         assert ver_doc[0]['_revision'] == 2
-        assert ver_doc[0]['foo'] == u'Some Other bla'
-        assert ver_doc[0]['_id'][:18] == u'MyVersionedUUIDDoc'
+        assert ver_doc[0]['foo'] == 'Some Other bla'
+        assert ver_doc[0]['_id'][:18] == 'MyVersionedUUIDDoc'
         assert ver_doc[0]['_id'] == versioned_doc['_id']