Bump version to v0.18.2

See https://github.com/MongoEngine/mongoengine/issues/2104 for details.

For now I'm hardcoding `$MONGODB = 3.4.17` just to get a release out there,
but we should probably use the globals going forward. Will do that in
a follow-up commit once I get the `travis-conditions` gem up and running and
hence can test `.travis.yml` changes without deploying.

.gitignore

@@ -15,3 +15,6 @@ env/
 .pydevproject
 tests/test_bugfix.py
 htmlcov/
+venv
+venv3
+scratchpad

.landscape.yml

@@ -0,0 +1,22 @@
+pylint:
+    disable:
+        # We use this a lot (e.g. via document._meta)
+        - protected-access
+
+    options:
+        additional-builtins:
+            # add xrange and long as valid built-ins. In Python 3, xrange is
+            # translated into range and long is translated into int via 2to3 (see
+            # "use_2to3" in setup.py). This should be removed when we drop Python
+            # 2 support (which probably won't happen any time soon).
+            - xrange
+            - long
+
+pyflakes:
+    disable:
+        # undefined variables are already covered by pylint (and exclude
+        # xrange & long)
+        - F821
+
+ignore-paths:
+    - benchmark.py

.travis.yml

@@ -1,33 +1,106 @@
-# http://travis-ci.org/#!/MongoEngine/mongoengine
+# For full coverage, we'd have to test all supported Python, MongoDB, and
+# PyMongo combinations. However, that would result in an overly long build
+# with a very large number of jobs, hence we only test a subset of all the
+# combinations:
+# * MongoDB v3.4 & the latest PyMongo v3.x is currently the "main" setup,
+#   tested against Python v2.7, v3.5, v3.6, and PyPy.
+# * Besides that, we test the lowest actively supported Python/MongoDB/PyMongo
+#   combination: MongoDB v3.4, PyMongo v3.4, Python v2.7.
+# * MongoDB v3.6 is tested against Python v3.6, and PyMongo v3.6, v3.7, v3.8.
+#
+# We should periodically check MongoDB Server versions supported by MongoDB
+# Inc., add newly released versions to the test matrix, and remove versions
+# which have reached their End of Life. See:
+# 1. https://www.mongodb.com/support-policy.
+# 2. https://docs.mongodb.com/ecosystem/drivers/driver-compatibility-reference/#python-driver-compatibility
+#
+# Reminder: Update README.rst if you change MongoDB versions we test.
+
+
 language: python
-services: mongodb
 python:
-    - "2.6"
-    - "2.7"
-    - "3.2"
-    - "3.3"
+- 2.7
+- 3.5
+- 3.6
+- pypy
+
+dist: xenial
+
 env:
-  - PYMONGO=dev DJANGO=1.6
-  - PYMONGO=dev DJANGO=1.5.5
-  - PYMONGO=dev DJANGO=1.4.10
-  - PYMONGO=2.5 DJANGO=1.6
-  - PYMONGO=2.5 DJANGO=1.5.5
-  - PYMONGO=2.5 DJANGO=1.4.10
-  - PYMONGO=3.2 DJANGO=1.6
-  - PYMONGO=3.2 DJANGO=1.5.5
-  - PYMONGO=3.3 DJANGO=1.6
-  - PYMONGO=3.3 DJANGO=1.5.5
+  global:
+    - MONGODB_3_4=3.4.17
+    - MONGODB_3_6=3.6.12
+  matrix:
+    - MONGODB=${MONGODB_3_4} PYMONGO=3.x
+
+matrix:
+
+  # Finish the build as soon as one job fails
+  fast_finish: true
+
+  include:
+  - python: 2.7
+    env: MONGODB=${MONGODB_3_4} PYMONGO=3.4.x
+  - python: 3.6
+    env: MONGODB=${MONGODB_3_6} PYMONGO=3.x
+  - python: 3.7
+    env: MONGODB=${MONGODB_3_6} PYMONGO=3.x
+
+
 install:
-    - if [[ $TRAVIS_PYTHON_VERSION == '2.'* ]]; then cp /usr/lib/*/libz.so $VIRTUAL_ENV/lib/; fi
-    - if [[ $TRAVIS_PYTHON_VERSION == '2.'* ]]; then pip install pil --use-mirrors ; true; fi
-    - if [[ $PYMONGO == 'dev' ]]; then pip install https://github.com/mongodb/mongo-python-driver/tarball/master; true; fi
-    - if [[ $PYMONGO != 'dev' ]]; then pip install pymongo==$PYMONGO --use-mirrors; true; fi
-    - pip install https://pypi.python.org/packages/source/p/python-dateutil/python-dateutil-2.1.tar.gz#md5=1534bb15cf311f07afaa3aacba1c028b
-    - python setup.py install
+  # Install Mongo
+  - wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-${MONGODB}.tgz
+  - tar xzf mongodb-linux-x86_64-${MONGODB}.tgz
+  - ${PWD}/mongodb-linux-x86_64-${MONGODB}/bin/mongod --version
+  # Install python dependencies
+  - pip install --upgrade pip
+  - pip install coveralls
+  - pip install flake8 flake8-import-order
+  - pip install tox         # tox 3.11.0 has requirement virtualenv>=14.0.0
+  - pip install virtualenv  # virtualenv>=14.0.0 has dropped Python 3.2 support (and pypy3 is based on py32)
+  # Install the tox venv
+  - tox -e $(echo py$TRAVIS_PYTHON_VERSION-mg$PYMONGO | tr -d . | sed -e 's/pypypy/pypy/') -- -e test
+
+before_script:
+  - mkdir ${PWD}/mongodb-linux-x86_64-${MONGODB}/data
+  - ${PWD}/mongodb-linux-x86_64-${MONGODB}/bin/mongod --dbpath ${PWD}/mongodb-linux-x86_64-${MONGODB}/data --logpath ${PWD}/mongodb-linux-x86_64-${MONGODB}/mongodb.log --fork
+  - if [[ $TRAVIS_PYTHON_VERSION == '2.7' ]]; then flake8 .; else echo "flake8 only runs on py27"; fi   # Run flake8 for py27
+  - mongo --eval 'db.version();'    # Make sure mongo is awake
+
 script:
-    - python setup.py test
+  - tox -e $(echo py$TRAVIS_PYTHON_VERSION-mg$PYMONGO | tr -d . | sed -e 's/pypypy/pypy/') -- --with-coverage
+
+# For now only submit coveralls for Python v2.7. Python v3.x currently shows
+# 0% coverage. That's caused by 'use_2to3', which builds the py3-compatible
+# code in a separate dir and runs tests on that.
+after_success:
+- if [[ $TRAVIS_PYTHON_VERSION == '2.7' ]]; then coveralls --verbose; fi
+
 notifications:
-  irc: "irc.freenode.org#mongoengine"
+  irc: irc.freenode.org#mongoengine
+
+# Only run builds on the master branch and GitHub releases (tagged as vX.Y.Z)
 branches:
   only:
-    - master
+  - master
+  - /^v.*$/
+
+# Whenever a new release is created via GitHub, publish it on PyPI.
+deploy:
+  provider: pypi
+  user: the_drow
+  password:
+    secure: QMyatmWBnC6ZN3XLW2+fTBDU4LQcp1m/LjR2/0uamyeUzWKdlOoh/Wx5elOgLwt/8N9ppdPeG83ose1jOz69l5G0MUMjv8n/RIcMFSpCT59tGYqn3kh55b0cIZXFT9ar+5cxlif6a5rS72IHm5li7QQyxexJIII6Uxp0kpvUmek=
+
+  # Create a source distribution and a pure python wheel for faster installs.
+  distributions: "sdist bdist_wheel"
+
+  # Only deploy on tagged commits (aka GitHub releases) and only for the parent
+  # repo's builds running Python v2.7 along with PyMongo v3.x and MongoDB v3.4.
+  # We run Travis against many different Python, PyMongo, and MongoDB versions
+  # and we don't want the deploy to occur multiple times).
+  on:
+    tags: true
+    repo: MongoEngine/mongoengine
+    condition: ($PYMONGO = 3.x) && ($MONGODB = 3.4.17)
+    python: 2.7

AUTHORS

@@ -12,7 +12,7 @@ Laine Herron https://github.com/LaineHerron
 
 CONTRIBUTORS
 
-Dervived from the git logs, inevitably incomplete but all of whom and others
+Derived from the git logs, inevitably incomplete but all of whom and others
 have submitted patches, reported bugs and generally helped make MongoEngine
 that much better:
 
@@ -119,7 +119,7 @@ that much better:
  * Anton Kolechkin
  * Sergey Nikitin
  * psychogenic
- * Stefan Wójcik
+ * Stefan Wójcik (https://github.com/wojcikstefan)
  * dimonb
  * Garry Polley
  * James Slagle
@@ -138,11 +138,10 @@ that much better:
  * hellysmile
  * Jaepil Jeong
  * Daniil Sharou
- * Stefan Wójcik
  * Pete Campton
  * Martyn Smith
  * Marcelo Anton
- * Aleksey Porfirov
+ * Aleksey Porfirov (https://github.com/lexqt)
  * Nicolas Trippar
  * Manuel Hermann
  * Gustavo Gawryszewski
@@ -171,7 +170,7 @@ that much better:
  * Michael Bartnett (https://github.com/michaelbartnett)
  * Alon Horev (https://github.com/alonho)
  * Kelvin Hammond (https://github.com/kelvinhammond)
- * Jatin- (https://github.com/jatin-)
+ * Jatin Chopra (https://github.com/jatin)
  * Paul Uithol (https://github.com/PaulUithol)
  * Thom Knowles (https://github.com/fleat)
  * Paul (https://github.com/squamous)
@@ -189,3 +188,67 @@ that much better:
  * Tom (https://github.com/tomprimozic)
  * j0hnsmith (https://github.com/j0hnsmith)
  * Damien Churchill (https://github.com/damoxc)
+ * Jonathan Simon Prates (https://github.com/jonathansp)
+ * Thiago Papageorgiou (https://github.com/tmpapageorgiou)
+ * Omer Katz (https://github.com/thedrow)
+ * Falcon Dai (https://github.com/falcondai)
+ * Polyrabbit (https://github.com/polyrabbit)
+ * Sagiv Malihi (https://github.com/sagivmalihi)
+ * Dmitry Konishchev (https://github.com/KonishchevDmitry)
+ * Martyn Smith (https://github.com/martynsmith)
+ * Andrei Zbikowski (https://github.com/b1naryth1ef)
+ * Ronald van Rij (https://github.com/ronaldvanrij)
+ * François Schmidts (https://github.com/jaesivsm)
+ * Eric Plumb (https://github.com/professorplumb)
+ * Damien Churchill (https://github.com/damoxc)
+ * Aleksandr Sorokoumov (https://github.com/Gerrrr)
+ * Clay McClure (https://github.com/claymation)
+ * Bruno Rocha (https://github.com/rochacbruno)
+ * Norberto Leite (https://github.com/nleite)
+ * Bob Cribbs (https://github.com/bocribbz)
+ * Jay Shirley (https://github.com/jshirley)
+ * David Bordeynik (https://github.com/DavidBord)
+ * Axel Haustant (https://github.com/noirbizarre)
+ * David Czarnecki (https://github.com/czarneckid)
+ * Vyacheslav Murashkin (https://github.com/a4tunado)
+ * André Ericson https://github.com/aericson)
+ * Mikhail Moshnogorsky (https://github.com/mikhailmoshnogorsky)
+ * Diego Berrocal (https://github.com/cestdiego)
+ * Matthew Ellison (https://github.com/seglberg)
+ * Jimmy Shen (https://github.com/jimmyshen)
+ * J. Fernando Sánchez (https://github.com/balkian)
+ * Michael Chase (https://github.com/rxsegrxup)
+ * Eremeev Danil (https://github.com/elephanter)
+ * Catstyle Lee (https://github.com/Catstyle)
+ * Kiryl Yermakou (https://github.com/rma4ok)
+ * Matthieu Rigal (https://github.com/MRigal)
+ * Charanpal Dhanjal (https://github.com/charanpald)
+ * Emmanuel Leblond (https://github.com/touilleMan)
+ * Breeze.Kay (https://github.com/9nix00)
+ * Vicki Donchenko (https://github.com/kivistein)
+ * Emile Caron (https://github.com/emilecaron)
+ * Amit Lichtenberg (https://github.com/amitlicht)
+ * Gang Li (https://github.com/iici-gli)
+ * Lars Butler (https://github.com/larsbutler)
+ * George Macon (https://github.com/gmacon)
+ * Ashley Whetter (https://github.com/AWhetter)
+ * Paul-Armand Verhaegen (https://github.com/paularmand)
+ * Steven Rossiter (https://github.com/BeardedSteve)
+ * Luo Peng (https://github.com/RussellLuo)
+ * Bryan Bennett (https://github.com/bbenne10)
+ * Gilb's Gilb's (https://github.com/gilbsgilbs)
+ * Joshua Nedrud (https://github.com/Neurostack)
+ * Shu Shen (https://github.com/shushen)
+ * xiaost7 (https://github.com/xiaost7)
+ * Victor Varvaryuk
+ * Stanislav Kaledin (https://github.com/sallyruthstruik)
+ * Dmitry Yantsen (https://github.com/mrTable)
+ * Renjianxin (https://github.com/Davidrjx)
+ * Erdenezul Batmunkh (https://github.com/erdenezul)
+ * Andy Yankovsky (https://github.com/werat)
+ * Bastien Gérard (https://github.com/bagerard)
+ * Trevor Hall (https://github.com/tjhall13)
+ * Gleb Voropaev (https://github.com/buggyspace)
+ * Paulo Amaral (https://github.com/pauloAmaral)
+ * Gaurav Dadhania (https://github.com/GVRV)
+ * Yurii Andrieiev (https://github.com/yandrieiev)

CONTRIBUTING.rst

@@ -14,38 +14,57 @@ Before starting to write code, look for existing `tickets
 <https://github.com/MongoEngine/mongoengine/issues?state=open>`_ or `create one
 <https://github.com/MongoEngine/mongoengine/issues>`_ for your specific
 issue or feature request. That way you avoid working on something
-that might not be of interest or that has already been addressed.  If in doubt
+that might not be of interest or that has already been addressed. If in doubt
 post to the `user group <http://groups.google.com/group/mongoengine-users>`
 
 Supported Interpreters
 ----------------------
 
-MongoEngine supports CPython 2.6 and newer. Language
+MongoEngine supports CPython 2.7 and newer. Language
 features not supported by all interpreters can not be used.
-Please also ensure that your code is properly converted by
-`2to3 <http://docs.python.org/library/2to3.html>`_ for Python 3 support.
+The codebase is written in python 2 so you must be using python 2
+when developing new features. Compatibility of the library with Python 3
+relies on the 2to3 package that gets executed as part of the installation
+build. You should ensure that your code is properly converted by
+`2to3 <http://docs.python.org/library/2to3.html>`_.
 
 Style Guide
 -----------
 
 MongoEngine aims to follow `PEP8 <http://www.python.org/dev/peps/pep-0008/>`_
-including 4 space indents and 79 character line limits.
+including 4 space indents. When possible we try to stick to 79 character line
+limits. However, screens got bigger and an ORM has a strong focus on
+readability and if it can help, we accept 119 as maximum line length, in a
+similar way as `django does
+<https://docs.djangoproject.com/en/dev/internals/contributing/writing-code/coding-style/#python-style>`_
 
 Testing
 -------
 
 All tests are run on `Travis <http://travis-ci.org/MongoEngine/mongoengine>`_
-and any pull requests are automatically tested by Travis. Any pull requests
-without tests will take longer to be integrated and might be refused.
+and any pull requests are automatically tested. Any pull requests without
+tests will take longer to be integrated and might be refused.
+
+You may also submit a simple failing test as a pull request if you don't know
+how to fix it, it will be easier for other people to work on it and it may get
+fixed faster.
 
 General Guidelines
 ------------------
 
 - Avoid backward breaking changes if at all possible.
+- If you *have* to introduce a breaking change, make it very clear in your
+  pull request's description. Also, describe how users of this package
+  should adapt to the breaking change in docs/upgrade.rst.
 - Write inline documentation for new classes and methods.
 - Write tests and make sure they pass (make sure you have a mongod
-  running on the default port, then execute ``python setup.py test``
+  running on the default port, then execute ``python setup.py nosetests``
   from the cmd line to run the test suite).
+- Ensure tests pass on all supported Python, PyMongo, and MongoDB versions.
+  You can test various Python and PyMongo versions locally by executing
+  ``tox``. For different MongoDB versions, you can rely on our automated
+  Travis tests.
+- Add enhancements or problematic bug fixes to docs/changelog.rst.
 - Add yourself to AUTHORS :)
 
 Documentation
@@ -59,3 +78,8 @@ just make your changes to the inline documentation of the appropriate
 branch and submit a `pull request <https://help.github.com/articles/using-pull-requests>`_.
 You might also use the github `Edit <https://github.com/blog/844-forking-with-the-edit-button>`_
 button.
+
+If you want to test your documentation changes locally, you need to install
+the ``sphinx`` and ``sphinx_rtd_theme`` packages. Once these are installed,
+go to the ``docs`` directory, run ``make html`` and inspect the updated docs
+by running ``open _build/html/index.html``.

README.rst

@@ -4,39 +4,74 @@ MongoEngine
 :Info: MongoEngine is an ORM-like layer on top of PyMongo.
 :Repository: https://github.com/MongoEngine/mongoengine
 :Author: Harry Marr (http://github.com/hmarr)
-:Maintainer: Ross Lawley (http://github.com/rozza)
+:Maintainer: Stefan Wójcik (http://github.com/wojcikstefan)
 
-.. image:: https://secure.travis-ci.org/MongoEngine/mongoengine.png?branch=master
-  :target: http://travis-ci.org/MongoEngine/mongoengine
+.. image:: https://travis-ci.org/MongoEngine/mongoengine.svg?branch=master
+  :target: https://travis-ci.org/MongoEngine/mongoengine
+
+.. image:: https://coveralls.io/repos/github/MongoEngine/mongoengine/badge.svg?branch=master
+  :target: https://coveralls.io/github/MongoEngine/mongoengine?branch=master
+
+.. image:: https://landscape.io/github/MongoEngine/mongoengine/master/landscape.svg?style=flat
+  :target: https://landscape.io/github/MongoEngine/mongoengine/master
+  :alt: Code Health
 
 About
 =====
 MongoEngine is a Python Object-Document Mapper for working with MongoDB.
-Documentation available at http://mongoengine-odm.rtfd.org - there is currently
-a `tutorial <http://readthedocs.org/docs/mongoengine-odm/en/latest/tutorial.html>`_, a `user guide
-<https://mongoengine-odm.readthedocs.org/en/latest/guide/index.html>`_ and an `API reference
-<http://readthedocs.org/docs/mongoengine-odm/en/latest/apireference.html>`_.
+Documentation is available at https://mongoengine-odm.readthedocs.io - there
+is currently a `tutorial <https://mongoengine-odm.readthedocs.io/tutorial.html>`_,
+a `user guide <https://mongoengine-odm.readthedocs.io/guide/index.html>`_, and
+an `API reference <https://mongoengine-odm.readthedocs.io/apireference.html>`_.
+
+Supported MongoDB Versions
+==========================
+MongoEngine is currently tested against MongoDB v3.4 and v3.6. Future versions
+should be supported as well, but aren't actively tested at the moment. Make
+sure to open an issue or submit a pull request if you experience any problems
+with MongoDB version > 3.6.
 
 Installation
 ============
-If you have `setuptools <http://peak.telecommunity.com/DevCenter/setuptools>`_
-you can use ``easy_install -U mongoengine``. Otherwise, you can download the
-source from `GitHub <http://github.com/MongoEngine/mongoengine>`_ and run ``python
-setup.py install``.
+We recommend the use of `virtualenv <https://virtualenv.pypa.io/>`_ and of
+`pip <https://pip.pypa.io/>`_. You can then use ``pip install -U mongoengine``.
+You may also have `setuptools <http://peak.telecommunity.com/DevCenter/setuptools>`_
+and thus you can use ``easy_install -U mongoengine``. Another option is
+`pipenv <https://docs.pipenv.org/>`_. You can then use ``pipenv install mongoengine``
+to both create the virtual environment and install the package. Otherwise, you can
+download the source from `GitHub <http://github.com/MongoEngine/mongoengine>`_ and
+run ``python setup.py install``.
 
 Dependencies
 ============
-- pymongo 2.5+
-- sphinx (optional - for documentation generation)
+All of the dependencies can easily be installed via `pip <https://pip.pypa.io/>`_.
+At the very least, you'll need these two packages to use MongoEngine:
+
+- pymongo>=3.4
+- six>=1.10.0
+
+If you utilize a ``DateTimeField``, you might also use a more flexible date parser:
+
+- dateutil>=2.1.0
+
+If you need to use an ``ImageField`` or ``ImageGridFsProxy``:
+
+- Pillow>=2.0.0
 
 Examples
 ========
-Some simple examples of what MongoEngine code looks like::
+Some simple examples of what MongoEngine code looks like:
+
+.. code :: python
+
+    from mongoengine import *
+    connect('mydb')
 
     class BlogPost(Document):
         title = StringField(required=True, max_length=200)
-        posted = DateTimeField(default=datetime.datetime.now)
+        posted = DateTimeField(default=datetime.datetime.utcnow)
         tags = ListField(StringField(max_length=50))
+        meta = {'allow_inheritance': True}
 
     class TextPost(BlogPost):
         content = StringField(required=True)
@@ -64,23 +99,46 @@ Some simple examples of what MongoEngine code looks like::
     ...     print
     ...
 
-    >>> len(BlogPost.objects)
+    # Count all blog posts and its subtypes
+    >>> BlogPost.objects.count()
     2
-    >>> len(HtmlPost.objects)
+    >>> TextPost.objects.count()
     1
-    >>> len(LinkPost.objects)
+    >>> LinkPost.objects.count()
     1
 
-    # Find tagged posts
-    >>> len(BlogPost.objects(tags='mongoengine'))
+    # Count tagged posts
+    >>> BlogPost.objects(tags='mongoengine').count()
     2
-    >>> len(BlogPost.objects(tags='mongodb'))
+    >>> BlogPost.objects(tags='mongodb').count()
     1
 
 Tests
 =====
 To run the test suite, ensure you are running a local instance of MongoDB on
-the standard port, and run: ``python setup.py test``.
+the standard port and have ``nose`` installed. Then, run ``python setup.py nosetests``.
+
+To run the test suite on every supported Python and PyMongo version, you can
+use ``tox``. You'll need to make sure you have each supported Python version
+installed in your environment and then:
+
+.. code-block:: shell
+
+    # Install tox
+    $ pip install tox
+    # Run the test suites
+    $ tox
+
+If you wish to run a subset of tests, use the nosetests convention:
+
+.. code-block:: shell
+
+    # Run all the tests in a particular test file
+    $ python setup.py nosetests --tests tests/fields/fields.py
+    # Run only particular test class in that file
+    $ python setup.py nosetests --tests tests/fields/fields.py:FieldTest
+    # Use the -s option if you want to print some debug statements or use pdb
+    $ python setup.py nosetests --tests tests/fields/fields.py:FieldTest -s
 
 Community
 =========
@@ -88,8 +146,7 @@ Community
   <http://groups.google.com/group/mongoengine-users>`_
 - `MongoEngine Developers mailing list
   <http://groups.google.com/group/mongoengine-dev>`_
-- `#mongoengine IRC channel <http://webchat.freenode.net/?channels=mongoengine>`_
 
 Contributing
 ============
-We welcome contributions! see  the`Contribution guidelines <https://github.com/MongoEngine/mongoengine/blob/master/CONTRIBUTING.rst>`_
+We welcome contributions! See the `Contribution guidelines <https://github.com/MongoEngine/mongoengine/blob/master/CONTRIBUTING.rst>`_

benchmark.py

@@ -1,282 +0,0 @@
-#!/usr/bin/env python
-
-import timeit
-
-
-def cprofile_main():
-    from pymongo import Connection
-    connection = Connection()
-    connection.drop_database('timeit_test')
-    connection.disconnect()
-
-    from mongoengine import Document, DictField, connect
-    connect("timeit_test")
-
-    class Noddy(Document):
-        fields = DictField()
-
-    for i in xrange(1):
-        noddy = Noddy()
-        for j in range(20):
-            noddy.fields["key" + str(j)] = "value " + str(j)
-        noddy.save()
-
-
-def main():
-    """
-    0.4 Performance Figures ...
-
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - Pymongo
-    3.86744189262
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine
-    6.23374891281
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, safe=False, validate=False
-    5.33027005196
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, safe=False, validate=False, cascade=False
-    pass - No Cascade
-
-    0.5.X
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - Pymongo
-    3.89597702026
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine
-    21.7735359669
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, safe=False, validate=False
-    19.8670389652
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, safe=False, validate=False, cascade=False
-    pass - No Cascade
-
-    0.6.X
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - Pymongo
-    3.81559205055
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine
-    10.0446798801
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, safe=False, validate=False
-    9.51354718208
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, safe=False, validate=False, cascade=False
-    9.02567505836
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, force=True
-    8.44933390617
-
-    0.7.X
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - Pymongo
-    3.78801012039
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine
-    9.73050498962
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, safe=False, validate=False
-    8.33456707001
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, safe=False, validate=False, cascade=False
-    8.37778115273
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, force=True
-    8.36906409264
-    0.8.X
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - Pymongo
-    3.69964408875
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - Pymongo write_concern={"w": 0}
-    3.5526599884
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine
-    7.00959801674
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries without continual assign - MongoEngine
-    5.60943293571
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine - write_concern={"w": 0}, cascade=True
-    6.715102911
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, write_concern={"w": 0}, validate=False, cascade=True
-    5.50644683838
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, write_concern={"w": 0}, validate=False
-    4.69851183891
-    ----------------------------------------------------------------------------------------------------
-    Creating 10000 dictionaries - MongoEngine, force_insert=True, write_concern={"w": 0}, validate=False
-    4.68946313858
-    ----------------------------------------------------------------------------------------------------
-    """
-
-    setup = """
-from pymongo import MongoClient
-connection = MongoClient()
-connection.drop_database('timeit_test')
-"""
-
-    stmt = """
-from pymongo import MongoClient
-connection = MongoClient()
-
-db = connection.timeit_test
-noddy = db.noddy
-
-for i in xrange(10000):
-    example = {'fields': {}}
-    for j in range(20):
-        example['fields']["key"+str(j)] = "value "+str(j)
-
-    noddy.save(example)
-
-myNoddys = noddy.find()
-[n for n in myNoddys] # iterate
-"""
-
-    print "-" * 100
-    print """Creating 10000 dictionaries - Pymongo"""
-    t = timeit.Timer(stmt=stmt, setup=setup)
-    print t.timeit(1)
-
-    stmt = """
-from pymongo import MongoClient
-connection = MongoClient()
-
-db = connection.timeit_test
-noddy = db.noddy
-
-for i in xrange(10000):
-    example = {'fields': {}}
-    for j in range(20):
-        example['fields']["key"+str(j)] = "value "+str(j)
-
-    noddy.save(example, write_concern={"w": 0})
-
-myNoddys = noddy.find()
-[n for n in myNoddys] # iterate
-"""
-
-    print "-" * 100
-    print """Creating 10000 dictionaries - Pymongo write_concern={"w": 0}"""
-    t = timeit.Timer(stmt=stmt, setup=setup)
-    print t.timeit(1)
-
-    setup = """
-from pymongo import MongoClient
-connection = MongoClient()
-connection.drop_database('timeit_test')
-connection.disconnect()
-
-from mongoengine import Document, DictField, connect
-connect("timeit_test")
-
-class Noddy(Document):
-    fields = DictField()
-"""
-
-    stmt = """
-for i in xrange(10000):
-    noddy = Noddy()
-    for j in range(20):
-        noddy.fields["key"+str(j)] = "value "+str(j)
-    noddy.save()
-
-myNoddys = Noddy.objects()
-[n for n in myNoddys] # iterate
-"""
-
-    print "-" * 100
-    print """Creating 10000 dictionaries - MongoEngine"""
-    t = timeit.Timer(stmt=stmt, setup=setup)
-    print t.timeit(1)
-
-    stmt = """
-for i in xrange(10000):
-    noddy = Noddy()
-    fields = {}
-    for j in range(20):
-        fields["key"+str(j)] = "value "+str(j)
-    noddy.fields = fields
-    noddy.save()
-
-myNoddys = Noddy.objects()
-[n for n in myNoddys] # iterate
-"""
-
-    print "-" * 100
-    print """Creating 10000 dictionaries without continual assign - MongoEngine"""
-    t = timeit.Timer(stmt=stmt, setup=setup)
-    print t.timeit(1)
-
-    stmt = """
-for i in xrange(10000):
-    noddy = Noddy()
-    for j in range(20):
-        noddy.fields["key"+str(j)] = "value "+str(j)
-    noddy.save(write_concern={"w": 0}, cascade=True)
-
-myNoddys = Noddy.objects()
-[n for n in myNoddys] # iterate
-"""
-
-    print "-" * 100
-    print """Creating 10000 dictionaries - MongoEngine - write_concern={"w": 0}, cascade = True"""
-    t = timeit.Timer(stmt=stmt, setup=setup)
-    print t.timeit(1)
-
-    stmt = """
-for i in xrange(10000):
-    noddy = Noddy()
-    for j in range(20):
-        noddy.fields["key"+str(j)] = "value "+str(j)
-    noddy.save(write_concern={"w": 0}, validate=False, cascade=True)
-
-myNoddys = Noddy.objects()
-[n for n in myNoddys] # iterate
-"""
-
-    print "-" * 100
-    print """Creating 10000 dictionaries - MongoEngine, write_concern={"w": 0}, validate=False, cascade=True"""
-    t = timeit.Timer(stmt=stmt, setup=setup)
-    print t.timeit(1)
-
-    stmt = """
-for i in xrange(10000):
-    noddy = Noddy()
-    for j in range(20):
-        noddy.fields["key"+str(j)] = "value "+str(j)
-    noddy.save(validate=False, write_concern={"w": 0})
-
-myNoddys = Noddy.objects()
-[n for n in myNoddys] # iterate
-"""
-
-    print "-" * 100
-    print """Creating 10000 dictionaries - MongoEngine, write_concern={"w": 0}, validate=False"""
-    t = timeit.Timer(stmt=stmt, setup=setup)
-    print t.timeit(1)
-
-    stmt = """
-for i in xrange(10000):
-    noddy = Noddy()
-    for j in range(20):
-        noddy.fields["key"+str(j)] = "value "+str(j)
-    noddy.save(force_insert=True, write_concern={"w": 0}, validate=False)
-
-myNoddys = Noddy.objects()
-[n for n in myNoddys] # iterate
-"""
-
-    print "-" * 100
-    print """Creating 10000 dictionaries - MongoEngine, force_insert=True, write_concern={"w": 0}, validate=False"""
-    t = timeit.Timer(stmt=stmt, setup=setup)
-    print t.timeit(1)
-
-
-if __name__ == "__main__":
-    main()

benchmarks/test_basic_doc_ops.py

@@ -0,0 +1,148 @@
+from timeit import repeat
+
+import mongoengine
+from mongoengine import (BooleanField, Document, EmailField, EmbeddedDocument,
+                         EmbeddedDocumentField, IntField, ListField,
+                         StringField)
+
+mongoengine.connect(db='mongoengine_benchmark_test')
+
+
+def timeit(f, n=10000):
+    return min(repeat(f, repeat=3, number=n)) / float(n)
+
+
+def test_basic():
+    class Book(Document):
+        name = StringField()
+        pages = IntField()
+        tags = ListField(StringField())
+        is_published = BooleanField()
+        author_email = EmailField()
+
+    Book.drop_collection()
+
+    def init_book():
+        return Book(
+            name='Always be closing',
+            pages=100,
+            tags=['self-help', 'sales'],
+            is_published=True,
+            author_email='alec@example.com',
+        )
+
+    print('Doc initialization: %.3fus' % (timeit(init_book, 1000) * 10**6))
+
+    b = init_book()
+    print('Doc getattr: %.3fus' % (timeit(lambda: b.name, 10000) * 10**6))
+
+    print(
+        'Doc setattr: %.3fus' % (
+            timeit(lambda: setattr(b, 'name', 'New name'), 10000) * 10**6
+        )
+    )
+
+    print('Doc to mongo: %.3fus' % (timeit(b.to_mongo, 1000) * 10**6))
+
+    print('Doc validation: %.3fus' % (timeit(b.validate, 1000) * 10**6))
+
+    def save_book():
+        b._mark_as_changed('name')
+        b._mark_as_changed('tags')
+        b.save()
+
+    print('Save to database: %.3fus' % (timeit(save_book, 100) * 10**6))
+
+    son = b.to_mongo()
+    print(
+        'Load from SON: %.3fus' % (
+            timeit(lambda: Book._from_son(son), 1000) * 10**6
+        )
+    )
+
+    print(
+        'Load from database: %.3fus' % (
+            timeit(lambda: Book.objects[0], 100) * 10**6
+        )
+    )
+
+    def create_and_delete_book():
+        b = init_book()
+        b.save()
+        b.delete()
+
+    print(
+        'Init + save to database + delete: %.3fms' % (
+            timeit(create_and_delete_book, 10) * 10**3
+        )
+    )
+
+
+def test_big_doc():
+    class Contact(EmbeddedDocument):
+        name = StringField()
+        title = StringField()
+        address = StringField()
+
+    class Company(Document):
+        name = StringField()
+        contacts = ListField(EmbeddedDocumentField(Contact))
+
+    Company.drop_collection()
+
+    def init_company():
+        return Company(
+            name='MongoDB, Inc.',
+            contacts=[
+                Contact(
+                    name='Contact %d' % x,
+                    title='CEO',
+                    address='Address %d' % x,
+                )
+                for x in range(1000)
+            ]
+        )
+
+    company = init_company()
+    print('Big doc to mongo: %.3fms' % (timeit(company.to_mongo, 100) * 10**3))
+
+    print('Big doc validation: %.3fms' % (timeit(company.validate, 1000) * 10**3))
+
+    company.save()
+
+    def save_company():
+        company._mark_as_changed('name')
+        company._mark_as_changed('contacts')
+        company.save()
+
+    print('Save to database: %.3fms' % (timeit(save_company, 100) * 10**3))
+
+    son = company.to_mongo()
+    print(
+        'Load from SON: %.3fms' % (
+            timeit(lambda: Company._from_son(son), 100) * 10**3
+        )
+    )
+
+    print(
+        'Load from database: %.3fms' % (
+            timeit(lambda: Company.objects[0], 100) * 10**3
+        )
+    )
+
+    def create_and_delete_company():
+        c = init_company()
+        c.save()
+        c.delete()
+
+    print(
+        'Init + save to database + delete: %.3fms' % (
+            timeit(create_and_delete_company, 10) * 10**3
+        )
+    )
+
+
+if __name__ == '__main__':
+    test_basic()
+    print('-' * 100)
+    test_big_doc()

benchmarks/test_inserts.py

@@ -0,0 +1,154 @@
+import timeit
+
+
+def main():
+    setup = """
+from pymongo import MongoClient
+connection = MongoClient()
+connection.drop_database('mongoengine_benchmark_test')
+"""
+
+    stmt = """
+from pymongo import MongoClient
+connection = MongoClient()
+
+db = connection.mongoengine_benchmark_test
+noddy = db.noddy
+
+for i in range(10000):
+    example = {'fields': {}}
+    for j in range(20):
+        example['fields']["key"+str(j)] = "value "+str(j)
+
+    noddy.insert_one(example)
+
+myNoddys = noddy.find()
+[n for n in myNoddys]  # iterate
+"""
+
+    print('-' * 100)
+    print('PyMongo: Creating 10000 dictionaries.')
+    t = timeit.Timer(stmt=stmt, setup=setup)
+    print('{}s'.format(t.timeit(1)))
+
+    stmt = """
+from pymongo import MongoClient, WriteConcern
+connection = MongoClient()
+
+db = connection.mongoengine_benchmark_test
+noddy = db.noddy.with_options(write_concern=WriteConcern(w=0))
+
+for i in range(10000):
+    example = {'fields': {}}
+    for j in range(20):
+        example['fields']["key"+str(j)] = "value "+str(j)
+
+    noddy.insert_one(example)
+
+myNoddys = noddy.find()
+[n for n in myNoddys]  # iterate
+"""
+
+    print('-' * 100)
+    print('PyMongo: Creating 10000 dictionaries (write_concern={"w": 0}).')
+    t = timeit.Timer(stmt=stmt, setup=setup)
+    print('{}s'.format(t.timeit(1)))
+
+    setup = """
+from pymongo import MongoClient
+connection = MongoClient()
+connection.drop_database('mongoengine_benchmark_test')
+connection.close()
+
+from mongoengine import Document, DictField, connect
+connect("mongoengine_benchmark_test")
+
+class Noddy(Document):
+    fields = DictField()
+"""
+
+    stmt = """
+for i in range(10000):
+    noddy = Noddy()
+    for j in range(20):
+        noddy.fields["key"+str(j)] = "value "+str(j)
+    noddy.save()
+
+myNoddys = Noddy.objects()
+[n for n in myNoddys]  # iterate
+"""
+
+    print('-' * 100)
+    print('MongoEngine: Creating 10000 dictionaries.')
+    t = timeit.Timer(stmt=stmt, setup=setup)
+    print('{}s'.format(t.timeit(1)))
+
+    stmt = """
+for i in range(10000):
+    noddy = Noddy()
+    fields = {}
+    for j in range(20):
+        fields["key"+str(j)] = "value "+str(j)
+    noddy.fields = fields
+    noddy.save()
+
+myNoddys = Noddy.objects()
+[n for n in myNoddys]  # iterate
+"""
+
+    print('-' * 100)
+    print('MongoEngine: Creating 10000 dictionaries (using a single field assignment).')
+    t = timeit.Timer(stmt=stmt, setup=setup)
+    print('{}s'.format(t.timeit(1)))
+
+    stmt = """
+for i in range(10000):
+    noddy = Noddy()
+    for j in range(20):
+        noddy.fields["key"+str(j)] = "value "+str(j)
+    noddy.save(write_concern={"w": 0})
+
+myNoddys = Noddy.objects()
+[n for n in myNoddys] # iterate
+"""
+
+    print('-' * 100)
+    print('MongoEngine: Creating 10000 dictionaries (write_concern={"w": 0}).')
+    t = timeit.Timer(stmt=stmt, setup=setup)
+    print('{}s'.format(t.timeit(1)))
+
+    stmt = """
+for i in range(10000):
+    noddy = Noddy()
+    for j in range(20):
+        noddy.fields["key"+str(j)] = "value "+str(j)
+    noddy.save(write_concern={"w": 0}, validate=False)
+
+myNoddys = Noddy.objects()
+[n for n in myNoddys] # iterate
+"""
+
+    print('-' * 100)
+    print('MongoEngine: Creating 10000 dictionaries (write_concern={"w": 0}, validate=False).')
+    t = timeit.Timer(stmt=stmt, setup=setup)
+    print('{}s'.format(t.timeit(1)))
+
+    stmt = """
+for i in range(10000):
+    noddy = Noddy()
+    for j in range(20):
+        noddy.fields["key"+str(j)] = "value "+str(j)
+    noddy.save(force_insert=True, write_concern={"w": 0}, validate=False)
+
+myNoddys = Noddy.objects()
+[n for n in myNoddys] # iterate
+"""
+
+    print('-' * 100)
+    print('MongoEngine: Creating 10000 dictionaries (force_insert=True, write_concern={"w": 0}, validate=False).')
+    t = timeit.Timer(stmt=stmt, setup=setup)
+    print('{}s'.format(t.timeit(1)))
+
+
+if __name__ == "__main__":
+    main()

docs/_themes/nature/static/nature.css_t

@@ -1,233 +0,0 @@
-/**
- * Sphinx stylesheet -- default theme
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-@import url("basic.css");
-
-#changelog p.first {margin-bottom: 0 !important;}
-#changelog p {margin-top: 0 !important;
-              margin-bottom: 0 !important;}
-
-/* -- page layout ----------------------------------------------------------- */
-
-body {
-    font-family: Arial, sans-serif;
-    font-size: 100%;
-    background-color: #111;
-    color: #555;
-    margin: 0;
-    padding: 0;
-}
-
-div.documentwrapper {
-    float: left;
-    width: 100%;
-}
-
-div.bodywrapper {
-    margin: 0 0 0 230px;
-}
-
-hr{
-    border: 1px solid #B1B4B6;
-}
-
-div.document {
-    background-color: #eee;
-}
-
-div.body {
-    background-color: #ffffff;
-    color: #3E4349;
-    padding: 0 30px 30px 30px;
-    font-size: 0.8em;
-}
-
-div.footer {
-    color: #555;
-    width: 100%;
-    padding: 13px 0;
-    text-align: center;
-    font-size: 75%;
-}
-
-div.footer a {
-    color: #444;
-    text-decoration: underline;
-}
-
-div.related {
-    background-color: #6BA81E;
-    line-height: 32px;
-    color: #fff;
-    text-shadow: 0px 1px 0 #444;
-    font-size: 0.80em;
-}
-
-div.related a {
-    color: #E2F3CC;
-}
-
-div.sphinxsidebar {
-    font-size: 0.75em;
-    line-height: 1.5em;
-}
-
-div.sphinxsidebarwrapper{
-    padding: 20px 0;
-}
-
-div.sphinxsidebar h3,
-div.sphinxsidebar h4 {
-    font-family: Arial, sans-serif;
-    color: #222;
-    font-size: 1.2em;
-    font-weight: normal;
-    margin: 0;
-    padding: 5px 10px;
-    background-color: #ddd;
-    text-shadow: 1px 1px 0 white
-}
-
-div.sphinxsidebar h4{
-    font-size: 1.1em;
-}
-
-div.sphinxsidebar h3 a {
-    color: #444;
-}
-
-
-div.sphinxsidebar p {
-    color: #888;
-    padding: 5px 20px;
-}
-
-div.sphinxsidebar p.topless {
-}
-
-div.sphinxsidebar ul {
-    margin: 10px 20px;
-    padding: 0;
-    color: #000;
-}
-
-div.sphinxsidebar a {
-    color: #444;
-}
-
-div.sphinxsidebar input {
-    border: 1px solid #ccc;
-    font-family: sans-serif;
-    font-size: 1em;
-}
-
-div.sphinxsidebar input[type=text]{
-    margin-left: 20px;
-}
-
-/* -- body styles ----------------------------------------------------------- */
-
-a {
-    color: #005B81;
-    text-decoration: none;
-}
-
-a:hover {
-    color: #E32E00;
-    text-decoration: underline;
-}
-
-div.body h1,
-div.body h2,
-div.body h3,
-div.body h4,
-div.body h5,
-div.body h6 {
-    font-family: Arial, sans-serif;
-    background-color: #BED4EB;
-    font-weight: normal;
-    color: #212224;
-    margin: 30px 0px 10px 0px;
-    padding: 5px 0 5px 10px;
-    text-shadow: 0px 1px 0 white
-}
-
-div.body h1 { border-top: 20px solid white; margin-top: 0; font-size: 200%; }
-div.body h2 { font-size: 150%; background-color: #C8D5E3; }
-div.body h3 { font-size: 120%; background-color: #D8DEE3; }
-div.body h4 { font-size: 110%; background-color: #D8DEE3; }
-div.body h5 { font-size: 100%; background-color: #D8DEE3; }
-div.body h6 { font-size: 100%; background-color: #D8DEE3; }
-
-a.headerlink {
-    color: #c60f0f;
-    font-size: 0.8em;
-    padding: 0 4px 0 4px;
-    text-decoration: none;
-}
-
-a.headerlink:hover {
-    background-color: #c60f0f;
-    color: white;
-}
-
-div.body p, div.body dd, div.body li {
-    line-height: 1.5em;
-}
-
-div.admonition p.admonition-title + p {
-    display: inline;
-}
-
-div.highlight{
-    background-color: white;
-}
-
-div.note {
-    background-color: #eee;
-    border: 1px solid #ccc;
-}
-
-div.seealso {
-    background-color: #ffc;
-    border: 1px solid #ff6;
-}
-
-div.topic {
-    background-color: #eee;
-}
-
-div.warning {
-    background-color: #ffe4e4;
-    border: 1px solid #f66;
-}
-
-p.admonition-title {
-    display: inline;
-}
-
-p.admonition-title:after {
-    content: ":";
-}
-
-pre {
-    padding: 10px;
-    background-color: White;
-    color: #222;
-    line-height: 1.2em;
-    border: 1px solid #C6C9CB;
-    font-size: 1.2em;
-    margin: 1.5em 0 1.5em 0;
-    -webkit-box-shadow: 1px 1px 1px #d8d8d8;
-    -moz-box-shadow: 1px 1px 1px #d8d8d8;
-}
-
-tt {
-    background-color: #ecf0f3;
-    color: #222;
-    padding: 1px 2px;
-    font-size: 1.2em;
-    font-family: monospace;
-}

docs/_themes/nature/static/pygments.css

@@ -1,54 +0,0 @@
-.c { color: #999988; font-style: italic } /* Comment */
-.k { font-weight: bold } /* Keyword */
-.o { font-weight: bold } /* Operator */
-.cm { color: #999988; font-style: italic } /* Comment.Multiline */
-.cp { color: #999999; font-weight: bold } /* Comment.preproc */
-.c1 { color: #999988; font-style: italic } /* Comment.Single */
-.gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
-.ge { font-style: italic } /* Generic.Emph */
-.gr { color: #aa0000 } /* Generic.Error */
-.gh { color: #999999 } /* Generic.Heading */
-.gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
-.go { color: #111 } /* Generic.Output */
-.gp { color: #555555 } /* Generic.Prompt */
-.gs { font-weight: bold } /* Generic.Strong */
-.gu { color: #aaaaaa } /* Generic.Subheading */
-.gt { color: #aa0000 } /* Generic.Traceback */
-.kc { font-weight: bold } /* Keyword.Constant */
-.kd { font-weight: bold } /* Keyword.Declaration */
-.kp { font-weight: bold } /* Keyword.Pseudo */
-.kr { font-weight: bold } /* Keyword.Reserved */
-.kt { color: #445588; font-weight: bold } /* Keyword.Type */
-.m { color: #009999 } /* Literal.Number */
-.s { color: #bb8844 } /* Literal.String */
-.na { color: #008080 } /* Name.Attribute */
-.nb { color: #999999 } /* Name.Builtin */
-.nc { color: #445588; font-weight: bold } /* Name.Class */
-.no { color: #ff99ff } /* Name.Constant */
-.ni { color: #800080 } /* Name.Entity */
-.ne { color: #990000; font-weight: bold } /* Name.Exception */
-.nf { color: #990000; font-weight: bold } /* Name.Function */
-.nn { color: #555555 } /* Name.Namespace */
-.nt { color: #000080 } /* Name.Tag */
-.nv { color: purple } /* Name.Variable */
-.ow { font-weight: bold } /* Operator.Word */
-.mf { color: #009999 } /* Literal.Number.Float */
-.mh { color: #009999 } /* Literal.Number.Hex */
-.mi { color: #009999 } /* Literal.Number.Integer */
-.mo { color: #009999 } /* Literal.Number.Oct */
-.sb { color: #bb8844 } /* Literal.String.Backtick */
-.sc { color: #bb8844 } /* Literal.String.Char */
-.sd { color: #bb8844 } /* Literal.String.Doc */
-.s2 { color: #bb8844 } /* Literal.String.Double */
-.se { color: #bb8844 } /* Literal.String.Escape */
-.sh { color: #bb8844 } /* Literal.String.Heredoc */
-.si { color: #bb8844 } /* Literal.String.Interpol */
-.sx { color: #bb8844 } /* Literal.String.Other */
-.sr { color: #808000 } /* Literal.String.Regex */
-.s1 { color: #bb8844 } /* Literal.String.Single */
-.ss { color: #bb8844 } /* Literal.String.Symbol */
-.bp { color: #999999 } /* Name.Builtin.Pseudo */
-.vc { color: #ff99ff } /* Name.Variable.Class */
-.vg { color: #ff99ff } /* Name.Variable.Global */
-.vi { color: #ff99ff } /* Name.Variable.Instance */
-.il { color: #009999 } /* Literal.Number.Integer.Long */

docs/_themes/nature/theme.conf

@@ -1,4 +0,0 @@
-[theme]
-inherit = basic
-stylesheet = nature.css
-pygments_style = tango

docs/apireference.rst

@@ -13,6 +13,7 @@ Documents
 
 .. autoclass:: mongoengine.Document
    :members:
+   :inherited-members:
 
    .. attribute:: objects
 
@@ -21,23 +22,30 @@ Documents
 
 .. autoclass:: mongoengine.EmbeddedDocument
    :members:
+   :inherited-members:
 
 .. autoclass:: mongoengine.DynamicDocument
    :members:
+   :inherited-members:
 
 .. autoclass:: mongoengine.DynamicEmbeddedDocument
    :members:
+   :inherited-members:
 
 .. autoclass:: mongoengine.document.MapReduceDocument
-  :members:
+   :members:
 
 .. autoclass:: mongoengine.ValidationError
   :members:
 
+.. autoclass:: mongoengine.FieldDoesNotExist
+
+
 Context Managers
 ================
 
 .. autoclass:: mongoengine.context_managers.switch_db
+.. autoclass:: mongoengine.context_managers.switch_collection
 .. autoclass:: mongoengine.context_managers.no_dereference
 .. autoclass:: mongoengine.context_managers.query_counter
 
@@ -78,11 +86,15 @@ Fields
 .. autoclass:: mongoengine.fields.GenericEmbeddedDocumentField
 .. autoclass:: mongoengine.fields.DynamicField
 .. autoclass:: mongoengine.fields.ListField
+.. autoclass:: mongoengine.fields.EmbeddedDocumentListField
 .. autoclass:: mongoengine.fields.SortedListField
 .. autoclass:: mongoengine.fields.DictField
 .. autoclass:: mongoengine.fields.MapField
 .. autoclass:: mongoengine.fields.ReferenceField
+.. autoclass:: mongoengine.fields.LazyReferenceField
 .. autoclass:: mongoengine.fields.GenericReferenceField
+.. autoclass:: mongoengine.fields.GenericLazyReferenceField
+.. autoclass:: mongoengine.fields.CachedReferenceField
 .. autoclass:: mongoengine.fields.BinaryField
 .. autoclass:: mongoengine.fields.FileField
 .. autoclass:: mongoengine.fields.ImageField
@@ -93,11 +105,29 @@ Fields
 .. autoclass:: mongoengine.fields.PointField
 .. autoclass:: mongoengine.fields.LineStringField
 .. autoclass:: mongoengine.fields.PolygonField
+.. autoclass:: mongoengine.fields.MultiPointField
+.. autoclass:: mongoengine.fields.MultiLineStringField
+.. autoclass:: mongoengine.fields.MultiPolygonField
 .. autoclass:: mongoengine.fields.GridFSError
 .. autoclass:: mongoengine.fields.GridFSProxy
 .. autoclass:: mongoengine.fields.ImageGridFsProxy
 .. autoclass:: mongoengine.fields.ImproperlyConfigured
 
+Embedded Document Querying
+==========================
+
+.. versionadded:: 0.9
+
+Additional queries for Embedded Documents are available when using the
+:class:`~mongoengine.EmbeddedDocumentListField` to store a list of embedded
+documents.
+
+A list of embedded documents is returned as a special list with the
+following methods:
+
+.. autoclass:: mongoengine.base.datastructures.EmbeddedDocumentList
+    :members:
+
 Misc
 ====
 

docs/changelog.rst

@@ -1,7 +1,365 @@
+
 =========
 Changelog
 =========
 
+Development
+===========
+- (Fill this out as you fix issues and develop your features).
+
+Changes in 0.18.2
+=================
+- Replace some of the deprecated PyMongo v2.x methods with their v3.x equivalents #2097
+- Various code clarity and documentation improvements
+
+Changes in 0.18.1
+=================
+- Fix a bug introduced in 0.18.0 which was causing `.save()` to update all the fields
+    instead of updating only the modified fields. This bug only occurs when using custom pk #2082
+- Add Python 3.7 in travis #2058
+
+Changes in 0.18.0
+=================
+- Drop support for EOL'd MongoDB v2.6, v3.0, and v3.2.
+- MongoEngine now requires PyMongo >= v3.4. Travis CI now tests against MongoDB v3.4 – v3.6 and PyMongo v3.4 – v3.6 (#2017 #2066).
+- Improve performance by avoiding a call to `to_mongo` in `Document.save()` #2049
+- Connection/disconnection improvements:
+    - Expose `mongoengine.connection.disconnect` and `mongoengine.connection.disconnect_all`
+    - Fix disconnecting #566 #1599 #605 #607 #1213 #565
+    - Improve documentation of `connect`/`disconnect`
+    - Fix issue when using multiple connections to the same mongo with different credentials #2047
+    - `connect` fails immediately when db name contains invalid characters #2031 #1718
+- Fix the default write concern of `Document.save` that was overwriting the connection write concern #568
+- Fix querying on `List(EmbeddedDocument)` subclasses fields #1961 #1492
+- Fix querying on `(Generic)EmbeddedDocument` subclasses fields #475
+- Fix `QuerySet.aggregate` so that it takes limit and skip value into account #2029
+- Generate unique indices for `SortedListField` and `EmbeddedDocumentListFields` #2020
+- BREAKING CHANGE: Changed the behavior of a custom field validator (i.e `validation` parameter of a `Field`). It is now expected to raise a `ValidationError` instead of returning True/False #2050
+- BREAKING CHANGES (associated with connect/disconnect fixes):
+    - Calling `connect` 2 times with the same alias and different parameter will raise an error (should call `disconnect` first).
+    - `disconnect` now clears `mongoengine.connection._connection_settings`.
+    - `disconnect` now clears the cached attribute `Document._collection`.
+- BREAKING CHANGE: `EmbeddedDocument.save` & `.reload` is no longier exist #1552
+
+Changes in 0.17.0
+=================
+- Fix .only() working improperly after using .count() of the same instance of QuerySet
+- Fix batch_size that was not copied when cloning a queryset object #2011
+- POTENTIAL BREAKING CHANGE: All result fields are now passed, including internal fields (_cls, _id) when using `QuerySet.as_pymongo` #1976
+- Document a BREAKING CHANGE introduced in 0.15.3 and not reported at that time (#1995)
+- Fix InvalidStringData error when using modify on a BinaryField #1127
+- DEPRECATION: `EmbeddedDocument.save` & `.reload` are marked as deprecated and will be removed in a next version of mongoengine #1552
+- Fix test suite and CI to support MongoDB 3.4 #1445
+- Fix reference fields querying the database on each access if value contains orphan DBRefs
+
+=================
+Changes in 0.16.3
+=================
+- Fix $push with $position operator not working with lists in embedded document #1965
+
+=================
+Changes in 0.16.2
+=================
+- Fix .save() that fails when called with write_concern=None (regression of 0.16.1) #1958
+
+=================
+Changes in 0.16.1
+=================
+- Fix `_cls` that is not set properly in Document constructor (regression) #1950
+- Fix bug in _delta method - Update of a ListField depends on an unrelated dynamic field update #1733
+- Remove deprecated `save()` method and used `insert_one()` #1899
+
+=================
+Changes in 0.16.0
+=================
+- Various improvements to the doc
+- Improvement to code quality
+- POTENTIAL BREAKING CHANGES:
+    - EmbeddedDocumentField will no longer accept references to Document classes in its constructor #1661
+    - Get rid of the `basecls` parameter from the DictField constructor (dead code) #1876
+    - default value of ComplexDateTime is now None (and no longer the current datetime) #1368
+- Fix unhashable TypeError when referencing a Document with a compound key in an EmbeddedDocument #1685
+- Fix bug where an EmbeddedDocument with the same id as its parent would not be tracked for changes #1768
+- Fix the fact that bulk `insert()` was not setting primary keys of inserted documents instances #1919
+- Fix bug when referencing the abstract class in a ReferenceField #1920
+- Allow modification to the document made in pre_save_post_validation to be taken into account #1202
+- Replaced MongoDB 2.4 tests in CI by MongoDB 3.2 #1903
+- Fix side effects of using queryset.`no_dereference` on other documents #1677
+- Fix TypeError when using lazy django translation objects as translated choices #1879
+- Improve 2-3 codebase compatibility #1889
+- Fix the support for changing the default value of ComplexDateTime #1368
+- Improves error message in case an EmbeddedDocumentListField receives an EmbeddedDocument instance
+    instead of a list #1877
+- Fix the Decimal operator inc/dec #1517 #1320
+- Ignore killcursors queries in `query_counter` context manager #1869
+- Fix the fact that `query_counter` was modifying the initial profiling_level in case it was != 0 #1870
+- Repaired the `no_sub_classes` context manager + fix the fact that it was swallowing exceptions #1865
+- Fix index creation error that was swallowed by hasattr under python2 #1688
+- QuerySet limit function behaviour: Passing 0 as parameter will return all the documents in the cursor #1611
+- bulk insert updates the ids of the input documents instances #1919
+- Fix an harmless bug related to GenericReferenceField where modifications in the generic-referenced document
+    were tracked in the parent #1934
+- Improve validator of BinaryField #273
+- Implemented lazy regex compiling in Field classes to improve 'import mongoengine' performance #1806
+- Updated GridFSProxy.__str__  so that it would always print both the filename and grid_id #710
+- Add __repr__ to Q and QCombination #1843
+- fix bug in BaseList.__iter__ operator (was occuring when modifying a BaseList while iterating over it) #1676
+- Added field `DateField`#513
+
+Changes in 0.15.3
+=================
+-  BREAKING CHANGES: `Queryset.update/update_one` methods now returns an UpdateResult when `full_result=True` is provided and no longer a dict (relates to #1491)
+-  Subfield resolve error in generic_emdedded_document query #1651 #1652
+-  use each modifier only with $position #1673 #1675
+-  Improve LazyReferenceField and GenericLazyReferenceField with nested fields #1704
+-  Fix validation error instance in GenericEmbeddedDocumentField #1067
+-  Update cached fields when fields argument is given #1712
+-  Add a db parameter to register_connection for compatibility with connect
+-  Use insert_one, insert_many in Document.insert #1491
+-  Use new update_one, update_many on document/queryset update #1491
+-  Use insert_one, insert_many in Document.insert #1491
+-  Fix reload(fields) affect changed fields #1371
+-  Fix Read-only access to database fails when trying to create indexes #1338
+
+Changes in 0.15.0
+=================
+- Add LazyReferenceField and GenericLazyReferenceField to address #1230
+
+Changes in 0.14.1
+=================
+- Removed SemiStrictDict and started using a regular dict for `BaseDocument._data` #1630
+- Added support for the `$position` param in the `$push` operator #1566
+- Fixed `DateTimeField` interpreting an empty string as today #1533
+- Added a missing `__ne__` method to the `GridFSProxy` class #1632
+- Fixed `BaseQuerySet._fields_to_db_fields` #1553
+
+Changes in 0.14.0
+=================
+- BREAKING CHANGE: Removed the `coerce_types` param from `QuerySet.as_pymongo` #1549
+- POTENTIAL BREAKING CHANGE: Made EmbeddedDocument not hashable by default #1528
+- Improved code quality #1531, #1540, #1541, #1547
+
+Changes in 0.13.0
+=================
+- POTENTIAL BREAKING CHANGE: Added Unicode support to the `EmailField`, see
+  docs/upgrade.rst for details.
+
+Changes in 0.12.0
+=================
+- POTENTIAL BREAKING CHANGE: Fixed limit/skip/hint/batch_size chaining #1476
+- POTENTIAL BREAKING CHANGE: Changed a public `QuerySet.clone_into` method to a private `QuerySet._clone_into` #1476
+- Fixed the way `Document.objects.create` works with duplicate IDs #1485
+- Fixed connecting to a replica set with PyMongo 2.x #1436
+- Fixed using sets in field choices #1481
+- Fixed deleting items from a `ListField` #1318
+- Fixed an obscure error message when filtering by `field__in=non_iterable`. #1237
+- Fixed behavior of a `dec` update operator #1450
+- Added a `rename` update operator #1454
+- Added validation for the `db_field` parameter #1448
+- Fixed the error message displayed when querying an `EmbeddedDocumentField` by an invalid value #1440
+- Fixed the error message displayed when validating unicode URLs #1486
+- Raise an error when trying to save an abstract document #1449
+
+Changes in 0.11.0
+=================
+- BREAKING CHANGE: Renamed `ConnectionError` to `MongoEngineConnectionError` since the former is a built-in exception name in Python v3.x. #1428
+- BREAKING CHANGE: Dropped Python 2.6 support. #1428
+- BREAKING CHANGE: `from mongoengine.base import ErrorClass` won't work anymore for any error from `mongoengine.errors` (e.g. `ValidationError`). Use `from mongoengine.errors import ErrorClass instead`. #1428
+- BREAKING CHANGE: Accessing a broken reference will raise a `DoesNotExist` error. In the past it used to return `None`. #1334
+- Fixed absent rounding for DecimalField when `force_string` is set. #1103
+
+Changes in 0.10.8
+=================
+- Added support for QuerySet.batch_size (#1426)
+- Fixed query set iteration within iteration #1427
+- Fixed an issue where specifying a MongoDB URI host would override more information than it should #1421
+- Added ability to filter the generic reference field by ObjectId and DBRef #1425
+- Fixed delete cascade for models with a custom primary key field #1247
+- Added ability to specify an authentication mechanism (e.g. X.509) #1333
+- Added support for falsey primary keys (e.g. doc.pk = 0) #1354
+- Fixed QuerySet#sum/average for fields w/ explicit db_field #1417
+- Fixed filtering by embedded_doc=None #1422
+- Added support for cursor.comment #1420
+- Fixed doc.get_<field>_display #1419
+- Fixed __repr__ method of the StrictDict #1424
+- Added a deprecation warning for Python 2.6
+
+Changes in 0.10.7
+=================
+- Dropped Python 3.2 support #1390
+- Fixed the bug where dynamic doc has index inside a dict field #1278
+- Fixed: ListField minus index assignment does not work #1128
+- Fixed cascade delete mixing among collections #1224
+- Add `signal_kwargs` argument to `Document.save`, `Document.delete` and `BaseQuerySet.insert` to be passed to signals calls #1206
+- Raise `OperationError` when trying to do a `drop_collection` on document with no collection set.
+- count on ListField of EmbeddedDocumentField fails. #1187
+- Fixed long fields stored as int32 in Python 3. #1253
+- MapField now handles unicodes keys correctly. #1267
+- ListField now handles negative indicies correctly. #1270
+- Fixed AttributeError when initializing EmbeddedDocument with positional args. #681
+- Fixed no_cursor_timeout error with pymongo 3.0+ #1304
+- Replaced map-reduce based QuerySet.sum/average with aggregation-based implementations #1336
+- Fixed support for `__` to escape field names that match operators names in `update` #1351
+- Fixed BaseDocument#_mark_as_changed #1369
+- Added support for pickling QuerySet instances. #1397
+- Fixed connecting to a list of hosts #1389
+- Fixed a bug where accessing broken references wouldn't raise a DoesNotExist error #1334
+- Fixed not being able to specify use_db_field=False on ListField(EmbeddedDocumentField) instances #1218
+- Improvements to the dictionary fields docs #1383
+
+Changes in 0.10.6
+=================
+- Add support for mocking MongoEngine based on mongomock. #1151
+- Fixed not being able to run tests on Windows. #1153
+- Allow creation of sparse compound indexes. #1114
+- count on ListField of EmbeddedDocumentField fails. #1187
+
+Changes in 0.10.5
+=================
+- Fix for reloading of strict with special fields. #1156
+
+Changes in 0.10.4
+=================
+- SaveConditionError is now importable from the top level package. #1165
+- upsert_one method added. #1157
+
+Changes in 0.10.3
+=================
+- Fix `read_preference` (it had chaining issues with PyMongo 2.x and it didn't work at all with PyMongo 3.x) #1042
+
+Changes in 0.10.2
+=================
+- Allow shard key to point to a field in an embedded document. #551
+- Allow arbirary metadata in fields. #1129
+- ReferenceFields now support abstract document types. #837
+
+Changes in 0.10.1
+=================
+- Fix infinite recursion with CASCADE delete rules under specific conditions. #1046
+- Fix CachedReferenceField bug when loading cached docs as DBRef but failing to save them. #1047
+- Fix ignored chained options #842
+- Document save's save_condition error raises `SaveConditionError` exception #1070
+- Fix Document.reload for DynamicDocument. #1050
+- StrictDict & SemiStrictDict are shadowed at init time. #1105
+- Fix ListField minus index assignment does not work. #1119
+- Remove code that marks field as changed when the field has default but not existed in database #1126
+- Remove test dependencies (nose and rednose) from install dependencies list. #1079
+- Recursively build query when using elemMatch operator. #1130
+- Fix instance back references for lists of embedded documents. #1131
+
+Changes in 0.10.0
+=================
+- Django support was removed and will be available as a separate extension. #958
+- Allow to load undeclared field with meta attribute 'strict': False #957
+- Support for PyMongo 3+ #946
+- Removed get_or_create() deprecated since 0.8.0. #300
+- Improve Document._created status when switch collection and db #1020
+- Queryset update doesn't go through field validation #453
+- Added support for specifying authentication source as option `authSource` in URI. #967
+- Fixed mark_as_changed to handle higher/lower level fields changed. #927
+- ListField of embedded docs doesn't set the _instance attribute when iterating over it #914
+- Support += and *= for ListField #595
+- Use sets for populating dbrefs to dereference
+- Fixed unpickled documents replacing the global field's list. #888
+- Fixed storage of microseconds in ComplexDateTimeField and unused separator option. #910
+- Don't send a "cls" option to ensureIndex (related to https://jira.mongodb.org/browse/SERVER-769)
+- Fix for updating sorting in SortedListField. #978
+- Added __ support to escape field name in fields lookup keywords that match operators names #949
+- Fix for issue where FileField deletion did not free space in GridFS.
+- No_dereference() not respected on embedded docs containing reference. #517
+- Document save raise an exception if save_condition fails #1005
+- Fixes some internal _id handling issue. #961
+- Updated URL and Email Field regex validators, added schemes argument to URLField validation. #652
+- Capped collection multiple of 256. #1011
+- Added `BaseQuerySet.aggregate_sum` and `BaseQuerySet.aggregate_average` methods.
+- Fix for delete with write_concern {'w': 0}. #1008
+- Allow dynamic lookup for more than two parts. #882
+- Added support for min_distance on geo queries. #831
+- Allow to add custom metadata to fields #705
+
+Changes in 0.9.0
+================
+- Update FileField when creating a new file #714
+- Added `EmbeddedDocumentListField` for Lists of Embedded Documents. #826
+- ComplexDateTimeField should fall back to None when null=True #864
+- Request Support for $min, $max Field update operators #863
+- `BaseDict` does not follow `setdefault` #866
+- Add support for $type operator # 766
+- Fix tests for pymongo 2.8+ #877
+- No module named 'django.utils.importlib' (Django dev) #872
+- Field Choices Now Accept Subclasses of Documents
+- Ensure Indexes before Each Save #812
+- Generate Unique Indices for Lists of EmbeddedDocuments #358
+- Sparse fields #515
+- write_concern not in params of Collection#remove #801
+- Better BaseDocument equality check when not saved #798
+- OperationError: Shard Keys are immutable. Tried to update id even though the document is not yet saved #771
+- with_limit_and_skip for count should default like in pymongo #759
+- Fix storing value of precision attribute in DecimalField #787
+- Set attribute to None does not work (at least for fields with default values) #734
+- Querying by a field defined in a subclass raises InvalidQueryError #744
+- Add Support For MongoDB 2.6.X's maxTimeMS #778
+- abstract shouldn't be inherited in EmbeddedDocument # 789
+- Allow specifying the '_cls' as a field for indexes #397
+- Stop ensure_indexes running on a secondaries unless connection is through mongos #746
+- Not overriding default values when loading a subset of fields #399
+- Saving document doesn't create new fields in existing collection #620
+- Added `Queryset.aggregate` wrapper to aggregation framework #703
+- Added support to show original model fields on to_json calls instead of db_field #697
+- Added Queryset.search_text to Text indexes searchs #700
+- Fixed tests for Django 1.7 #696
+- Follow ReferenceFields in EmbeddedDocuments with select_related #690
+- Added preliminary support for text indexes #680
+- Added `elemMatch` operator as well - `match` is too obscure #653
+- Added support for progressive JPEG #486 #548
+- Allow strings to be used in index creation #675
+- Fixed EmbeddedDoc weakref proxy issue #592
+- Fixed nested reference field distinct error #583
+- Fixed change tracking on nested MapFields #539
+- Dynamic fields in embedded documents now visible to queryset.only() / qs.exclude() #425 #507
+- Add authentication_source option to register_connection #178 #464 #573 #580 #590
+- Implemented equality between Documents and DBRefs #597
+- Fixed ReferenceField inside nested ListFields dereferencing problem #368
+- Added the ability to reload specific document fields #100
+- Added db_alias support and fixes for custom map/reduce output #586
+- post_save signal now has access to delta information about field changes #594 #589
+- Don't query with $orderby for qs.get() #600
+- Fix id shard key save issue #636
+- Fixes issue with recursive embedded document errors #557
+- Fix clear_changed_fields() clearing unsaved documents bug #602
+- Removing support for Django 1.4.x, pymongo 2.5.x, pymongo 2.6.x.
+- Removing support for Python < 2.6.6
+- Fixed $maxDistance location for geoJSON $near queries with MongoDB 2.6+ #664
+- QuerySet.modify() and Document.modify() methods to provide find_and_modify() like behaviour #677 #773
+- Added support for the using() method on a queryset #676
+- PYPY support #673
+- Connection pooling #674
+- Avoid to open all documents from cursors in an if stmt #655
+- Ability to clear the ordering #657
+- Raise NotUniqueError in Document.update() on pymongo.errors.DuplicateKeyError #626
+- Slots - memory improvements #625
+- Fixed incorrectly split a query key when it ends with "_" #619
+- Geo docs updates #613
+- Workaround a dateutil bug #608
+- Conditional save for atomic-style operations #511
+- Allow dynamic dictionary-style field access #559
+- Increase email field length to accommodate new TLDs #726
+- index_cls is ignored when deciding to set _cls as index prefix #733
+- Make 'db' argument to connection optional #737
+- Allow atomic update for the entire `DictField` #742
+- Added MultiPointField, MultiLineField, MultiPolygonField
+- Fix multiple connections aliases being rewritten #748
+- Fixed a few instances where reverse_delete_rule was written as reverse_delete_rules. #791
+- Make `in_bulk()` respect `no_dereference()` #775
+- Handle None from model __str__; Fixes #753 #754
+- _get_changed_fields fix for embedded documents with id field. #925
+
+Changes in 0.8.7
+================
+- Calling reload on deleted / nonexistent documents raises DoesNotExist (#538)
+- Stop ensure_indexes running on a secondaries (#555)
+- Fix circular import issue with django auth (#531) (#545)
+
 Changes in 0.8.6
 ================
 - Fix django auth import (#531)
@@ -11,7 +369,7 @@ Changes in 0.8.5
 - Fix multi level nested fields getting marked as changed (#523)
 - Django 1.6 login fix (#522) (#527)
 - Django 1.6 session fix (#509)
-- EmbeddedDocument._instance is now set when settng the attribute (#506)
+- EmbeddedDocument._instance is now set when setting the attribute (#506)
 - Fixed EmbeddedDocument with ReferenceField equality issue (#502)
 - Fixed GenericReferenceField serialization order (#499)
 - Fixed count and none bug (#498)
@@ -101,7 +459,7 @@ Changes in 0.8.0
 - Added `get_next_value` preview for SequenceFields (#319)
 - Added no_sub_classes context manager and queryset helper (#312)
 - Querysets now utilises a local cache
-- Changed __len__ behavour in the queryset (#247, #311)
+- Changed __len__ behaviour in the queryset (#247, #311)
 - Fixed querying string versions of ObjectIds issue with ReferenceField (#307)
 - Added $setOnInsert support for upserts (#308)
 - Upserts now possible with just query parameters (#309)
@@ -152,7 +510,7 @@ Changes in 0.8.0
 - Uses getlasterror to test created on updated saves (#163)
 - Fixed inheritance and unique index creation (#140)
 - Fixed reverse delete rule with inheritance (#197)
-- Fixed validation for GenericReferences which havent been dereferenced
+- Fixed validation for GenericReferences which haven't been dereferenced
 - Added switch_db context manager (#106)
 - Added switch_db method to document instances (#106)
 - Added no_dereference context manager (#82) (#61)
@@ -234,11 +592,11 @@ Changes in 0.7.2
 - Update index spec generation so its not destructive (#113)
 
 Changes in 0.7.1
-=================
+================
 - Fixed index spec inheritance (#111)
 
 Changes in 0.7.0
-=================
+================
 - Updated queryset.delete so you can use with skip / limit (#107)
 - Updated index creation allows kwargs to be passed through refs (#104)
 - Fixed Q object merge edge case (#109)
@@ -319,7 +677,7 @@ Changes in 0.6.12
 - Fixes error with _delta handling DBRefs
 
 Changes in 0.6.11
-==================
+=================
 - Fixed inconsistency handling None values field attrs
 - Fixed map_field embedded db_field issue
 - Fixed .save() _delta issue with DbRefs
@@ -399,7 +757,7 @@ Changes in 0.6.1
 - Fix for replicaSet connections
 
 Changes in 0.6
-================
+==============
 
 - Added FutureWarning to inherited classes not declaring 'allow_inheritance' as the default will change in 0.7
 - Added support for covered indexes when inheritance is off
@@ -487,8 +845,8 @@ Changes in v0.5
 - Updated default collection naming convention
 - Added Document Mixin support
 - Fixed queryet __repr__ mid iteration
-- Added hint() support, so cantell Mongo the proper index to use for the query
-- Fixed issue with inconsitent setting of _cls breaking inherited referencing
+- Added hint() support, so can tell Mongo the proper index to use for the query
+- Fixed issue with inconsistent setting of _cls breaking inherited referencing
 - Added help_text and verbose_name to fields to help with some form libs
 - Updated item_frequencies to handle embedded document lookups
 - Added delta tracking now only sets / unsets explicitly changed fields

docs/code/tumblelog.py

@@ -17,6 +17,10 @@ class Post(Document):
     tags = ListField(StringField(max_length=30))
     comments = ListField(EmbeddedDocumentField(Comment))
 
+    # bugfix
+    meta = {'allow_inheritance': True}
+
+
 class TextPost(Post):
     content = StringField()
 
@@ -41,26 +45,27 @@ post2.link_url = 'http://tractiondigital.com/labs/mongoengine/docs'
 post2.tags = ['mongoengine']
 post2.save()
 
-print 'ALL POSTS'
-print
+print('ALL POSTS')
+print()
 for post in Post.objects:
-    print post.title
-    print '=' * post.title.count()
+    print(post.title)
+    #print '=' * post.title.count()
+    print("=" * 20)
 
     if isinstance(post, TextPost):
-        print post.content
+        print(post.content)
 
     if isinstance(post, LinkPost):
-        print 'Link:', post.link_url
+        print('Link:', post.link_url)
 
-    print
-print
+    print()
+print()
 
-print 'POSTS TAGGED \'MONGODB\''
-print
+print('POSTS TAGGED \'MONGODB\'')
+print()
 for post in Post.objects(tags='mongodb'):
-    print post.title
-print
+    print(post.title)
+print()
 
 num_posts = Post.objects(tags='mongodb').count()
-print 'Found %d posts with tag "mongodb"' % num_posts
+print('Found %d posts with tag "mongodb"' % num_posts)

docs/conf.py

@@ -13,6 +13,10 @@
 
 import sys, os
 
+import sphinx_rtd_theme
+
+import mongoengine
+
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
@@ -44,7 +48,6 @@ copyright = u'2009, MongoEngine Authors'
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
-import mongoengine
 # The short X.Y version.
 version = mongoengine.get_version()
 # The full version, including alpha/beta/rc tags.
@@ -92,15 +95,17 @@ pygments_style = 'sphinx'
 
 # The theme to use for HTML and HTML Help pages.  Major themes that come with
 # Sphinx are currently 'default' and 'sphinxdoc'.
-html_theme = 'nature'
+html_theme = 'sphinx_rtd_theme'
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-#html_theme_options = {}
+html_theme_options = {
+    'canonical_url': 'http://docs.mongoengine.org/en/latest/'
+}
 
 # Add any paths that contain custom themes here, relative to this directory.
-html_theme_path = ['_themes']
+html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
@@ -116,7 +121,7 @@ html_theme_path = ['_themes']
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-#html_favicon = None
+html_favicon = "favicon.ico"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
@@ -199,4 +204,3 @@ latex_documents = [
 #latex_use_modindex = True
 
 autoclass_content = 'both'
-

docs/django.rst

@@ -2,176 +2,18 @@
 Django Support
 ==============
 
-.. note:: Updated to support Django 1.5
-
-Connecting
-==========
-In your **settings.py** file, ignore the standard database settings (unless you
-also plan to use the ORM in your project), and instead call
-:func:`~mongoengine.connect` somewhere in the settings module.
-
-.. note::
-   If you are not using another Database backend you may need to add a dummy
-   database backend to ``settings.py`` eg::
-
-        DATABASES = {
-            'default': {
-                'ENGINE': 'django.db.backends.dummy'
-            }
-        }
-
-Authentication
-==============
-MongoEngine includes a Django authentication backend, which uses MongoDB. The
-:class:`~mongoengine.django.auth.User` model is a MongoEngine
-:class:`~mongoengine.Document`, but implements most of the methods and
-attributes that the standard Django :class:`User` model does - so the two are
-moderately compatible. Using this backend will allow you to store users in
-MongoDB but still use many of the Django authentication infrastructure (such as
-the :func:`login_required` decorator and the :func:`authenticate` function). To
-enable the MongoEngine auth backend, add the following to your **settings.py**
-file::
-
-    AUTHENTICATION_BACKENDS = (
-        'mongoengine.django.auth.MongoEngineBackend',
-    )
-
-The :mod:`~mongoengine.django.auth` module also contains a
-:func:`~mongoengine.django.auth.get_user` helper function, that takes a user's
-:attr:`id` and returns a :class:`~mongoengine.django.auth.User` object.
-
-.. versionadded:: 0.1.3
-
-Custom User model
-=================
-Django 1.5 introduced `Custom user Models
-<https://docs.djangoproject.com/en/dev/topics/auth/customizing/#auth-custom-user>`_
-which can be used as an alternative to the MongoEngine authentication backend.
-
-The main advantage of this option is that other components relying on
-:mod:`django.contrib.auth` and supporting the new swappable user model are more
-likely to work. For example, you can use the ``createsuperuser`` management
-command as usual.
-
-To enable the custom User model in Django, add ``'mongoengine.django.mongo_auth'``
-in your ``INSTALLED_APPS`` and set ``'mongo_auth.MongoUser'`` as the custom user
-user model to use. In your **settings.py** file you will have::
-
-    INSTALLED_APPS = (
-        ...
-        'django.contrib.auth',
-        'mongoengine.django.mongo_auth',
-        ...
-    )
-
-    AUTH_USER_MODEL = 'mongo_auth.MongoUser'
-
-An additional ``MONGOENGINE_USER_DOCUMENT`` setting enables you to replace the
-:class:`~mongoengine.django.auth.User` class with another class of your choice::
-
-    MONGOENGINE_USER_DOCUMENT = 'mongoengine.django.auth.User'
-
-The custom :class:`User` must be a :class:`~mongoengine.Document` class, but
-otherwise has the same requirements as a standard custom user model,
-as specified in the `Django Documentation
-<https://docs.djangoproject.com/en/dev/topics/auth/customizing/>`_.
-In particular, the custom class must define :attr:`USERNAME_FIELD` and
-:attr:`REQUIRED_FIELDS` attributes.
-
-Sessions
-========
-Django allows the use of different backend stores for its sessions. MongoEngine
-provides a MongoDB-based session backend for Django, which allows you to use
-sessions in your Django application with just MongoDB. To enable the MongoEngine
-session backend, ensure that your settings module has
-``'django.contrib.sessions.middleware.SessionMiddleware'`` in the
-``MIDDLEWARE_CLASSES`` field  and ``'django.contrib.sessions'`` in your
-``INSTALLED_APPS``. From there, all you need to do is add the following line
-into your settings module::
-
-    SESSION_ENGINE = 'mongoengine.django.sessions'
-    SESSION_SERIALIZER = 'mongoengine.django.sessions.BSONSerializer'
-
-Django provides session cookie, which expires after ```SESSION_COOKIE_AGE``` seconds, but doesn't delete cookie at sessions backend, so ``'mongoengine.django.sessions'`` supports  `mongodb TTL
-<http://docs.mongodb.org/manual/tutorial/expire-data/>`_.
-
-.. note:: ``SESSION_SERIALIZER`` is only necessary in Django 1.6 as the default
-   serializer is based around JSON and doesn't know how to convert
-   ``bson.objectid.ObjectId`` instances to strings.
-
-.. versionadded:: 0.2.1
-
-Storage
-=======
-With MongoEngine's support for GridFS via the :class:`~mongoengine.fields.FileField`,
-it is useful to have a Django file storage backend that wraps this. The new
-storage module is called :class:`~mongoengine.django.storage.GridFSStorage`.
-Using it is very similar to using the default FileSystemStorage.::
-
-    from mongoengine.django.storage import GridFSStorage
-    fs = GridFSStorage()
-
-    filename = fs.save('hello.txt', 'Hello, World!')
-
-All of the `Django Storage API methods
-<http://docs.djangoproject.com/en/dev/ref/files/storage/>`_ have been
-implemented except :func:`path`. If the filename provided already exists, an
-underscore and a number (before # the file extension, if one exists) will be
-appended to the filename until the generated filename doesn't exist. The
-:func:`save` method will return the new filename.::
-
-    >>> fs.exists('hello.txt')
-    True
-    >>> fs.open('hello.txt').read()
-    'Hello, World!'
-    >>> fs.size('hello.txt')
-    13
-    >>> fs.url('hello.txt')
-    'http://your_media_url/hello.txt'
-    >>> fs.open('hello.txt').name
-    'hello.txt'
-    >>> fs.listdir()
-    ([], [u'hello.txt'])
-
-All files will be saved and retrieved in GridFS via the :class:`FileDocument`
-document, allowing easy access to the files without the GridFSStorage
-backend.::
-
-    >>> from mongoengine.django.storage import FileDocument
-    >>> FileDocument.objects()
-    [<FileDocument: FileDocument object>]
-
-.. versionadded:: 0.4
-
-Shortcuts
-=========
-Inspired by the `Django shortcut get_object_or_404
-<https://docs.djangoproject.com/en/dev/topics/http/shortcuts/#get-object-or-404>`_,
-the :func:`~mongoengine.django.shortcuts.get_document_or_404` method returns 
-a document or raises an Http404 exception if the document does not exist::
-
-    from mongoengine.django.shortcuts import get_document_or_404
-    
-    admin_user = get_document_or_404(User, username='root')
-
-The first argument may be a Document or QuerySet object. All other passed arguments
-and keyword arguments are used in the query::
-
-    foo_email = get_document_or_404(User.objects.only('email'), username='foo', is_active=True).email
-
-.. note:: Like with :func:`get`, a MultipleObjectsReturned will be raised if more than one
-    object is found.
+.. note:: Django support has been split from the main MongoEngine
+    repository. The *legacy* Django extension may be found bundled with the
+    0.9 release of MongoEngine.
 
 
-Also inspired by the `Django shortcut get_list_or_404
-<https://docs.djangoproject.com/en/dev/topics/http/shortcuts/#get-list-or-404>`_,
-the :func:`~mongoengine.django.shortcuts.get_list_or_404` method returns a list of
-documents or raises an Http404 exception if the list is empty::
 
-    from mongoengine.django.shortcuts import get_list_or_404
-    
-    active_users = get_list_or_404(User, is_active=True)
-
-The first argument may be a Document or QuerySet object. All other passed
-arguments and keyword arguments are used to filter the query.
+Help Wanted!
+------------
 
+The MongoEngine team is looking for help contributing and maintaining a new
+Django extension for MongoEngine! If you have Django experience and would like
+to help contribute to the project, please get in touch on the 
+`mailing list <http://groups.google.com/group/mongoengine-users>`_ or by 
+simply contributing on
+`GitHub <https://github.com/MongoEngine/django-mongoengine>`_.

docs/guide/connecting.rst

@@ -4,9 +4,11 @@
 Connecting to MongoDB
 =====================
 
-To connect to a running instance of :program:`mongod`, use the
-:func:`~mongoengine.connect` function. The first argument is the name of the
-database to connect to::
+Connections in MongoEngine are registered globally and are identified with aliases.
+If no `alias` is provided during the connection, it will use "default" as alias.
+
+To connect to a running instance of :program:`mongod`, use the :func:`~mongoengine.connect`
+function. The first argument is the name of the database to connect to::
 
     from mongoengine import connect
     connect('project1')
@@ -18,26 +20,45 @@ provide the :attr:`host` and :attr:`port` arguments to
 
     connect('project1', host='192.168.1.35', port=12345)
 
-If the database requires authentication, :attr:`username` and :attr:`password`
-arguments should be provided::
+If the database requires authentication, :attr:`username`, :attr:`password`
+and :attr:`authentication_source` arguments should be provided::
 
-    connect('project1', username='webapp', password='pwd123')
+    connect('project1', username='webapp', password='pwd123', authentication_source='admin')
 
-Uri style connections are also supported - just supply the uri as
+URI style connections are also supported -- just supply the URI as
 the :attr:`host` to
 :func:`~mongoengine.connect`::
 
     connect('project1', host='mongodb://localhost/database_name')
 
-Note that database name from uri has priority over name
-in ::func:`~mongoengine.connect`
+.. note:: Database, username and password from URI string overrides
+    corresponding parameters in :func:`~mongoengine.connect`: ::
 
-ReplicaSets
-===========
+        connect(
+            db='test',
+            username='user',
+            password='12345',
+            host='mongodb://admin:qwerty@localhost/production'
+        )
 
-MongoEngine supports :class:`~pymongo.mongo_replica_set_client.MongoReplicaSetClient`
-to use them please use a URI style connection and provide the `replicaSet` name in the
-connection kwargs.
+    will establish connection to ``production`` database using
+    ``admin`` username and ``qwerty`` password.
+
+.. note:: Calling :func:`~mongoengine.connect` without argument will establish
+    a connection to the "test" database by default
+
+Replica Sets
+============
+
+MongoEngine supports connecting to replica sets::
+
+    from mongoengine import connect
+
+    # Regular connect
+    connect('dbname', replicaset='rs-name')
+
+    # MongoDB URI-style connect
+    connect(host='mongodb://localhost/dbname?replicaSet=rs-name')
 
 Read preferences are supported through the connection or via individual
 queries by passing the read_preference ::
@@ -48,55 +69,109 @@ queries by passing the read_preference ::
 Multiple Databases
 ==================
 
-Multiple database support was added in MongoEngine 0.6. To use multiple
-databases you can use :func:`~mongoengine.connect` and provide an `alias` name
-for the connection - if no `alias` is provided then "default" is used.
+To use multiple databases you can use :func:`~mongoengine.connect` and provide
+an `alias` name for the connection - if no `alias` is provided then "default"
+is used.
 
 In the background this uses :func:`~mongoengine.register_connection` to
 store the data and you can register all aliases up front if required.
 
-Individual documents can also support multiple databases by providing a
-`db_alias` in their meta data.  This allows :class:`~pymongo.dbref.DBRef` objects
-to point across databases and collections.  Below is an example schema, using
-3 different databases to store data::
+Documents defined in different database
+---------------------------------------
+Individual documents can be attached to different databases by providing a
+`db_alias` in their meta data. This allows :class:`~pymongo.dbref.DBRef`
+objects to point across databases and collections. Below is an example schema,
+using 3 different databases to store data::
+
+        connect(alias='user-db-alias', db='user-db')
+        connect(alias='book-db-alias', db='book-db')
+        connect(alias='users-books-db-alias', db='users-books-db')
         
         class User(Document):
             name = StringField()
 
-            meta = {"db_alias": "user-db"}
+            meta = {'db_alias': 'user-db-alias'}
 
         class Book(Document):
             name = StringField()
 
-            meta = {"db_alias": "book-db"}
+            meta = {'db_alias': 'book-db-alias'}
 
         class AuthorBooks(Document):
             author = ReferenceField(User)
             book = ReferenceField(Book)
 
-            meta = {"db_alias": "users-books-db"}
+            meta = {'db_alias': 'users-books-db-alias'}
 
 
-Switch Database Context Manager
-===============================
+Disconnecting an existing connection
+------------------------------------
+The function :func:`~mongoengine.disconnect` can be used to
+disconnect a particular connection. This can be used to change a
+connection globally::
 
-Sometimes you may want to switch the database to query against for a class
-for example, archiving older data into a separate database for performance
-reasons.
+        from mongoengine import connect, disconnect
+        connect('a_db', alias='db1')
 
+        class User(Document):
+            name = StringField()
+            meta = {'db_alias': 'db1'}
+
+        disconnect(alias='db1')
+
+        connect('another_db', alias='db1')
+
+.. note:: Calling :func:`~mongoengine.disconnect` without argument
+    will disconnect the "default" connection
+
+.. note:: Since connections gets registered globally, it is important
+    to use the `disconnect` function from MongoEngine and not the
+    `disconnect()` method of an existing connection (pymongo.MongoClient)
+
+.. note:: :class:`~mongoengine.Document` are caching the pymongo collection.
+    using `disconnect` ensures that it gets cleaned as well
+
+Context Managers
+================
+Sometimes you may want to switch the database or collection to query against.
+For example, archiving older data into a separate database for performance
+reasons or writing functions that dynamically choose collections to write
+a document to.
+
+Switch Database
+---------------
 The :class:`~mongoengine.context_managers.switch_db` context manager allows
 you to change the database alias for a given class allowing quick and easy
 access to the same User document across databases::
 
-        from mongoengine.context_managers import switch_db
+    from mongoengine.context_managers import switch_db
 
-        class User(Document):
+    class User(Document):
+        name = StringField()
+
+        meta = {'db_alias': 'user-db'}
+
+    with switch_db(User, 'archive-user-db') as User:
+        User(name='Ross').save()  # Saves the 'archive-user-db'
+
+
+Switch Collection
+-----------------
+The :func:`~mongoengine.context_managers.switch_collection` context manager
+allows you to change the collection for a given class allowing quick and easy
+access to the same Group document across collection::
+
+        from mongoengine.context_managers import switch_collection
+
+        class Group(Document):
             name = StringField()
 
-            meta = {"db_alias": "user-db"}
+        Group(name='test').save()  # Saves in the default db
+
+        with switch_collection(Group, 'group2000') as Group:
+            Group(name='hello Group 2000 collection!').save()  # Saves in group2000 collection
 
-        with switch_db(User, 'archive-user-db') as User:
-            User(name="Ross").save()  # Saves the 'archive-user-db'
 
 .. note:: Make sure any aliases have been registered with
-    :func:`~mongoengine.register_connection` before using the context manager.
+    :func:`~mongoengine.register_connection` or :func:`~mongoengine.connect`
+    before using the context manager.

docs/guide/defining-documents.rst

@@ -4,7 +4,7 @@ Defining documents
 In MongoDB, a **document** is roughly equivalent to a **row** in an RDBMS. When
 working with relational databases, rows are stored in **tables**, which have a
 strict **schema** that the rows follow. MongoDB stores documents in
-**collections** rather than tables - the principle difference is that no schema
+**collections** rather than tables --- the principal difference is that no schema
 is enforced at a database level.
 
 Defining a document's schema
@@ -22,14 +22,14 @@ objects** as class attributes to the document class::
 
     class Page(Document):
         title = StringField(max_length=200, required=True)
-        date_modified = DateTimeField(default=datetime.datetime.now)
+        date_modified = DateTimeField(default=datetime.datetime.utcnow)
 
 As BSON (the binary format for storing data in mongodb) is order dependent,
 documents are serialized based on their field order.
 
 Dynamic document schemas
 ========================
-One of the benefits of MongoDb is dynamic schemas for a collection, whilst data
+One of the benefits of MongoDB is dynamic schemas for a collection, whilst data
 should be planned and organised (after all explicit is better than implicit!)
 there are scenarios where having dynamic / expando style documents is desirable.
 
@@ -75,22 +75,32 @@ are as follows:
 * :class:`~mongoengine.fields.DynamicField`
 * :class:`~mongoengine.fields.EmailField`
 * :class:`~mongoengine.fields.EmbeddedDocumentField`
+* :class:`~mongoengine.fields.EmbeddedDocumentListField`
 * :class:`~mongoengine.fields.FileField`
 * :class:`~mongoengine.fields.FloatField`
 * :class:`~mongoengine.fields.GenericEmbeddedDocumentField`
 * :class:`~mongoengine.fields.GenericReferenceField`
+* :class:`~mongoengine.fields.GenericLazyReferenceField`
 * :class:`~mongoengine.fields.GeoPointField`
 * :class:`~mongoengine.fields.ImageField`
 * :class:`~mongoengine.fields.IntField`
 * :class:`~mongoengine.fields.ListField`
+* :class:`~mongoengine.fields.LongField`
 * :class:`~mongoengine.fields.MapField`
 * :class:`~mongoengine.fields.ObjectIdField`
 * :class:`~mongoengine.fields.ReferenceField`
+* :class:`~mongoengine.fields.LazyReferenceField`
 * :class:`~mongoengine.fields.SequenceField`
 * :class:`~mongoengine.fields.SortedListField`
 * :class:`~mongoengine.fields.StringField`
 * :class:`~mongoengine.fields.URLField`
 * :class:`~mongoengine.fields.UUIDField`
+* :class:`~mongoengine.fields.PointField`
+* :class:`~mongoengine.fields.LineStringField`
+* :class:`~mongoengine.fields.PolygonField`
+* :class:`~mongoengine.fields.MultiPointField`
+* :class:`~mongoengine.fields.MultiLineStringField`
+* :class:`~mongoengine.fields.MultiPolygonField`
 
 Field arguments
 ---------------
@@ -108,7 +118,7 @@ arguments can be set on all fields:
 :attr:`default` (Default: None)
     A value to use when no value is set for this field.
 
-    The definion of default parameters follow `the general rules on Python
+    The definition of default parameters follow `the general rules on Python
     <http://docs.python.org/reference/compound_stmts.html#function-definitions>`__,
     which means that some care should be taken when dealing with default mutable objects
     (like in :class:`~mongoengine.fields.ListField` or :class:`~mongoengine.fields.DictField`)::
@@ -140,11 +150,13 @@ arguments can be set on all fields:
     When True, use this field as a primary key for the collection.  `DictField`
     and `EmbeddedDocuments` both support being the primary key for a document.
 
+    .. note:: If set, this field is also accessible through the `pk` field.
+
 :attr:`choices` (Default: None)
-    An iterable (e.g. a list or tuple) of choices to which the value of this
+    An iterable (e.g. list, tuple or set) of choices to which the value of this
     field should be limited.
 
-    Can be either be a nested tuples of value (stored in mongo) and a
+    Can either be nested tuples of value (stored in mongo) and a
     human readable key ::
 
         SIZE = (('S', 'Small'),
@@ -164,16 +176,31 @@ arguments can be set on all fields:
         class Shirt(Document):
             size = StringField(max_length=3, choices=SIZE)
 
-:attr:`help_text` (Default: None)
-    Optional help text to output with the field - used by form libraries
+:attr:`validation` (Optional)
+    A callable to validate the value of the field.
+    The callable takes the value as parameter and should raise a ValidationError
+    if validation fails
 
-:attr:`verbose_name` (Default: None)
-    Optional human-readable name for the field - used by form libraries
+    e.g ::
+
+        def _not_empty(val):
+            if not val:
+                raise ValidationError('value can not be empty')
+
+        class Person(Document):
+            name = StringField(validation=_not_empty)
+
+
+:attr:`**kwargs` (Optional)
+    You can supply additional metadata as arbitrary additional keyword
+    arguments.  You can not override existing attributes, however.  Common
+    choices include `help_text` and `verbose_name`, commonly used by form and
+    widget libraries.
 
 
 List fields
 -----------
-MongoDB allows the storage of lists of items. To add a list of items to a
+MongoDB allows storing lists of items. To add a list of items to a
 :class:`~mongoengine.Document`, use the :class:`~mongoengine.fields.ListField` field
 type. :class:`~mongoengine.fields.ListField` takes another field object as its first
 argument, which specifies which type elements may be stored within the list::
@@ -205,9 +232,9 @@ document class as the first argument::
 
 Dictionary Fields
 -----------------
-Often, an embedded document may be used instead of a dictionary -- generally
-this is recommended as dictionaries don't support validation or custom field
-types. However, sometimes you will not know the structure of what you want to
+Often, an embedded document may be used instead of a dictionary – generally
+embedded documents are recommended as dictionaries don’t support validation
+or custom field types. However, sometimes you will not know the structure of what you want to
 store; in this situation a :class:`~mongoengine.fields.DictField` is appropriate::
 
     class SurveyResponse(Document):
@@ -215,7 +242,7 @@ store; in this situation a :class:`~mongoengine.fields.DictField` is appropriate
         user = ReferenceField(User)
         answers = DictField()
 
-    survey_response = SurveyResponse(date=datetime.now(), user=request.user)
+    survey_response = SurveyResponse(date=datetime.utcnow(), user=request.user)
     response_form = ResponseForm(request.POST)
     survey_response.answers = response_form.cleaned_data()
     survey_response.save()
@@ -307,12 +334,12 @@ reference with a delete rule specification.  A delete rule is specified by
 supplying the :attr:`reverse_delete_rule` attributes on the
 :class:`ReferenceField` definition, like this::
 
-    class Employee(Document):
+    class ProfilePage(Document):
         ...
-        profile_page = ReferenceField('ProfilePage', reverse_delete_rule=mongoengine.NULLIFY)
+        employee = ReferenceField('Employee', reverse_delete_rule=mongoengine.CASCADE)
 
 The declaration in this example means that when an :class:`Employee` object is
-removed, the :class:`ProfilePage` that belongs to that employee is removed as
+removed, the :class:`ProfilePage` that references that employee is removed as
 well.  If a whole batch of employees is removed, all profile pages that are
 linked are removed as well.
 
@@ -328,7 +355,7 @@ Its value can take any of the following constants:
   Any object's fields still referring to the object being deleted are removed
   (using MongoDB's "unset" operation), effectively nullifying the relationship.
 :const:`mongoengine.CASCADE`
-  Any object containing fields that are refererring to the object being deleted
+  Any object containing fields that are referring to the object being deleted
   are deleted first.
 :const:`mongoengine.PULL`
   Removes the reference to the object (using MongoDB's "pull" operation)
@@ -352,11 +379,6 @@ Its value can take any of the following constants:
    In Django, be sure to put all apps that have such delete rule declarations in
    their :file:`models.py` in the :const:`INSTALLED_APPS` tuple.
 
-
-.. warning::
-   Signals are not triggered when doing cascading updates / deletes - if this
-   is required you must manually handle the update / delete.
-
 Generic reference fields
 ''''''''''''''''''''''''
 A second kind of reference field also exists,
@@ -395,7 +417,7 @@ MongoEngine allows you to specify that a field should be unique across a
 collection by providing ``unique=True`` to a :class:`~mongoengine.fields.Field`\ 's
 constructor. If you try to save a document that has the same value for a unique
 field as a document that is already in the database, a
-:class:`~mongoengine.OperationError` will be raised. You may also specify
+:class:`~mongoengine.NotUniqueError` will be raised. You may also specify
 multi-field uniqueness constraints by using :attr:`unique_with`, which may be
 either a single field name, or a list or tuple of field names::
 
@@ -422,7 +444,7 @@ Document collections
 ====================
 Document classes that inherit **directly** from :class:`~mongoengine.Document`
 will have their own **collection** in the database. The name of the collection
-is by default the name of the class, coverted to lowercase (so in the example
+is by default the name of the class, converted to lowercase (so in the example
 above, the collection would be called `page`). If you need to change the name
 of the collection (e.g. to use MongoEngine with an existing database), then
 create a class dictionary attribute called :attr:`meta` on your document, and
@@ -439,8 +461,10 @@ A :class:`~mongoengine.Document` may use a **Capped Collection** by specifying
 :attr:`max_documents` and :attr:`max_size` in the :attr:`meta` dictionary.
 :attr:`max_documents` is the maximum number of documents that is allowed to be
 stored in the collection, and :attr:`max_size` is the maximum size of the
-collection in bytes. If :attr:`max_size` is not specified and
-:attr:`max_documents` is, :attr:`max_size` defaults to 10000000 bytes (10MB).
+collection in bytes. :attr:`max_size` is rounded up to the next multiple of 256
+by MongoDB internally and mongoengine before. Use also a multiple of 256 to
+avoid confusions. If :attr:`max_size` is not specified and
+:attr:`max_documents` is, :attr:`max_size` defaults to 10485760 bytes (10MB).
 The following example shows a :class:`Log` document that will be limited to
 1000 entries and 2MB of disk space::
 
@@ -457,18 +481,36 @@ You can specify indexes on collections to make querying faster. This is done
 by creating a list of index specifications called :attr:`indexes` in the
 :attr:`~mongoengine.Document.meta` dictionary, where an index specification may
 either be a single field name, a tuple containing multiple field names, or a
-dictionary containing a full index definition. A direction may be specified on
-fields by prefixing the field name with a **+** (for ascending) or a **-** sign
-(for descending). Note that direction only matters on multi-field indexes. ::
+dictionary containing a full index definition.
+
+A direction may be specified on fields by prefixing the field name with a
+**+** (for ascending) or a **-** sign (for descending). Note that direction
+only matters on multi-field indexes. Text indexes may be specified by prefixing
+the field name with a **$**. Hashed indexes may be specified by prefixing
+the field name with a **#**::
 
     class Page(Document):
+        category = IntField()
         title = StringField()
         rating = StringField()
+        created = DateTimeField()
         meta = {
-            'indexes': ['title', ('title', '-rating')]
+            'indexes': [
+                'title',
+                '$title',  # text index
+                '#title',  # hashed index
+                ('title', '-rating'),
+                ('category', '_cls'),
+                {
+                    'fields': ['created'],
+                    'expireAfterSeconds': 3600
+                }
+            ]
         }
 
-If a dictionary is passed then the following options are available:
+If a dictionary is passed then additional options become available. Valid options include,
+but are not limited to:
+
 
 :attr:`fields` (Default: None)
     The fields to index. Specified in the same format as described above.
@@ -489,8 +531,15 @@ If a dictionary is passed then the following options are available:
     Allows you to automatically expire data from a collection by setting the
     time in seconds to expire the a field.
 
+:attr:`name` (Optional)
+    Allows you to specify a name for the index
+
+:attr:`collation` (Optional)
+    Allows to create case insensitive indexes (MongoDB v3.4+ only)
+
 .. note::
 
+    Additional options are forwarded as **kwargs to pymongo's create_index method.
     Inheritance adds extra fields indices see: :ref:`document-inheritance`.
 
 Global index default options
@@ -502,25 +551,34 @@ There are a few top level defaults for all indexes that can be set::
         title = StringField()
         rating = StringField()
         meta = {
-            'index_options': {},
+            'index_opts': {},
             'index_background': True,
+            'index_cls': False,
+            'auto_create_index': True,
             'index_drop_dups': True,
-            'index_cls': False
         }
 
 
-:attr:`index_options` (Optional)
-    Set any default index options - see the `full options list <http://docs.mongodb.org/manual/reference/method/db.collection.ensureIndex/#db.collection.ensureIndex>`_
+:attr:`index_opts` (Optional)
+    Set any default index options - see the `full options list <https://docs.mongodb.com/manual/reference/method/db.collection.createIndex/#db.collection.createIndex>`_
 
 :attr:`index_background` (Optional)
     Set the default value for if an index should be indexed in the background
 
-:attr:`index_drop_dups` (Optional)
-    Set the default value for if an index should drop duplicates
-
 :attr:`index_cls` (Optional)
     A way to turn off a specific index for _cls.
 
+:attr:`auto_create_index` (Optional)
+    When this is True (default), MongoEngine will ensure that the correct
+    indexes exist in MongoDB each time a command is run. This can be disabled
+    in systems where indexes are managed separately. Disabling this will improve
+    performance.
+
+:attr:`index_drop_dups` (Optional)
+    Set the default value for if an index should drop duplicates
+    Since MongoDB 3.0 drop_dups is not supported anymore. Raises a Warning
+    and has no effect
+
 
 Compound Indexes and Indexing sub documents
 -------------------------------------------
@@ -531,6 +589,8 @@ field name to the index definition.
 Sometimes its more efficient to index parts of Embedded / dictionary fields,
 in this case use 'dot' notation to identify the value to index eg: `rank.title`
 
+.. _geospatial-indexes:
+
 Geospatial indexes
 ------------------
 
@@ -541,6 +601,9 @@ The following fields will explicitly add a "2dsphere" index:
     - :class:`~mongoengine.fields.PointField`
     - :class:`~mongoengine.fields.LineStringField`
     - :class:`~mongoengine.fields.PolygonField`
+    - :class:`~mongoengine.fields.MultiPointField`
+    - :class:`~mongoengine.fields.MultiLineStringField`
+    - :class:`~mongoengine.fields.MultiPolygonField`
 
 As "2dsphere" indexes can be part of a compound index, you may not want the
 automatic index but would prefer a compound index.  In this example we turn off
@@ -588,7 +651,7 @@ collection after a given period. See the official
 documentation for more information.  A common usecase might be session data::
 
     class Session(Document):
-        created = DateTimeField(default=datetime.now)
+        created = DateTimeField(default=datetime.utcnow)
         meta = {
             'indexes': [
                 {'fields': ['created'], 'expireAfterSeconds': 3600}
@@ -651,12 +714,17 @@ subsequent calls to :meth:`~mongoengine.queryset.QuerySet.order_by`. ::
 Shard keys
 ==========
 
-If your collection is sharded, then you need to specify the shard key as a tuple,
-using the :attr:`shard_key` attribute of :attr:`-mongoengine.Document.meta`.
-This ensures that the shard key is sent with the query when calling the
-:meth:`~mongoengine.document.Document.save` or
-:meth:`~mongoengine.document.Document.update` method on an existing
-:class:`-mongoengine.Document` instance::
+If your collection is sharded by multiple keys, then you can improve shard
+routing (and thus the performance of your application) by specifying the shard
+key, using the :attr:`shard_key` attribute of
+:attr:`~mongoengine.Document.meta`. The shard key should be defined as a tuple.
+
+This ensures that the full shard key is sent with the query when calling
+methods such as :meth:`~mongoengine.document.Document.save`,
+:meth:`~mongoengine.document.Document.update`,
+:meth:`~mongoengine.document.Document.modify`, or
+:meth:`~mongoengine.document.Document.delete` on an existing
+:class:`~mongoengine.Document` instance::
 
     class LogEntry(Document):
         machine = StringField()
@@ -665,7 +733,8 @@ This ensures that the shard key is sent with the query when calling the
         data = StringField()
 
         meta = {
-            'shard_key': ('machine', 'timestamp',)
+            'shard_key': ('machine', 'timestamp'),
+            'indexes': ('machine', 'timestamp'),
         }
 
 .. _document-inheritance:
@@ -678,7 +747,7 @@ defined, you may subclass it and add any extra fields or methods you may need.
 As this is new class is not a direct subclass of
 :class:`~mongoengine.Document`, it will not be stored in its own collection; it
 will use the same collection as its superclass uses. This allows for more
-convenient and efficient retrieval of related documents - all you need do is
+convenient and efficient retrieval of related documents -- all you need do is
 set :attr:`allow_inheritance` to True in the :attr:`meta` data for a
 document.::
 
@@ -692,12 +761,15 @@ document.::
     class DatedPage(Page):
         date = DateTimeField()
 
-.. note:: From 0.8 onwards you must declare :attr:`allow_inheritance` defaults
+.. note:: From 0.8 onwards :attr:`allow_inheritance` defaults
           to False, meaning you must set it to True to use inheritance.
 
+          Setting :attr:`allow_inheritance` to True should also be used in
+          :class:`~mongoengine.EmbeddedDocument` class in case you need to subclass it
+
 Working with existing data
 --------------------------
-As MongoEngine no longer defaults to needing :attr:`_cls` you can quickly and
+As MongoEngine no longer defaults to needing :attr:`_cls`, you can quickly and
 easily get working with existing data.  Just define the document to match
 the expected schema in your database ::
 
@@ -720,7 +792,7 @@ Abstract classes
 
 If you want to add some extra functionality to a group of Document classes but
 you don't need or want the overhead of inheritance you can use the
-:attr:`abstract` attribute of :attr:`-mongoengine.Document.meta`.
+:attr:`abstract` attribute of :attr:`~mongoengine.Document.meta`.
 This won't turn on :ref:`document-inheritance` but will allow you to keep your
 code DRY::
 

docs/guide/document-instances.rst

@@ -2,7 +2,7 @@
 Documents instances
 ===================
 To create a new document object, create an instance of the relevant document
-class, providing values for its fields as its constructor keyword arguments.
+class, providing values for its fields as constructor keyword arguments.
 You may provide values for any of the fields on the document::
 
     >>> page = Page(title="Test Page")
@@ -32,11 +32,11 @@ already exist, then any changes will be updated atomically.  For example::
 
     Changes to documents are tracked and on the whole perform ``set`` operations.
 
-    * ``list_field.push(0)`` - *sets* the resulting list
-    * ``del(list_field)``   - *unsets* whole list
+    * ``list_field.push(0)`` --- *sets* the resulting list
+    * ``del(list_field)``   --- *unsets* whole list
 
     With lists its preferable to use ``Doc.update(push__list_field=0)`` as
-    this stops the whole list being updated - stopping any race conditions.
+    this stops the whole list being updated --- stopping any race conditions.
 
 .. seealso::
     :ref:`guide-atomic-updates`
@@ -57,7 +57,8 @@ document values for example::
 
         def clean(self):
             """Ensures that only published essays have a `pub_date` and
-            automatically sets the pub_date if published and not set"""
+            automatically sets `pub_date` if essay is published and `pub_date`
+            is not set"""
             if self.status == 'Draft' and self.pub_date is not None:
                 msg = 'Draft entries should not have a publication date.'
                 raise ValidationError(msg)
@@ -74,7 +75,7 @@ Cascading Saves
 If your document contains :class:`~mongoengine.fields.ReferenceField` or
 :class:`~mongoengine.fields.GenericReferenceField` objects, then by default the
 :meth:`~mongoengine.Document.save` method will not save any changes to
-those objects.  If you want all references to also be saved also, noting each
+those objects.  If you want all references to be saved also, noting each
 save is a separate query, then passing :attr:`cascade` as True
 to the save method will cascade any saves.
 
@@ -113,12 +114,13 @@ you may still use :attr:`id` to access the primary key if you want::
     >>> bob.id == bob.email == 'bob@example.com'
     True
 
-You can also access the document's "primary key" using the :attr:`pk` field; in
-is an alias to :attr:`id`::
+You can also access the document's "primary key" using the :attr:`pk` field,
+it's an alias to :attr:`id`::
 
     >>> page = Page(title="Another Test Page")
     >>> page.save()
     >>> page.id == page.pk
+    True
 
 .. note::
 

docs/guide/gridfs.rst

@@ -20,7 +20,7 @@ a document is created to store details about animals, including a photo::
 
     marmot = Animal(genus='Marmota', family='Sciuridae')
 
-    marmot_photo = open('marmot.jpg', 'r')
+    marmot_photo = open('marmot.jpg', 'rb')
     marmot.photo.put(marmot_photo, content_type = 'image/jpeg')
     marmot.save()
 
@@ -46,14 +46,15 @@ slightly different manner.  First, a new file must be created by calling the
     marmot.photo.write('some_more_image_data')
     marmot.photo.close()
 
-    marmot.photo.save()
+    marmot.save()
 
 Deletion
 --------
 
 Deleting stored files is achieved with the :func:`delete` method::
 
-    marmot.photo.delete()
+    marmot.photo.delete()    # Deletes the GridFS document
+    marmot.save()            # Saves the GridFS reference (being None) contained in the marmot instance
 
 .. warning::
 
@@ -70,5 +71,6 @@ Replacing files
 Files can be replaced with the :func:`replace` method. This works just like
 the :func:`put` method so even metadata can (and should) be replaced::
 
-    another_marmot = open('another_marmot.png', 'r')
-    marmot.photo.replace(another_marmot, content_type='image/png')
+    another_marmot = open('another_marmot.png', 'rb')
+    marmot.photo.replace(another_marmot, content_type='image/png')  # Replaces the GridFS document
+    marmot.save()                                                   # Replaces the GridFS reference contained in marmot instance

docs/guide/index.rst

@@ -12,3 +12,5 @@ User Guide
    querying
    gridfs
    signals
+   text-indexes
+   mongomock

docs/guide/installing.rst

@@ -2,13 +2,13 @@
 Installing MongoEngine
 ======================
 
-To use MongoEngine, you will need to download `MongoDB <http://mongodb.org/>`_
+To use MongoEngine, you will need to download `MongoDB <http://mongodb.com/>`_
 and ensure it is running in an accessible location. You will also need
 `PyMongo <http://api.mongodb.org/python>`_ to use MongoEngine, but if you
 install MongoEngine using setuptools, then the dependencies will be handled for
 you.
 
-MongoEngine is available on PyPI, so to use it you can use :program:`pip`:
+MongoEngine is available on PyPI, so you can use :program:`pip`:
 
 .. code-block:: console
 

docs/guide/mongomock.rst

@@ -0,0 +1,48 @@
+==============================
+Use mongomock for testing
+==============================
+
+`mongomock <https://github.com/vmalloc/mongomock/>`_ is a package to do just 
+what the name implies, mocking a mongo database.
+
+To use with mongoengine, simply specify mongomock when connecting with 
+mongoengine:
+
+.. code-block:: python
+
+    connect('mongoenginetest', host='mongomock://localhost')
+    conn = get_connection()
+
+or with an alias:
+
+.. code-block:: python
+
+    connect('mongoenginetest', host='mongomock://localhost', alias='testdb')
+    conn = get_connection('testdb')
+
+Example of test file:
+--------
+.. code-block:: python
+
+    import unittest
+    from mongoengine import connect, disconnect
+
+    class Person(Document):
+        name = StringField()
+
+    class TestPerson(unittest.TestCase):
+
+        @classmethod
+        def setUpClass(cls):
+            connect('mongoenginetest', host='mongomock://localhost')
+
+        @classmethod
+        def tearDownClass(cls):
+           disconnect()
+
+        def test_thing(self):
+            pers = Person(name='John')
+            pers.save()
+
+            fresh_pers = Person.objects().first()
+            self.assertEqual(fresh_pers.name, 'John')

docs/guide/querying.rst

@@ -17,7 +17,7 @@ fetch documents from the database::
 
     As of MongoEngine 0.8 the querysets utilise a local cache.  So iterating
     it multiple times will only cause a single query.  If this is not the
-    desired behavour you can call :class:`~mongoengine.QuerySet.no_cache`
+    desired behaviour you can call :class:`~mongoengine.QuerySet.no_cache`
     (version **0.8.3+**) to return a non-caching queryset.
 
 Filtering queries
@@ -39,10 +39,18 @@ syntax::
     # been written by a user whose 'country' field is set to 'uk'
     uk_pages = Page.objects(author__country='uk')
 
+.. note::
+
+   (version **0.9.1+**) if your field name is like mongodb operator name (for example
+   type, lte, lt...) and you want to place it at the end of lookup keyword
+   mongoengine automatically  prepend $ to it. To avoid this use  __ at the end of
+   your lookup keyword. For example if your field name is ``type`` and you want to
+   query by this field you must use ``.objects(user__type__="admin")`` instead of
+   ``.objects(user__type="admin")``
 
 Query operators
 ===============
-Operators other than equality may also be used in queries; just attach the
+Operators other than equality may also be used in queries --- just attach the
 operator name to a key with a double-underscore::
 
     # Only find users whose age is 18 or less
@@ -56,7 +64,7 @@ Available operators are as follows:
 * ``gt`` -- greater than
 * ``gte`` -- greater than or equal to
 * ``not`` -- negate a standard check, may be used before other operators (e.g.
-  ``Q(age__not__mod=5)``)
+  ``Q(age__not__mod=(5, 0))``)
 * ``in`` -- value is in list (a list of values should be provided)
 * ``nin`` -- value is not in list (a list of values should be provided)
 * ``mod`` -- ``value % x == y``, where ``x`` and ``y`` are two provided values
@@ -84,19 +92,20 @@ expressions:
 Geo queries
 -----------
 
-There are a few special operators for performing geographical queries. The following
-were added in 0.8 for:  :class:`~mongoengine.fields.PointField`,
+There are a few special operators for performing geographical queries.
+The following were added in MongoEngine 0.8 for
+:class:`~mongoengine.fields.PointField`,
 :class:`~mongoengine.fields.LineStringField` and
 :class:`~mongoengine.fields.PolygonField`:
 
-* ``geo_within`` -- Check if a geometry is within a polygon.  For ease of use
-    it accepts either a geojson geometry or just the polygon coordinates eg::
+* ``geo_within`` -- check if a geometry is within a polygon. For ease of use
+  it accepts either a geojson geometry or just the polygon coordinates eg::
 
-        loc.objects(point__geo_with=[[[40, 5], [40, 6], [41, 6], [40, 5]]])
-        loc.objects(point__geo_with={"type": "Polygon",
+        loc.objects(point__geo_within=[[[40, 5], [40, 6], [41, 6], [40, 5]]])
+        loc.objects(point__geo_within={"type": "Polygon",
                                  "coordinates": [[[40, 5], [40, 6], [41, 6], [40, 5]]]})
 
-* ``geo_within_box`` - simplified geo_within searching with a box eg::
+* ``geo_within_box`` -- simplified geo_within searching with a box eg::
 
         loc.objects(point__geo_within_box=[(-125.0, 35.0), (-100.0, 40.0)])
         loc.objects(point__geo_within_box=[<bottom left coordinates>, <upper right coordinates>])
@@ -132,23 +141,22 @@ were added in 0.8 for:  :class:`~mongoengine.fields.PointField`,
         loc.objects(poly__geo_intersects={"type": "Polygon",
                                           "coordinates": [[[40, 5], [40, 6], [41, 6], [41, 5], [40, 5]]]})
 
-* ``near`` -- Find all the locations near a given point::
+* ``near`` -- find all the locations near a given point::
 
         loc.objects(point__near=[40, 5])
         loc.objects(point__near={"type": "Point", "coordinates": [40, 5]})
 
-
-    You can also set the maximum distance in meters as well::
+  You can also set the maximum and/or the minimum distance in meters as well::
 
         loc.objects(point__near=[40, 5], point__max_distance=1000)
-
+        loc.objects(point__near=[40, 5], point__min_distance=100)
 
 The older 2D indexes are still supported with the
 :class:`~mongoengine.fields.GeoPointField`:
 
 * ``within_distance`` -- provide a list containing a point and a maximum
   distance (e.g. [(41.342, -87.653), 5])
-* ``within_spherical_distance`` -- Same as above but using the spherical geo model
+* ``within_spherical_distance`` -- same as above but using the spherical geo model
   (e.g. [(41.342, -87.653), 5/earth_radius])
 * ``near`` -- order the documents by how close they are to a given point
 * ``near_sphere`` -- Same as above but using the spherical geo model
@@ -161,7 +169,8 @@ The older 2D indexes are still supported with the
 
 * ``max_distance`` -- can be added to your location queries to set a maximum
   distance.
-
+* ``min_distance`` -- can be added to your location queries to set a minimum
+  distance.
 
 Querying lists
 --------------
@@ -198,12 +207,14 @@ However, this doesn't map well to the syntax so you can also use a capital S ins
 
     Post.objects(comments__by="joe").update(inc__comments__S__votes=1)
 
-    .. note:: Due to Mongo currently the $ operator only applies to the first matched item in the query.
+.. note::
+    Due to :program:`Mongo`, currently the $ operator only applies to the
+    first matched item in the query.
 
 
 Raw queries
 -----------
-It is possible to provide a raw PyMongo query as a query parameter, which will
+It is possible to provide a raw :mod:`PyMongo` query as a query parameter, which will
 be integrated directly into the query. This is done using the ``__raw__``
 keyword argument::
 
@@ -213,12 +224,12 @@ keyword argument::
 
 Limiting and skipping results
 =============================
-Just as with traditional ORMs, you may limit the number of results returned, or
+Just as with traditional ORMs, you may limit the number of results returned or
 skip a number or results in you query.
 :meth:`~mongoengine.queryset.QuerySet.limit` and
 :meth:`~mongoengine.queryset.QuerySet.skip` and methods are available on
-:class:`~mongoengine.queryset.QuerySet` objects, but the prefered syntax for
-achieving this is using array-slicing syntax::
+:class:`~mongoengine.queryset.QuerySet` objects, but the `array-slicing` syntax
+is preferred for achieving this::
 
     # Only the first 5 people
     users = User.objects[:5]
@@ -226,7 +237,7 @@ achieving this is using array-slicing syntax::
     # All except for the first 5 people
     users = User.objects[5:]
 
-    # 5 users, starting from the 10th user found
+    # 5 users, starting from the 11th user found
     users = User.objects[10:15]
 
 You may also index the query to retrieve a single result. If an item at that
@@ -252,23 +263,17 @@ To retrieve a result that should be unique in the collection, use
 no document matches the query, and
 :class:`~mongoengine.queryset.MultipleObjectsReturned`
 if more than one document matched the query.  These exceptions are merged into
-your document defintions eg: `MyDoc.DoesNotExist`
+your document definitions eg: `MyDoc.DoesNotExist`
 
-A variation of this method exists,
-:meth:`~mongoengine.queryset.Queryset.get_or_create`, that will create a new
-document with the query arguments if no documents match the query. An
-additional keyword argument, :attr:`defaults` may be provided, which will be
-used as default values for the new document, in the case that it should need
-to be created::
-
-    >>> a, created = User.objects.get_or_create(name='User A', defaults={'age': 30})
-    >>> b, created = User.objects.get_or_create(name='User A', defaults={'age': 40})
-    >>> a.name == b.name and a.age == b.age
-    True
+A variation of this method, get_or_create() existed, but it was unsafe. It
+could not be made safe, because there are no transactions in mongoDB. Other
+approaches should be investigated, to ensure you don't accidentally duplicate
+data when using something similar to this method. Therefore it was deprecated
+in 0.8 and removed in 0.10.
 
 Default Document queries
 ========================
-By default, the objects :attr:`~mongoengine.Document.objects` attribute on a
+By default, the objects :attr:`~Document.objects` attribute on a
 document returns a :class:`~mongoengine.queryset.QuerySet` that doesn't filter
 the collection -- it returns all objects. This may be changed by defining a
 method on a document that modifies a queryset. The method should accept two
@@ -311,7 +316,7 @@ Should you want to add custom methods for interacting with or filtering
 documents, extending the :class:`~mongoengine.queryset.QuerySet` class may be
 the way to go. To use a custom :class:`~mongoengine.queryset.QuerySet` class on
 a document, set ``queryset_class`` to the custom class in a
-:class:`~mongoengine.Document`\ s ``meta`` dictionary::
+:class:`~mongoengine.Document`'s ``meta`` dictionary::
 
     class AwesomerQuerySet(QuerySet):
 
@@ -335,12 +340,19 @@ Javascript code that is executed on the database server.
 
 Counting results
 ----------------
-Just as with limiting and skipping results, there is a method on
-:class:`~mongoengine.queryset.QuerySet` objects --
-:meth:`~mongoengine.queryset.QuerySet.count`, but there is also a more Pythonic
-way of achieving this::
+Just as with limiting and skipping results, there is a method on a
+:class:`~mongoengine.queryset.QuerySet` object --
+:meth:`~mongoengine.queryset.QuerySet.count`::
 
-    num_users = len(User.objects)
+    num_users = User.objects.count()
+
+You could technically use ``len(User.objects)`` to get the same result, but it
+would be significantly slower than :meth:`~mongoengine.queryset.QuerySet.count`.
+When you execute a server-side count query, you let MongoDB do the heavy
+lifting and you receive a single integer over the wire. Meanwhile, len()
+retrieves all the results, places them in a local cache, and finally counts
+them. If we compare the performance of the two operations, len() is much slower
+than :meth:`~mongoengine.queryset.QuerySet.count`.
 
 Further aggregation
 -------------------
@@ -444,14 +456,14 @@ data. To turn off dereferencing of the results of a query use
 :func:`~mongoengine.queryset.QuerySet.no_dereference` on the queryset like so::
 
     post = Post.objects.no_dereference().first()
-    assert(isinstance(post.author, ObjectId))
+    assert(isinstance(post.author, DBRef))
 
 You can also turn off all dereferencing for a fixed period by using the
 :class:`~mongoengine.context_managers.no_dereference` context manager::
 
     with no_dereference(Post) as Post:
         post = Post.objects.first()
-        assert(isinstance(post.author, ObjectId))
+        assert(isinstance(post.author, DBRef))
 
     # Outside the context manager dereferencing occurs.
     assert(isinstance(post.author, User))
@@ -472,6 +484,8 @@ operators. To use a :class:`~mongoengine.queryset.Q` object, pass it in as the
 first positional argument to :attr:`Document.objects` when you filter it by
 calling it with keyword arguments::
 
+    from mongoengine.queryset.visitor import Q
+
     # Get published posts
     Post.objects(Q(published=True) | Q(publish_date__lte=datetime.now()))
 
@@ -488,22 +502,28 @@ calling it with keyword arguments::
 Atomic updates
 ==============
 Documents may be updated atomically by using the
-:meth:`~mongoengine.queryset.QuerySet.update_one` and
-:meth:`~mongoengine.queryset.QuerySet.update` methods on a
-:meth:`~mongoengine.queryset.QuerySet`. There are several different "modifiers"
-that you may use with these methods:
+:meth:`~mongoengine.queryset.QuerySet.update_one`,
+:meth:`~mongoengine.queryset.QuerySet.update` and
+:meth:`~mongoengine.queryset.QuerySet.modify` methods on a
+:class:`~mongoengine.queryset.QuerySet` or
+:meth:`~mongoengine.Document.modify` and
+:meth:`~mongoengine.Document.save` (with :attr:`save_condition` argument) on a
+:class:`~mongoengine.Document`.
+There are several different "modifiers" that you may use with these methods:
 
 * ``set`` -- set a particular value
-* ``unset`` -- delete a particular value (since MongoDB v1.3+)
+* ``unset`` -- delete a particular value (since MongoDB v1.3)
 * ``inc`` -- increment a value by a given amount
 * ``dec`` -- decrement a value by a given amount
 * ``push`` -- append a value to a list
 * ``push_all`` -- append several values to a list
-* ``pop`` -- remove the first or last element of a list
+* ``pop`` -- remove the first or last element of a list `depending on the value`_
 * ``pull`` -- remove a value from a list
 * ``pull_all`` -- remove several values from a list
 * ``add_to_set`` -- add value to a list only if its not in the list already
 
+.. _depending on the value: http://docs.mongodb.org/manual/reference/operator/update/pop/
+
 The syntax for atomic updates is similar to the querying syntax, but the
 modifier comes before the field, not after it::
 
@@ -522,6 +542,13 @@ modifier comes before the field, not after it::
     >>> post.tags
     ['database', 'nosql']
 
+.. note::
+
+    If no modifier operator is specified the default will be ``$set``. So the following sentences are identical::
+
+        >>> BlogPost.objects(id=post.id).update(title='Example Post')
+        >>> BlogPost.objects(id=post.id).update(set__title='Example Post')
+
 .. note::
 
     In version 0.5 the :meth:`~mongoengine.Document.save` runs atomic updates
@@ -538,6 +565,15 @@ cannot use the `$` syntax in keyword arguments it has been mapped to `S`::
     >>> post.tags
     ['database', 'mongodb']
 
+From MongoDB version 2.6, push operator supports $position value which allows
+to push values with index.
+    >>> post = BlogPost(title="Test", tags=["mongo"])
+    >>> post.save()
+    >>> post.update(push__tags__0=["database", "code"])
+    >>> post.reload()
+    >>> post.tags
+    ['database', 'code', 'mongo']
+
 .. note::
     Currently only top level lists are handled, future versions of mongodb /
     pymongo plan to support nested positional operators.  See `The $ positional
@@ -580,7 +616,7 @@ Some variables are made available in the scope of the Javascript function:
 
 The following example demonstrates the intended usage of
 :meth:`~mongoengine.queryset.QuerySet.exec_js` by defining a function that sums
-over a field on a document (this functionality is already available throught
+over a field on a document (this functionality is already available through
 :meth:`~mongoengine.queryset.QuerySet.sum` but is shown here for sake of
 example)::
 

docs/guide/signals.rst

@@ -35,25 +35,25 @@ Available signals include:
   :class:`~mongoengine.EmbeddedDocument` instance has been completed.
 
 `pre_save`
-  Called within :meth:`~mongoengine.document.Document.save` prior to performing
+  Called within :meth:`~mongoengine.Document.save` prior to performing
   any actions.
 
 `pre_save_post_validation`
-  Called within :meth:`~mongoengine.document.Document.save` after validation
+  Called within :meth:`~mongoengine.Document.save` after validation
   has taken place but before saving.
 
 `post_save`
-  Called within :meth:`~mongoengine.document.Document.save` after all actions
-  (validation, insert/update, cascades, clearing dirty flags) have completed
-  successfully.  Passed the additional boolean keyword argument `created` to
-  indicate if the save was an insert or an update.
+  Called within :meth:`~mongoengine.Document.save` after most actions
+  (validation, insert/update, and cascades, but not clearing dirty flags) have 
+  completed successfully.  Passed the additional boolean keyword argument 
+  `created` to indicate if the save was an insert or an update.
 
 `pre_delete`
-  Called within :meth:`~mongoengine.document.Document.delete` prior to
+  Called within :meth:`~mongoengine.Document.delete` prior to
   attempting the delete operation.
 
 `post_delete`
-  Called within :meth:`~mongoengine.document.Document.delete` upon successful
+  Called within :meth:`~mongoengine.Document.delete` upon successful
   deletion of the record.
 
 `pre_bulk_insert`
@@ -113,6 +113,10 @@ handlers within your subclass::
     signals.pre_save.connect(Author.pre_save, sender=Author)
     signals.post_save.connect(Author.post_save, sender=Author)
 
+.. warning::
+
+    Note that EmbeddedDocument only supports pre/post_init signals. pre/post_save, etc should be attached to Document's class only. Attaching pre_save to an EmbeddedDocument is ignored silently.
+
 Finally, you can also use this small decorator to quickly create a number of
 signals and attach them to your :class:`~mongoengine.Document` or
 :class:`~mongoengine.EmbeddedDocument` subclasses as class decorators::
@@ -142,11 +146,4 @@ cleaner looking while still allowing manual execution of the callback::
         modified = DateTimeField()
 
 
-ReferenceFields and Signals
----------------------------
-
-Currently `reverse_delete_rules` do not trigger signals on the other part of
-the relationship.  If this is required you must manually handle the
-reverse deletion.
-
 .. _blinker: http://pypi.python.org/pypi/blinker

docs/guide/text-indexes.rst

@@ -0,0 +1,51 @@
+===========
+Text Search
+===========
+
+After MongoDB 2.4 version, supports search documents by text indexes.
+
+
+Defining a Document with text index
+===================================
+Use the *$* prefix to set a text index, Look the declaration::
+  
+  class News(Document):
+      title = StringField()
+      content = StringField()
+      is_active = BooleanField()
+
+      meta = {'indexes': [
+          {'fields': ['$title', "$content"],
+           'default_language': 'english',
+           'weights': {'title': 10, 'content': 2}
+          }
+      ]}
+
+
+
+Querying
+========
+
+Saving a document::
+
+  News(title="Using mongodb text search",
+       content="Testing text search").save()
+
+  News(title="MongoEngine 0.9 released",
+       content="Various improvements").save()
+
+Next, start a text search using :attr:`QuerySet.search_text` method::
+  
+  document = News.objects.search_text('testing').first()
+  document.title # may be: "Using mongodb text search"
+  
+  document = News.objects.search_text('released').first()
+  document.title # may be: "MongoEngine 0.9 released"
+
+
+Ordering by text score
+======================
+
+::
+
+  objects = News.objects.search_text('mongo').order_by('$text_score')

docs/index.rst

@@ -14,7 +14,7 @@ MongoDB. To install it, simply run
   MongoEngine.
 
 :doc:`guide/index`
-  The Full guide to MongoEngine - from modeling documents to storing files,
+  The Full guide to MongoEngine --- from modeling documents to storing files,
   from querying for data to firing signals and *everything* between.
 
 :doc:`apireference`

docs/tutorial.rst

@@ -3,11 +3,10 @@ Tutorial
 ========
 
 This tutorial introduces **MongoEngine** by means of example --- we will walk
-through how to create a simple **Tumblelog** application. A Tumblelog is a type
-of blog where posts are not constrained to being conventional text-based posts.
-As well as text-based entries, users may post images, links, videos, etc. For
-simplicity's sake, we'll stick to text, image and link entries in our
-application. As the purpose of this tutorial is to introduce MongoEngine, we'll
+through how to create a simple **Tumblelog** application. A tumblelog is a
+blog that supports mixed media content, including text, images, links, video,
+audio, etc. For simplicity's sake, we'll stick to text, image, and link
+entries. As the purpose of this tutorial is to introduce MongoEngine, we'll
 focus on the data-modelling side of the application, leaving out a user
 interface.
 
@@ -16,14 +15,14 @@ Getting started
 
 Before we start, make sure that a copy of MongoDB is running in an accessible
 location --- running it locally will be easier, but if that is not an option
-then it may be run on a remote server. If you haven't installed mongoengine,
+then it may be run on a remote server. If you haven't installed MongoEngine,
 simply use pip to install it like so::
 
     $ pip install mongoengine
 
 Before we can start using MongoEngine, we need to tell it how to connect to our
 instance of :program:`mongod`. For this we use the :func:`~mongoengine.connect`
-function. If running locally the only argument we need to provide is the name
+function. If running locally, the only argument we need to provide is the name
 of the MongoDB database to use::
 
     from mongoengine import *
@@ -39,18 +38,18 @@ Defining our documents
 MongoDB is *schemaless*, which means that no schema is enforced by the database
 --- we may add and remove fields however we want and MongoDB won't complain.
 This makes life a lot easier in many regards, especially when there is a change
-to the data model. However, defining schemata for our documents can help to
-iron out bugs involving incorrect types or missing fields, and also allow us to
+to the data model. However, defining schemas for our documents can help to iron
+out bugs involving incorrect types or missing fields, and also allow us to
 define utility methods on our documents in the same way that traditional
 :abbr:`ORMs (Object-Relational Mappers)` do.
 
 In our Tumblelog application we need to store several different types of
-information.  We will need to have a collection of **users**, so that we may
+information. We will need to have a collection of **users**, so that we may
 link posts to an individual. We also need to store our different types of
 **posts** (eg: text, image and link) in the database. To aid navigation of our
 Tumblelog, posts may have **tags** associated with them, so that the list of
 posts shown to the user may be limited to posts that have been assigned a
-specific tag.  Finally, it would be nice if **comments** could be added to
+specific tag. Finally, it would be nice if **comments** could be added to
 posts. We'll start with **users**, as the other document models are slightly
 more involved.
 
@@ -65,7 +64,7 @@ which fields a :class:`User` may have, and what types of data they might store::
         first_name = StringField(max_length=50)
         last_name = StringField(max_length=50)
 
-This looks similar to how a the structure of a table would be defined in a
+This looks similar to how the structure of a table would be defined in a
 regular ORM. The key difference is that this schema will never be passed on to
 MongoDB --- this will only be enforced at the application level, making future
 changes easy to manage. Also, the User documents will be stored in a
@@ -78,7 +77,7 @@ Now we'll think about how to store the rest of the information. If we were
 using a relational database, we would most likely have a table of **posts**, a
 table of **comments** and a table of **tags**.  To associate the comments with
 individual posts, we would put a column in the comments table that contained a
-foreign key to the posts table.  We'd also need a link table to provide the
+foreign key to the posts table. We'd also need a link table to provide the
 many-to-many relationship between posts and tags. Then we'd need to address the
 problem of storing the specialised post-types (text, image and link). There are
 several ways we can achieve this, but each of them have their problems --- none
@@ -87,7 +86,7 @@ of them stand out as particularly intuitive solutions.
 Posts
 ^^^^^
 
-Happily mongoDB *isn't* a relational database, so we're not going to do it that
+Happily MongoDB *isn't* a relational database, so we're not going to do it that
 way. As it turns out, we can use MongoDB's schemaless nature to provide us with
 a much nicer solution. We will store all of the posts in *one collection* and
 each post type will only store the fields it needs. If we later want to add
@@ -96,7 +95,7 @@ using* the new fields we need to support video posts. This fits with the
 Object-Oriented principle of *inheritance* nicely. We can think of
 :class:`Post` as a base class, and :class:`TextPost`, :class:`ImagePost` and
 :class:`LinkPost` as subclasses of :class:`Post`. In fact, MongoEngine supports
-this kind of modelling out of the box --- all you need do is turn on inheritance
+this kind of modeling out of the box --- all you need do is turn on inheritance
 by setting :attr:`allow_inheritance` to True in the :attr:`meta`::
 
     class Post(Document):
@@ -128,8 +127,8 @@ link table, we can just store a list of tags in each post. So, for both
 efficiency and simplicity's sake, we'll store the tags as strings directly
 within the post, rather than storing references to tags in a separate
 collection. Especially as tags are generally very short (often even shorter
-than a document's id), this denormalisation won't impact very strongly on the
-size of our database. So let's take a look that the code our modified
+than a document's id), this denormalization won't impact the size of the
+database very strongly. Let's take a look at the code of our modified
 :class:`Post` class::
 
     class Post(Document):
@@ -141,7 +140,7 @@ The :class:`~mongoengine.fields.ListField` object that is used to define a Post'
 takes a field object as its first argument --- this means that you can have
 lists of any type of field (including lists).
 
-.. note:: We don't need to modify the specialised post types as they all
+.. note:: We don't need to modify the specialized post types as they all
     inherit from :class:`Post`.
 
 Comments
@@ -149,12 +148,12 @@ Comments
 
 A comment is typically associated with *one* post. In a relational database, to
 display a post with its comments, we would have to retrieve the post from the
-database, then query the database again for the comments associated with the
+database and then query the database again for the comments associated with the
 post. This works, but there is no real reason to be storing the comments
 separately from their associated posts, other than to work around the
 relational model. Using MongoDB we can store the comments as a list of
 *embedded documents* directly on a post document. An embedded document should
-be treated no differently that a regular document; it just doesn't have its own
+be treated no differently than a regular document; it just doesn't have its own
 collection in the database. Using MongoEngine, we can define the structure of
 embedded documents, along with utility methods, in exactly the same way we do
 with regular documents::
@@ -207,7 +206,10 @@ object::
         ross.last_name = 'Lawley'
         ross.save()
 
-Now that we've got our user in the database, let's add a couple of posts::
+Assign another user to a variable called ``john``, just like we did above with
+``ross``.
+
+Now that we've got our users in the database, let's add a couple of posts::
 
     post1 = TextPost(title='Fun with MongoEngine', author=john)
     post1.content = 'Took a look at MongoEngine today, looks pretty cool.'
@@ -219,8 +221,8 @@ Now that we've got our user in the database, let's add a couple of posts::
     post2.tags = ['mongoengine']
     post2.save()
 
-.. note:: If you change a field on a object that has already been saved, then
-    call :meth:`save` again, the document will be updated.
+.. note:: If you change a field on an object that has already been saved and
+    then call :meth:`save` again, the document will be updated.
 
 Accessing our data
 ==================
@@ -232,17 +234,17 @@ used to access the documents in the database collection associated with that
 class. So let's see how we can get our posts' titles::
 
     for post in Post.objects:
-        print post.title
+        print(post.title)
 
 Retrieving type-specific information
 ------------------------------------
 
-This will print the titles of our posts, one on each line. But What if we want
+This will print the titles of our posts, one on each line. But what if we want
 to access the type-specific data (link_url, content, etc.)? One way is simply
 to use the :attr:`objects` attribute of a subclass of :class:`Post`::
 
     for post in TextPost.objects:
-        print post.content
+        print(post.content)
 
 Using TextPost's :attr:`objects` attribute only returns documents that were
 created using :class:`TextPost`. Actually, there is a more general rule here:
@@ -259,16 +261,14 @@ instances of :class:`Post` --- they were instances of the subclass of
 practice::
 
     for post in Post.objects:
-        print post.title
-        print '=' * len(post.title)
+        print(post.title)
+        print('=' * len(post.title))
 
         if isinstance(post, TextPost):
-            print post.content
+            print(post.content)
 
         if isinstance(post, LinkPost):
-            print 'Link:', post.link_url
-
-        print
+            print('Link: {}'.format(post.link_url))
 
 This would print the title of each post, followed by the content if it was a
 text post, and "Link: <url>" if it was a link post.
@@ -283,7 +283,7 @@ your query.  Let's adjust our query so that only posts with the tag "mongodb"
 are returned::
 
     for post in Post.objects(tags='mongodb'):
-        print post.title
+        print(post.title)
 
 There are also methods available on :class:`~mongoengine.queryset.QuerySet`
 objects that allow different results to be returned, for example, calling
@@ -292,11 +292,11 @@ the first matched by the query you provide. Aggregation functions may also be
 used on :class:`~mongoengine.queryset.QuerySet` objects::
 
     num_posts = Post.objects(tags='mongodb').count()
-    print 'Found %d posts with tag "mongodb"' % num_posts
+    print('Found {} posts with tag "mongodb"'.format(num_posts))
 
-Learning more about mongoengine
+Learning more about MongoEngine
 -------------------------------
 
-If you got this far you've made a great start, so well done!  The next step on
-your mongoengine journey is the `full user guide <guide/index.html>`_, where you
-can learn indepth about how to use mongoengine and mongodb.
+If you got this far you've made a great start, so well done! The next step on
+your MongoEngine journey is the `full user guide <guide/index.html>`_, where
+you can learn in-depth about how to use MongoEngine and MongoDB.

docs/upgrade.rst

@@ -2,6 +2,100 @@
 Upgrading
 #########
 
+Development
+***********
+(Fill this out whenever you introduce breaking changes to MongoEngine)
+
+URLField's constructor no longer takes `verify_exists`
+
+0.15.0
+******
+
+0.14.0
+******
+This release includes a few bug fixes and a significant code cleanup. The most
+important change is that `QuerySet.as_pymongo` no longer supports a
+`coerce_types` mode. If you used it in the past, a) please let us know of your
+use case, b) you'll need to override `as_pymongo` to get the desired outcome.
+
+This release also makes the EmbeddedDocument not hashable by default. If you
+use embedded documents in sets or dictionaries, you might have to override
+`__hash__` and implement a hashing logic specific to your use case. See #1528
+for the reason behind this change.
+
+0.13.0
+******
+This release adds Unicode support to the `EmailField` and changes its
+structure significantly. Previously, email addresses containing Unicode
+characters didn't work at all. Starting with v0.13.0, domains with Unicode
+characters are supported out of the box, meaning some emails that previously
+didn't pass validation now do. Make sure the rest of your application can
+accept such email addresses. Additionally, if you subclassed the `EmailField`
+in your application and overrode `EmailField.EMAIL_REGEX`, you will have to
+adjust your code to override `EmailField.USER_REGEX`, `EmailField.DOMAIN_REGEX`,
+and potentially `EmailField.UTF8_USER_REGEX`.
+
+0.12.0
+******
+This release includes various fixes for the `BaseQuerySet` methods and how they
+are chained together. Since version 0.10.1 applying limit/skip/hint/batch_size
+to an already-existing queryset wouldn't modify the underlying PyMongo cursor.
+This has been fixed now, so you'll need to make sure that your code didn't rely
+on the broken implementation.
+
+Additionally, a public `BaseQuerySet.clone_into` has been renamed to a private
+`_clone_into`. If you directly used that method in your code, you'll need to
+rename its occurrences.
+
+0.11.0
+******
+This release includes a major rehaul of MongoEngine's code quality and
+introduces a few breaking changes. It also touches many different parts of
+the package and although all the changes have been tested and scrutinized,
+you're encouraged to thorougly test the upgrade.
+
+First breaking change involves renaming `ConnectionError` to `MongoEngineConnectionError`.
+If you import or catch this exception, you'll need to rename it in your code.
+
+Second breaking change drops Python v2.6 support. If you run MongoEngine on
+that Python version, you'll need to upgrade it first.
+
+Third breaking change drops an old backward compatibility measure where
+`from mongoengine.base import ErrorClass` would work on top of
+`from mongoengine.errors import ErrorClass` (where `ErrorClass` is e.g.
+`ValidationError`). If you import any exceptions from `mongoengine.base`,
+change it to `mongoengine.errors`.
+
+0.10.8
+******
+This version fixed an issue where specifying a MongoDB URI host would override
+more information than it should. These changes are minor, but they still
+subtly modify the connection logic and thus you're encouraged to test your
+MongoDB connection before shipping v0.10.8 in production.
+
+0.10.7
+******
+
+`QuerySet.aggregate_sum` and `QuerySet.aggregate_average` are dropped. Use
+`QuerySet.sum` and `QuerySet.average` instead which use the aggreation framework
+by default from now on.
+
+0.9.0
+*****
+
+The 0.8.7 package on pypi was corrupted.  If upgrading from 0.8.7 to 0.9.0 please follow: ::
+
+    pip uninstall pymongo
+    pip uninstall mongoengine
+    pip install pymongo==2.8
+    pip install mongoengine
+
+0.8.7
+*****
+
+Calling reload on deleted / nonexistent documents now raises a DoesNotExist
+exception.
+
 
 0.8.2 to 0.8.3
 **************
@@ -257,7 +351,7 @@ update your code like so: ::
     [m for m in mammals]                                               # This will return all carnivores
 
 Len iterates the queryset
---------------------------
+-------------------------
 
 If you ever did `len(queryset)` it previously did a `count()` under the covers,
 this caused some unusual issues.  As `len(queryset)` is most often used by
@@ -270,7 +364,7 @@ queryset you should upgrade to use count::
     len(Animal.objects(type="mammal"))
 
     # New code
-    Animal.objects(type="mammal").count())
+    Animal.objects(type="mammal").count()
 
 
 .only() now inline with .exclude()

mongoengine/__init__.py

@@ -1,26 +1,37 @@
-import document
-from document import *
-import fields
-from fields import *
-import connection
-from connection import *
-import queryset
-from queryset import *
-import signals
-from signals import *
-from errors import *
-import errors
-import django
+# Import submodules so that we can expose their __all__
+from mongoengine import connection
+from mongoengine import document
+from mongoengine import errors
+from mongoengine import fields
+from mongoengine import queryset
+from mongoengine import signals
 
-__all__ = (list(document.__all__) + fields.__all__ + connection.__all__ +
-           list(queryset.__all__) + signals.__all__ + list(errors.__all__))
+# Import everything from each submodule so that it can be accessed via
+# mongoengine, e.g. instead of `from mongoengine.connection import connect`,
+# users can simply use `from mongoengine import connect`, or even
+# `from mongoengine import *` and then `connect('testdb')`.
+from mongoengine.connection import *
+from mongoengine.document import *
+from mongoengine.errors import *
+from mongoengine.fields import *
+from mongoengine.queryset import *
+from mongoengine.signals import *
 
-VERSION = (0, 8, 6)
+
+__all__ = (list(document.__all__) + list(fields.__all__) +
+           list(connection.__all__) + list(queryset.__all__) +
+           list(signals.__all__) + list(errors.__all__))
+
+
+VERSION = (0, 18, 2)
 
 
 def get_version():
-    if isinstance(VERSION[-1], basestring):
-        return '.'.join(map(str, VERSION[:-1])) + VERSION[-1]
+    """Return the VERSION as a string.
+
+    For example, if `VERSION == (0, 10, 7)`, return '0.10.7'.
+    """
     return '.'.join(map(str, VERSION))
 
+
 __version__ = get_version()

mongoengine/base/__init__.py

@@ -1,8 +1,28 @@
+# Base module is split into several files for convenience. Files inside of
+# this module should import from a specific submodule (e.g.
+# `from mongoengine.base.document import BaseDocument`), but all of the
+# other modules should import directly from the top-level module (e.g.
+# `from mongoengine.base import BaseDocument`). This approach is cleaner and
+# also helps with cyclical import errors.
 from mongoengine.base.common import *
 from mongoengine.base.datastructures import *
 from mongoengine.base.document import *
 from mongoengine.base.fields import *
 from mongoengine.base.metaclasses import *
 
-# Help with backwards compatibility
-from mongoengine.errors import *
+__all__ = (
+    # common
+    'UPDATE_OPERATORS', '_document_registry', 'get_document',
+
+    # datastructures
+    'BaseDict', 'BaseList', 'EmbeddedDocumentList', 'LazyReference',
+
+    # document
+    'BaseDocument',
+
+    # fields
+    'BaseField', 'ComplexBaseField', 'ObjectIdField', 'GeoJsonBaseField',
+
+    # metaclasses
+    'DocumentMetaclass', 'TopLevelDocumentMetaclass'
+)

mongoengine/base/common.py

@@ -1,19 +1,25 @@
 from mongoengine.errors import NotRegistered
 
-__all__ = ('ALLOW_INHERITANCE', 'get_document', '_document_registry')
+__all__ = ('UPDATE_OPERATORS', 'get_document', '_document_registry')
+
+
+UPDATE_OPERATORS = {'set', 'unset', 'inc', 'dec', 'mul',
+                    'pop', 'push', 'push_all', 'pull',
+                    'pull_all', 'add_to_set', 'set_on_insert',
+                    'min', 'max', 'rename'}
 
-ALLOW_INHERITANCE = False
 
 _document_registry = {}
 
 
 def get_document(name):
+    """Get a registered Document class by name."""
     doc = _document_registry.get(name, None)
     if not doc:
         # Possible old style name
         single_end = name.split('.')[-1]
         compound_end = '.%s' % single_end
-        possible_match = [k for k in _document_registry.keys()
+        possible_match = [k for k in _document_registry
                           if k.endswith(compound_end) or k == single_end]
         if len(possible_match) == 1:
             doc = _document_registry.get(possible_match.pop(), None)
@@ -24,3 +30,12 @@ def get_document(name):
             been imported?
         """.strip() % name)
     return doc
+
+
+def _get_documents_by_db(connection_alias, default_connection_alias):
+    """Get all registered Documents class attached to a given database"""
+    def get_doc_alias(doc_cls):
+        return doc_cls._meta.get('db_alias', default_connection_alias)
+
+    return [doc_cls for doc_cls in _document_registry.values()
+            if get_doc_alias(doc_cls) == connection_alias]

mongoengine/base/datastructures.py

@@ -1,50 +1,73 @@
 import weakref
-from mongoengine.common import _import_class
 
-__all__ = ("BaseDict", "BaseList")
+from bson import DBRef
+import six
+from six import iteritems
+
+from mongoengine.common import _import_class
+from mongoengine.errors import DoesNotExist, MultipleObjectsReturned
+
+__all__ = ('BaseDict', 'StrictDict', 'BaseList', 'EmbeddedDocumentList', 'LazyReference')
+
+
+def mark_as_changed_wrapper(parent_method):
+    """Decorator that ensures _mark_as_changed method gets called."""
+    def wrapper(self, *args, **kwargs):
+        # Can't use super() in the decorator.
+        result = parent_method(self, *args, **kwargs)
+        self._mark_as_changed()
+        return result
+    return wrapper
+
+
+def mark_key_as_changed_wrapper(parent_method):
+    """Decorator that ensures _mark_as_changed method gets called with the key argument"""
+    def wrapper(self, key, *args, **kwargs):
+        # Can't use super() in the decorator.
+        result = parent_method(self, key, *args, **kwargs)
+        self._mark_as_changed(key)
+        return result
+    return wrapper
 
 
 class BaseDict(dict):
-    """A special dict so we can watch any changes
-    """
+    """A special dict so we can watch any changes."""
 
     _dereferenced = False
     _instance = None
     _name = None
 
     def __init__(self, dict_items, instance, name):
-        Document = _import_class('Document')
-        EmbeddedDocument = _import_class('EmbeddedDocument')
+        BaseDocument = _import_class('BaseDocument')
 
-        if isinstance(instance, (Document, EmbeddedDocument)):
+        if isinstance(instance, BaseDocument):
             self._instance = weakref.proxy(instance)
         self._name = name
-        return super(BaseDict, self).__init__(dict_items)
+        super(BaseDict, self).__init__(dict_items)
 
-    def __getitem__(self, *args, **kwargs):
-        value = super(BaseDict, self).__getitem__(*args, **kwargs)
+    def get(self, key, default=None):
+        # get does not use __getitem__ by default so we must override it as well
+        try:
+            return self.__getitem__(key)
+        except KeyError:
+            return default
+
+    def __getitem__(self, key):
+        value = super(BaseDict, self).__getitem__(key)
 
         EmbeddedDocument = _import_class('EmbeddedDocument')
         if isinstance(value, EmbeddedDocument) and value._instance is None:
             value._instance = self._instance
+        elif isinstance(value, dict) and not isinstance(value, BaseDict):
+            value = BaseDict(value, None, '%s.%s' % (self._name, key))
+            super(BaseDict, self).__setitem__(key, value)
+            value._instance = self._instance
+        elif isinstance(value, list) and not isinstance(value, BaseList):
+            value = BaseList(value, None, '%s.%s' % (self._name, key))
+            super(BaseDict, self).__setitem__(key, value)
+            value._instance = self._instance
         return value
 
-    def __setitem__(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseDict, self).__setitem__(*args, **kwargs)
-
-    def __delete__(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseDict, self).__delete__(*args, **kwargs)
-
-    def __delitem__(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseDict, self).__delitem__(*args, **kwargs)
-
-    def __delattr__(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseDict, self).__delattr__(*args, **kwargs)
-
     def __getstate__(self):
         self.instance = None
         self._dereferenced = False
@@ -54,67 +77,64 @@ class BaseDict(dict):
         self = state
         return self
 
-    def clear(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseDict, self).clear(*args, **kwargs)
+    __setitem__ = mark_key_as_changed_wrapper(dict.__setitem__)
+    __delattr__ = mark_key_as_changed_wrapper(dict.__delattr__)
+    __delitem__ = mark_key_as_changed_wrapper(dict.__delitem__)
+    pop = mark_as_changed_wrapper(dict.pop)
+    clear = mark_as_changed_wrapper(dict.clear)
+    update = mark_as_changed_wrapper(dict.update)
+    popitem = mark_as_changed_wrapper(dict.popitem)
+    setdefault = mark_as_changed_wrapper(dict.setdefault)
 
-    def pop(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseDict, self).pop(*args, **kwargs)
-
-    def popitem(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseDict, self).popitem(*args, **kwargs)
-
-    def update(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseDict, self).update(*args, **kwargs)
-
-    def _mark_as_changed(self):
+    def _mark_as_changed(self, key=None):
         if hasattr(self._instance, '_mark_as_changed'):
-            self._instance._mark_as_changed(self._name)
+            if key:
+                self._instance._mark_as_changed('%s.%s' % (self._name, key))
+            else:
+                self._instance._mark_as_changed(self._name)
 
 
 class BaseList(list):
-    """A special list so we can watch any changes
-    """
+    """A special list so we can watch any changes."""
 
     _dereferenced = False
     _instance = None
     _name = None
 
     def __init__(self, list_items, instance, name):
-        Document = _import_class('Document')
-        EmbeddedDocument = _import_class('EmbeddedDocument')
+        BaseDocument = _import_class('BaseDocument')
 
-        if isinstance(instance, (Document, EmbeddedDocument)):
+        if isinstance(instance, BaseDocument):
             self._instance = weakref.proxy(instance)
         self._name = name
-        return super(BaseList, self).__init__(list_items)
+        super(BaseList, self).__init__(list_items)
 
-    def __getitem__(self, *args, **kwargs):
-        value = super(BaseList, self).__getitem__(*args, **kwargs)
+    def __getitem__(self, key):
+        value = super(BaseList, self).__getitem__(key)
+
+        if isinstance(key, slice):
+            # When receiving a slice operator, we don't convert the structure and bind
+            # to parent's instance. This is buggy for now but would require more work to be handled properly
+            return value
 
         EmbeddedDocument = _import_class('EmbeddedDocument')
         if isinstance(value, EmbeddedDocument) and value._instance is None:
             value._instance = self._instance
+        elif isinstance(value, dict) and not isinstance(value, BaseDict):
+            # Replace dict by BaseDict
+            value = BaseDict(value, None, '%s.%s' % (self._name, key))
+            super(BaseList, self).__setitem__(key, value)
+            value._instance = self._instance
+        elif isinstance(value, list) and not isinstance(value, BaseList):
+            # Replace list by BaseList
+            value = BaseList(value, None, '%s.%s' % (self._name, key))
+            super(BaseList, self).__setitem__(key, value)
+            value._instance = self._instance
         return value
 
-    def __setitem__(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).__setitem__(*args, **kwargs)
-
-    def __delitem__(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).__delitem__(*args, **kwargs)
-
-    def __setslice__(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).__setslice__(*args, **kwargs)
-
-    def __delslice__(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).__delslice__(*args, **kwargs)
+    def __iter__(self):
+        for v in super(BaseList, self).__iter__():
+            yield v
 
     def __getstate__(self):
         self.instance = None
@@ -125,34 +145,332 @@ class BaseList(list):
         self = state
         return self
 
-    def append(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).append(*args, **kwargs)
+    def __setitem__(self, key, value):
+        changed_key = key
+        if isinstance(key, slice):
+            # In case of slice, we don't bother to identify the exact elements being updated
+            # instead, we simply marks the whole list as changed
+            changed_key = None
 
-    def extend(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).extend(*args, **kwargs)
+        result = super(BaseList, self).__setitem__(key, value)
+        self._mark_as_changed(changed_key)
+        return result
 
-    def insert(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).insert(*args, **kwargs)
+    append = mark_as_changed_wrapper(list.append)
+    extend = mark_as_changed_wrapper(list.extend)
+    insert = mark_as_changed_wrapper(list.insert)
+    pop = mark_as_changed_wrapper(list.pop)
+    remove = mark_as_changed_wrapper(list.remove)
+    reverse = mark_as_changed_wrapper(list.reverse)
+    sort = mark_as_changed_wrapper(list.sort)
+    __delitem__ = mark_as_changed_wrapper(list.__delitem__)
+    __iadd__ = mark_as_changed_wrapper(list.__iadd__)
+    __imul__ = mark_as_changed_wrapper(list.__imul__)
 
-    def pop(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).pop(*args, **kwargs)
+    if six.PY2:
+        # Under py3 __setslice__, __delslice__ and __getslice__
+        # are replaced by __setitem__, __delitem__ and __getitem__ with a slice as parameter
+        # so we mimic this under python 2
+        def __setslice__(self, i, j, sequence):
+            return self.__setitem__(slice(i, j), sequence)
 
-    def remove(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).remove(*args, **kwargs)
+        def __delslice__(self, i, j):
+            return self.__delitem__(slice(i, j))
 
-    def reverse(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).reverse(*args, **kwargs)
+        def __getslice__(self, i, j):
+            return self.__getitem__(slice(i, j))
 
-    def sort(self, *args, **kwargs):
-        self._mark_as_changed()
-        return super(BaseList, self).sort(*args, **kwargs)
-
-    def _mark_as_changed(self):
+    def _mark_as_changed(self, key=None):
         if hasattr(self._instance, '_mark_as_changed'):
-            self._instance._mark_as_changed(self._name)
+            if key:
+                self._instance._mark_as_changed(
+                    '%s.%s' % (self._name, key % len(self))
+                )
+            else:
+                self._instance._mark_as_changed(self._name)
+
+
+class EmbeddedDocumentList(BaseList):
+
+    def __init__(self, list_items, instance, name):
+        super(EmbeddedDocumentList, self).__init__(list_items, instance, name)
+        self._instance = instance
+
+    @classmethod
+    def __match_all(cls, embedded_doc, kwargs):
+        """Return True if a given embedded doc matches all the filter
+        kwargs. If it doesn't return False.
+        """
+        for key, expected_value in kwargs.items():
+            doc_val = getattr(embedded_doc, key)
+            if doc_val != expected_value and six.text_type(doc_val) != expected_value:
+                return False
+        return True
+
+    @classmethod
+    def __only_matches(cls, embedded_docs, kwargs):
+        """Return embedded docs that match the filter kwargs."""
+        if not kwargs:
+            return embedded_docs
+        return [doc for doc in embedded_docs if cls.__match_all(doc, kwargs)]
+
+    def filter(self, **kwargs):
+        """
+        Filters the list by only including embedded documents with the
+        given keyword arguments.
+
+        This method only supports simple comparison (e.g: .filter(name='John Doe'))
+        and does not support operators like __gte, __lte, __icontains like queryset.filter does
+
+        :param kwargs: The keyword arguments corresponding to the fields to
+         filter on. *Multiple arguments are treated as if they are ANDed
+         together.*
+        :return: A new ``EmbeddedDocumentList`` containing the matching
+         embedded documents.
+
+        Raises ``AttributeError`` if a given keyword is not a valid field for
+        the embedded document class.
+        """
+        values = self.__only_matches(self, kwargs)
+        return EmbeddedDocumentList(values, self._instance, self._name)
+
+    def exclude(self, **kwargs):
+        """
+        Filters the list by excluding embedded documents with the given
+        keyword arguments.
+
+        :param kwargs: The keyword arguments corresponding to the fields to
+         exclude on. *Multiple arguments are treated as if they are ANDed
+         together.*
+        :return: A new ``EmbeddedDocumentList`` containing the non-matching
+         embedded documents.
+
+        Raises ``AttributeError`` if a given keyword is not a valid field for
+        the embedded document class.
+        """
+        exclude = self.__only_matches(self, kwargs)
+        values = [item for item in self if item not in exclude]
+        return EmbeddedDocumentList(values, self._instance, self._name)
+
+    def count(self):
+        """
+        The number of embedded documents in the list.
+
+        :return: The length of the list, equivalent to the result of ``len()``.
+        """
+        return len(self)
+
+    def get(self, **kwargs):
+        """
+        Retrieves an embedded document determined by the given keyword
+        arguments.
+
+        :param kwargs: The keyword arguments corresponding to the fields to
+         search on. *Multiple arguments are treated as if they are ANDed
+         together.*
+        :return: The embedded document matched by the given keyword arguments.
+
+        Raises ``DoesNotExist`` if the arguments used to query an embedded
+        document returns no results. ``MultipleObjectsReturned`` if more
+        than one result is returned.
+        """
+        values = self.__only_matches(self, kwargs)
+        if len(values) == 0:
+            raise DoesNotExist(
+                '%s matching query does not exist.' % self._name
+            )
+        elif len(values) > 1:
+            raise MultipleObjectsReturned(
+                '%d items returned, instead of 1' % len(values)
+            )
+
+        return values[0]
+
+    def first(self):
+        """Return the first embedded document in the list, or ``None``
+        if empty.
+        """
+        if len(self) > 0:
+            return self[0]
+
+    def create(self, **values):
+        """
+        Creates a new embedded document and saves it to the database.
+
+        .. note::
+            The embedded document changes are not automatically saved
+            to the database after calling this method.
+
+        :param values: A dictionary of values for the embedded document.
+        :return: The new embedded document instance.
+        """
+        name = self._name
+        EmbeddedClass = self._instance._fields[name].field.document_type_obj
+        self._instance[self._name].append(EmbeddedClass(**values))
+
+        return self._instance[self._name][-1]
+
+    def save(self, *args, **kwargs):
+        """
+        Saves the ancestor document.
+
+        :param args: Arguments passed up to the ancestor Document's save
+         method.
+        :param kwargs: Keyword arguments passed up to the ancestor Document's
+         save method.
+        """
+        self._instance.save(*args, **kwargs)
+
+    def delete(self):
+        """
+        Deletes the embedded documents from the database.
+
+        .. note::
+            The embedded document changes are not automatically saved
+            to the database after calling this method.
+
+        :return: The number of entries deleted.
+        """
+        values = list(self)
+        for item in values:
+            self._instance[self._name].remove(item)
+
+        return len(values)
+
+    def update(self, **update):
+        """
+        Updates the embedded documents with the given replacement values. This
+        function does not support mongoDB update operators such as ``inc__``.
+
+        .. note::
+            The embedded document changes are not automatically saved
+            to the database after calling this method.
+
+        :param update: A dictionary of update values to apply to each
+         embedded document.
+        :return: The number of entries updated.
+        """
+        if len(update) == 0:
+            return 0
+        values = list(self)
+        for item in values:
+            for k, v in update.items():
+                setattr(item, k, v)
+
+        return len(values)
+
+
+class StrictDict(object):
+    __slots__ = ()
+    _special_fields = {'get', 'pop', 'iteritems', 'items', 'keys', 'create'}
+    _classes = {}
+
+    def __init__(self, **kwargs):
+        for k, v in iteritems(kwargs):
+            setattr(self, k, v)
+
+    def __getitem__(self, key):
+        key = '_reserved_' + key if key in self._special_fields else key
+        try:
+            return getattr(self, key)
+        except AttributeError:
+            raise KeyError(key)
+
+    def __setitem__(self, key, value):
+        key = '_reserved_' + key if key in self._special_fields else key
+        return setattr(self, key, value)
+
+    def __contains__(self, key):
+        return hasattr(self, key)
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def pop(self, key, default=None):
+        v = self.get(key, default)
+        try:
+            delattr(self, key)
+        except AttributeError:
+            pass
+        return v
+
+    def iteritems(self):
+        for key in self:
+            yield key, self[key]
+
+    def items(self):
+        return [(k, self[k]) for k in iter(self)]
+
+    def iterkeys(self):
+        return iter(self)
+
+    def keys(self):
+        return list(iter(self))
+
+    def __iter__(self):
+        return (key for key in self.__slots__ if hasattr(self, key))
+
+    def __len__(self):
+        return len(list(iteritems(self)))
+
+    def __eq__(self, other):
+        return self.items() == other.items()
+
+    def __ne__(self, other):
+        return self.items() != other.items()
+
+    @classmethod
+    def create(cls, allowed_keys):
+        allowed_keys_tuple = tuple(('_reserved_' + k if k in cls._special_fields else k) for k in allowed_keys)
+        allowed_keys = frozenset(allowed_keys_tuple)
+        if allowed_keys not in cls._classes:
+            class SpecificStrictDict(cls):
+                __slots__ = allowed_keys_tuple
+
+                def __repr__(self):
+                    return '{%s}' % ', '.join('"{0!s}": {1!r}'.format(k, v) for k, v in self.items())
+
+            cls._classes[allowed_keys] = SpecificStrictDict
+        return cls._classes[allowed_keys]
+
+
+class LazyReference(DBRef):
+    __slots__ = ('_cached_doc', 'passthrough', 'document_type')
+
+    def fetch(self, force=False):
+        if not self._cached_doc or force:
+            self._cached_doc = self.document_type.objects.get(pk=self.pk)
+            if not self._cached_doc:
+                raise DoesNotExist('Trying to dereference unknown document %s' % (self))
+        return self._cached_doc
+
+    @property
+    def pk(self):
+        return self.id
+
+    def __init__(self, document_type, pk, cached_doc=None, passthrough=False):
+        self.document_type = document_type
+        self._cached_doc = cached_doc
+        self.passthrough = passthrough
+        super(LazyReference, self).__init__(self.document_type._get_collection_name(), pk)
+
+    def __getitem__(self, name):
+        if not self.passthrough:
+            raise KeyError()
+        document = self.fetch()
+        return document[name]
+
+    def __getattr__(self, name):
+        if not object.__getattribute__(self, 'passthrough'):
+            raise AttributeError()
+        document = self.fetch()
+        try:
+            return document[name]
+        except KeyError:
+            raise AttributeError()
+
+    def __repr__(self):
+        return "<LazyReference(%s, %r)>" % (self.document_type, self.pk)

mongoengine/base/fields.py

@@ -4,14 +4,17 @@ import weakref
 
 from bson import DBRef, ObjectId, SON
 import pymongo
+import six
+from six import iteritems
 
+from mongoengine.base.common import UPDATE_OPERATORS
+from mongoengine.base.datastructures import (BaseDict, BaseList,
+                                             EmbeddedDocumentList)
 from mongoengine.common import _import_class
-from mongoengine.errors import ValidationError
+from mongoengine.errors import DeprecatedError, ValidationError
 
-from mongoengine.base.common import ALLOW_INHERITANCE
-from mongoengine.base.datastructures import BaseDict, BaseList
-
-__all__ = ("BaseField", "ComplexBaseField", "ObjectIdField", "GeoJsonBaseField")
+__all__ = ('BaseField', 'ComplexBaseField', 'ObjectIdField',
+           'GeoJsonBaseField')
 
 
 class BaseField(object):
@@ -20,7 +23,6 @@ class BaseField(object):
 
     .. versionchanged:: 0.5 - added verbose and help text
     """
-
     name = None
     _geo_index = False
     _auto_gen = False  # Call `generate` to generate a value
@@ -34,34 +36,39 @@ class BaseField(object):
 
     def __init__(self, db_field=None, name=None, required=False, default=None,
                  unique=False, unique_with=None, primary_key=False,
-                 validation=None, choices=None, verbose_name=None,
-                 help_text=None):
+                 validation=None, choices=None, null=False, sparse=False,
+                 **kwargs):
         """
         :param db_field: The database field to store this field in
             (defaults to the name of the field)
-        :param name: Depreciated - use db_field
+        :param name: Deprecated - use db_field
         :param required: If the field is required. Whether it has to have a
             value or not. Defaults to False.
         :param default: (optional) The default value for this field if no value
-            has been set (or if the value has been unset).  It Can be a
+            has been set (or if the value has been unset).  It can be a
             callable.
         :param unique: Is the field value unique or not.  Defaults to False.
         :param unique_with: (optional) The other field this field should be
             unique with.
         :param primary_key: Mark this field as the primary key. Defaults to False.
         :param validation: (optional) A callable to validate the value of the
-            field.  Generally this is deprecated in favour of the
-            `FIELD.validate` method
+            field.  The callable takes the value as parameter and should raise
+            a ValidationError if validation fails
         :param choices: (optional) The valid choices
-        :param verbose_name: (optional)  The verbose name for the field.
-            Designed to be human readable and is often used when generating
-            model forms from the document model.
-        :param help_text: (optional) The help text for this field and is often
-            used when generating model forms from the document model.
+        :param null: (optional) If the field value can be null. If no and there is a default value
+            then the default value is set
+        :param sparse: (optional) `sparse=True` combined with `unique=True` and `required=False`
+            means that uniqueness won't be enforced for `None` values
+        :param **kwargs: (optional) Arbitrary indirection-free metadata for
+            this field can be supplied as additional keyword arguments and
+            accessed as attributes of the field. Must not conflict with any
+            existing attributes. Common metadata includes `verbose_name` and
+            `help_text`.
         """
         self.db_field = (db_field or name) if not primary_key else '_id'
+
         if name:
-            msg = "Fields' 'name' attribute deprecated in favour of 'db_field'"
+            msg = 'Field\'s "name" attribute deprecated in favour of "db_field"'
             warnings.warn(msg, DeprecationWarning)
         self.required = required or primary_key
         self.default = default
@@ -70,8 +77,37 @@ class BaseField(object):
         self.primary_key = primary_key
         self.validation = validation
         self.choices = choices
-        self.verbose_name = verbose_name
-        self.help_text = help_text
+        self.null = null
+        self.sparse = sparse
+        self._owner_document = None
+
+        # Make sure db_field is a string (if it's explicitly defined).
+        if (
+            self.db_field is not None and
+            not isinstance(self.db_field, six.string_types)
+        ):
+            raise TypeError('db_field should be a string.')
+
+        # Make sure db_field doesn't contain any forbidden characters.
+        if isinstance(self.db_field, six.string_types) and (
+            '.' in self.db_field or
+            '\0' in self.db_field or
+            self.db_field.startswith('$')
+        ):
+            raise ValueError(
+                'field names cannot contain dots (".") or null characters '
+                '("\\0"), and they must not start with a dollar sign ("$").'
+            )
+
+        # Detect and report conflicts between metadata and base properties.
+        conflicts = set(dir(self)) & set(kwargs)
+        if conflicts:
+            raise TypeError('%s already has attribute(s): %s' % (
+                self.__class__.__name__, ', '.join(conflicts)))
+
+        # Assign metadata to the instance
+        # This efficient method is available because no __slots__ are defined.
+        self.__dict__.update(kwargs)
 
         # Adjust the appropriate creation counter, and save our local copy.
         if self.db_field == '_id':
@@ -92,87 +128,134 @@ class BaseField(object):
         return instance._data.get(self.name)
 
     def __set__(self, instance, value):
-        """Descriptor for assigning a value to a field in a document.
-        """
-
-        # If setting to None and theres a default
-        # Then set the value to the default value
-        if value is None and self.default is not None:
-            value = self.default
-            if callable(value):
-                value = value()
+        """Descriptor for assigning a value to a field in a document."""
+        # If setting to None and there is a default value provided for this
+        # field, then set the value to the default value.
+        if value is None:
+            if self.null:
+                value = None
+            elif self.default is not None:
+                value = self.default
+                if callable(value):
+                    value = value()
 
         if instance._initialised:
             try:
-                if (self.name not in instance._data or
-                   instance._data[self.name] != value):
+                value_has_changed = (
+                    self.name not in instance._data or
+                    instance._data[self.name] != value
+                )
+                if value_has_changed:
                     instance._mark_as_changed(self.name)
-            except:
-                # Values cant be compared eg: naive and tz datetimes
-                # So mark it as changed
+            except Exception:
+                # Some values can't be compared and throw an error when we
+                # attempt to do so (e.g. tz-naive and tz-aware datetimes).
+                # Mark the field as changed in such cases.
                 instance._mark_as_changed(self.name)
 
         EmbeddedDocument = _import_class('EmbeddedDocument')
-        if isinstance(value, EmbeddedDocument) and value._instance is None:
+        if isinstance(value, EmbeddedDocument):
             value._instance = weakref.proxy(instance)
+        elif isinstance(value, (list, tuple)):
+            for v in value:
+                if isinstance(v, EmbeddedDocument):
+                    v._instance = weakref.proxy(instance)
+
         instance._data[self.name] = value
 
-    def error(self, message="", errors=None, field_name=None):
-        """Raises a ValidationError.
-        """
+    def error(self, message='', errors=None, field_name=None):
+        """Raise a ValidationError."""
         field_name = field_name if field_name else self.name
         raise ValidationError(message, errors=errors, field_name=field_name)
 
     def to_python(self, value):
-        """Convert a MongoDB-compatible type to a Python type.
-        """
+        """Convert a MongoDB-compatible type to a Python type."""
         return value
 
     def to_mongo(self, value):
-        """Convert a Python type to a MongoDB-compatible type.
-        """
+        """Convert a Python type to a MongoDB-compatible type."""
         return self.to_python(value)
 
+    def _to_mongo_safe_call(self, value, use_db_field=True, fields=None):
+        """Helper method to call to_mongo with proper inputs."""
+        f_inputs = self.to_mongo.__code__.co_varnames
+        ex_vars = {}
+        if 'fields' in f_inputs:
+            ex_vars['fields'] = fields
+
+        if 'use_db_field' in f_inputs:
+            ex_vars['use_db_field'] = use_db_field
+
+        return self.to_mongo(value, **ex_vars)
+
     def prepare_query_value(self, op, value):
-        """Prepare a value that is being used in a query for PyMongo.
-        """
+        """Prepare a value that is being used in a query for PyMongo."""
+        if op in UPDATE_OPERATORS:
+            self.validate(value)
         return value
 
     def validate(self, value, clean=True):
-        """Perform validation on a value.
-        """
+        """Perform validation on a value."""
         pass
 
-    def _validate(self, value, **kwargs):
+    def _validate_choices(self, value):
         Document = _import_class('Document')
         EmbeddedDocument = _import_class('EmbeddedDocument')
-        # check choices
+
+        choice_list = self.choices
+        if isinstance(next(iter(choice_list)), (list, tuple)):
+            # next(iter) is useful for sets
+            choice_list = [k for k, _ in choice_list]
+
+        # Choices which are other types of Documents
+        if isinstance(value, (Document, EmbeddedDocument)):
+            if not any(isinstance(value, c) for c in choice_list):
+                self.error(
+                    'Value must be an instance of %s' % (
+                        six.text_type(choice_list)
+                    )
+                )
+        # Choices which are types other than Documents
+        else:
+            values = value if isinstance(value, (list, tuple)) else [value]
+            if len(set(values) - set(choice_list)):
+                self.error('Value must be one of %s' % six.text_type(choice_list))
+
+    def _validate(self, value, **kwargs):
+        # Check the Choices Constraint
         if self.choices:
-            is_cls = isinstance(value, (Document, EmbeddedDocument))
-            value_to_check = value.__class__ if is_cls else value
-            err_msg = 'an instance' if is_cls else 'one'
-            if isinstance(self.choices[0], (list, tuple)):
-                option_keys = [k for k, v in self.choices]
-                if value_to_check not in option_keys:
-                    msg = ('Value must be %s of %s' %
-                           (err_msg, unicode(option_keys)))
-                    self.error(msg)
-            elif value_to_check not in self.choices:
-                msg = ('Value must be %s of %s' %
-                       (err_msg, unicode(self.choices)))
-                self.error(msg)
+            self._validate_choices(value)
 
         # check validation argument
         if self.validation is not None:
             if callable(self.validation):
-                if not self.validation(value):
-                    self.error('Value does not match custom validation method')
+                try:
+                    # breaking change of 0.18
+                    # Get rid of True/False-type return for the validation method
+                    # in favor of having validation raising a ValidationError
+                    ret = self.validation(value)
+                    if ret is not None:
+                        raise DeprecatedError('validation argument for `%s` must not return anything, '
+                                              'it should raise a ValidationError if validation fails' % self.name)
+                except ValidationError as ex:
+                    self.error(str(ex))
             else:
-                raise ValueError('validation argument for "%s" must be a '
+                raise ValueError('validation argument for `"%s"` must be a '
                                  'callable.' % self.name)
 
         self.validate(value, **kwargs)
 
+    @property
+    def owner_document(self):
+        return self._owner_document
+
+    def _set_owner_document(self, owner_document):
+        self._owner_document = owner_document
+
+    @owner_document.setter
+    def owner_document(self, owner_document):
+        self._set_owner_document(owner_document)
+
 
 class ComplexBaseField(BaseField):
     """Handles complex fields, such as lists / dictionaries.
@@ -187,41 +270,51 @@ class ComplexBaseField(BaseField):
     field = None
 
     def __get__(self, instance, owner):
-        """Descriptor to automatically dereference references.
-        """
+        """Descriptor to automatically dereference references."""
         if instance is None:
             # Document class being used rather than a document object
             return self
 
         ReferenceField = _import_class('ReferenceField')
         GenericReferenceField = _import_class('GenericReferenceField')
-        dereference = (self._auto_dereference and
+        EmbeddedDocumentListField = _import_class('EmbeddedDocumentListField')
+
+        auto_dereference = instance._fields[self.name]._auto_dereference
+
+        dereference = (auto_dereference and
                        (self.field is None or isinstance(self.field,
-                        (GenericReferenceField, ReferenceField))))
+                                                         (GenericReferenceField, ReferenceField))))
 
-        _dereference = _import_class("DeReference")()
+        _dereference = _import_class('DeReference')()
 
-        self._auto_dereference = instance._fields[self.name]._auto_dereference
-        if instance._initialised and dereference and instance._data.get(self.name):
+        if (instance._initialised and
+                dereference and
+                instance._data.get(self.name) and
+                not getattr(instance._data[self.name], '_dereferenced', False)):
             instance._data[self.name] = _dereference(
                 instance._data.get(self.name), max_depth=1, instance=instance,
                 name=self.name
             )
+            if hasattr(instance._data[self.name], '_dereferenced'):
+                instance._data[self.name]._dereferenced = True
 
         value = super(ComplexBaseField, self).__get__(instance, owner)
 
         # Convert lists / values so we can watch for any changes on them
-        if (isinstance(value, (list, tuple)) and
-           not isinstance(value, BaseList)):
-            value = BaseList(value, instance, self.name)
+        if isinstance(value, (list, tuple)):
+            if (issubclass(type(self), EmbeddedDocumentListField) and
+                    not isinstance(value, EmbeddedDocumentList)):
+                value = EmbeddedDocumentList(value, instance, self.name)
+            elif not isinstance(value, BaseList):
+                value = BaseList(value, instance, self.name)
             instance._data[self.name] = value
         elif isinstance(value, dict) and not isinstance(value, BaseDict):
             value = BaseDict(value, instance, self.name)
             instance._data[self.name] = value
 
-        if (self._auto_dereference and instance._initialised and
-           isinstance(value, (BaseList, BaseDict))
-           and not value._dereferenced):
+        if (auto_dereference and instance._initialised and
+                isinstance(value, (BaseList, BaseDict)) and
+                not value._dereferenced):
             value = _dereference(
                 value, max_depth=1, instance=instance, name=self.name
             )
@@ -231,28 +324,32 @@ class ComplexBaseField(BaseField):
         return value
 
     def to_python(self, value):
-        """Convert a MongoDB-compatible type to a Python type.
-        """
-        Document = _import_class('Document')
-
-        if isinstance(value, basestring):
+        """Convert a MongoDB-compatible type to a Python type."""
+        if isinstance(value, six.string_types):
             return value
 
         if hasattr(value, 'to_python'):
             return value.to_python()
 
+        BaseDocument = _import_class('BaseDocument')
+        if isinstance(value, BaseDocument):
+            # Something is wrong, return the value as it is
+            return value
+
         is_list = False
         if not hasattr(value, 'items'):
             try:
                 is_list = True
-                value = dict([(k, v) for k, v in enumerate(value)])
+                value = {idx: v for idx, v in enumerate(value)}
             except TypeError:  # Not iterable return the value
                 return value
 
         if self.field:
-            value_dict = dict([(key, self.field.to_python(item))
-                               for key, item in value.items()])
+            self.field._auto_dereference = self._auto_dereference
+            value_dict = {key: self.field.to_python(item)
+                          for key, item in value.items()}
         else:
+            Document = _import_class('Document')
             value_dict = {}
             for k, v in value.items():
                 if isinstance(v, Document):
@@ -268,27 +365,26 @@ class ComplexBaseField(BaseField):
                     value_dict[k] = self.to_python(v)
 
         if is_list:  # Convert back to a list
-            return [v for k, v in sorted(value_dict.items(),
+            return [v for _, v in sorted(value_dict.items(),
                                          key=operator.itemgetter(0))]
         return value_dict
 
-    def to_mongo(self, value):
-        """Convert a Python type to a MongoDB-compatible type.
-        """
-        Document = _import_class("Document")
-        EmbeddedDocument = _import_class("EmbeddedDocument")
-        GenericReferenceField = _import_class("GenericReferenceField")
+    def to_mongo(self, value, use_db_field=True, fields=None):
+        """Convert a Python type to a MongoDB-compatible type."""
+        Document = _import_class('Document')
+        EmbeddedDocument = _import_class('EmbeddedDocument')
+        GenericReferenceField = _import_class('GenericReferenceField')
 
-        if isinstance(value, basestring):
+        if isinstance(value, six.string_types):
             return value
 
         if hasattr(value, 'to_mongo'):
             if isinstance(value, Document):
                 return GenericReferenceField().to_mongo(value)
             cls = value.__class__
-            val = value.to_mongo()
-            # If we its a document thats not inherited add _cls
-            if (isinstance(value, EmbeddedDocument)):
+            val = value.to_mongo(use_db_field, fields)
+            # If it's a document that is not inherited add _cls
+            if isinstance(value, EmbeddedDocument):
                 val['_cls'] = cls.__name__
             return val
 
@@ -296,16 +392,18 @@ class ComplexBaseField(BaseField):
         if not hasattr(value, 'items'):
             try:
                 is_list = True
-                value = dict([(k, v) for k, v in enumerate(value)])
+                value = {k: v for k, v in enumerate(value)}
             except TypeError:  # Not iterable return the value
                 return value
 
         if self.field:
-            value_dict = dict([(key, self.field.to_mongo(item))
-                               for key, item in value.iteritems()])
+            value_dict = {
+                key: self.field._to_mongo_safe_call(item, use_db_field, fields)
+                for key, item in iteritems(value)
+            }
         else:
             value_dict = {}
-            for k, v in value.iteritems():
+            for k, v in iteritems(value):
                 if isinstance(v, Document):
                     # We need the id from the saved object to create the DBRef
                     if v.pk is None:
@@ -316,9 +414,7 @@ class ComplexBaseField(BaseField):
                     # any _cls data so make it a generic reference allows
                     # us to dereference
                     meta = getattr(v, '_meta', {})
-                    allow_inheritance = (
-                        meta.get('allow_inheritance', ALLOW_INHERITANCE)
-                        is True)
+                    allow_inheritance = meta.get('allow_inheritance')
                     if not allow_inheritance and not self.field:
                         value_dict[k] = GenericReferenceField().to_mongo(v)
                     else:
@@ -326,34 +422,33 @@ class ComplexBaseField(BaseField):
                         value_dict[k] = DBRef(collection, v.pk)
                 elif hasattr(v, 'to_mongo'):
                     cls = v.__class__
-                    val = v.to_mongo()
-                    # If we its a document thats not inherited add _cls
-                    if (isinstance(v, (Document, EmbeddedDocument))):
+                    val = v.to_mongo(use_db_field, fields)
+                    # If it's a document that is not inherited add _cls
+                    if isinstance(v, (Document, EmbeddedDocument)):
                         val['_cls'] = cls.__name__
                     value_dict[k] = val
                 else:
-                    value_dict[k] = self.to_mongo(v)
+                    value_dict[k] = self.to_mongo(v, use_db_field, fields)
 
         if is_list:  # Convert back to a list
-            return [v for k, v in sorted(value_dict.items(),
+            return [v for _, v in sorted(value_dict.items(),
                                          key=operator.itemgetter(0))]
         return value_dict
 
     def validate(self, value):
-        """If field is provided ensure the value is valid.
-        """
+        """If field is provided ensure the value is valid."""
         errors = {}
         if self.field:
             if hasattr(value, 'iteritems') or hasattr(value, 'items'):
-                sequence = value.iteritems()
+                sequence = iteritems(value)
             else:
                 sequence = enumerate(value)
             for k, v in sequence:
                 try:
                     self.field._validate(v)
-                except ValidationError, error:
+                except ValidationError as error:
                     errors[k] = error.errors or error
-                except (ValueError, AssertionError), error:
+                except (ValueError, AssertionError) as error:
                     errors[k] = error
 
             if errors:
@@ -377,28 +472,25 @@ class ComplexBaseField(BaseField):
             self.field.owner_document = owner_document
         self._owner_document = owner_document
 
-    def _get_owner_document(self, owner_document):
-        self._owner_document = owner_document
-
-    owner_document = property(_get_owner_document, _set_owner_document)
-
 
 class ObjectIdField(BaseField):
-    """A field wrapper around MongoDB's ObjectIds.
-    """
+    """A field wrapper around MongoDB's ObjectIds."""
 
     def to_python(self, value):
-        if not isinstance(value, ObjectId):
-            value = ObjectId(value)
+        try:
+            if not isinstance(value, ObjectId):
+                value = ObjectId(value)
+        except Exception:
+            pass
         return value
 
     def to_mongo(self, value):
         if not isinstance(value, ObjectId):
             try:
-                return ObjectId(unicode(value))
-            except Exception, e:
+                return ObjectId(six.text_type(value))
+            except Exception as e:
                 # e.message attribute has been deprecated since Python 2.6
-                self.error(unicode(e))
+                self.error(six.text_type(e))
         return value
 
     def prepare_query_value(self, op, value):
@@ -406,36 +498,37 @@ class ObjectIdField(BaseField):
 
     def validate(self, value):
         try:
-            ObjectId(unicode(value))
-        except:
+            ObjectId(six.text_type(value))
+        except Exception:
             self.error('Invalid Object ID')
 
 
 class GeoJsonBaseField(BaseField):
     """A geo json field storing a geojson style object.
+
     .. versionadded:: 0.8
     """
 
     _geo_index = pymongo.GEOSPHERE
-    _type = "GeoBase"
+    _type = 'GeoBase'
 
     def __init__(self, auto_index=True, *args, **kwargs):
         """
-        :param auto_index: Automatically create a "2dsphere" index. Defaults
-            to `True`.
+        :param bool auto_index: Automatically create a '2dsphere' index.\
+            Defaults to `True`.
         """
-        self._name = "%sField" % self._type
+        self._name = '%sField' % self._type
         if not auto_index:
             self._geo_index = False
         super(GeoJsonBaseField, self).__init__(*args, **kwargs)
 
     def validate(self, value):
-        """Validate the GeoJson object based on its type
-        """
+        """Validate the GeoJson object based on its type."""
         if isinstance(value, dict):
-            if set(value.keys()) == set(['type', 'coordinates']):
+            if set(value.keys()) == {'type', 'coordinates'}:
                 if value['type'] != self._type:
-                    self.error('%s type must be "%s"' % (self._name, self._type))
+                    self.error('%s type must be "%s"' %
+                               (self._name, self._type))
                 return self.validate(value['coordinates'])
             else:
                 self.error('%s can only accept a valid GeoJson dictionary'
@@ -445,20 +538,20 @@ class GeoJsonBaseField(BaseField):
             self.error('%s can only accept lists of [x, y]' % self._name)
             return
 
-        validate = getattr(self, "_validate_%s" % self._type.lower())
+        validate = getattr(self, '_validate_%s' % self._type.lower())
         error = validate(value)
         if error:
             self.error(error)
 
-    def _validate_polygon(self, value):
+    def _validate_polygon(self, value, top_level=True):
         if not isinstance(value, (list, tuple)):
             return 'Polygons must contain list of linestrings'
 
         # Quick and dirty validator
         try:
             value[0][0][0]
-        except:
-            return "Invalid Polygon must contain at least one valid linestring"
+        except (TypeError, IndexError):
+            return 'Invalid Polygon must contain at least one valid linestring'
 
         errors = []
         for val in value:
@@ -468,18 +561,21 @@ class GeoJsonBaseField(BaseField):
             if error and error not in errors:
                 errors.append(error)
         if errors:
-            return "Invalid Polygon:\n%s" % ", ".join(errors)
+            if top_level:
+                return 'Invalid Polygon:\n%s' % ', '.join(errors)
+            else:
+                return '%s' % ', '.join(errors)
 
     def _validate_linestring(self, value, top_level=True):
-        """Validates a linestring"""
+        """Validate a linestring."""
         if not isinstance(value, (list, tuple)):
             return 'LineStrings must contain list of coordinate pairs'
 
         # Quick and dirty validator
         try:
             value[0][0]
-        except:
-            return "Invalid LineString must contain at least one valid point"
+        except (TypeError, IndexError):
+            return 'Invalid LineString must contain at least one valid point'
 
         errors = []
         for val in value:
@@ -488,21 +584,81 @@ class GeoJsonBaseField(BaseField):
                 errors.append(error)
         if errors:
             if top_level:
-                return "Invalid LineString:\n%s" % ", ".join(errors)
+                return 'Invalid LineString:\n%s' % ', '.join(errors)
             else:
-                return "%s" % ", ".join(errors)
+                return '%s' % ', '.join(errors)
 
     def _validate_point(self, value):
         """Validate each set of coords"""
         if not isinstance(value, (list, tuple)):
             return 'Points must be a list of coordinate pairs'
         elif not len(value) == 2:
-            return "Value (%s) must be a two-dimensional point" % repr(value)
+            return 'Value (%s) must be a two-dimensional point' % repr(value)
         elif (not isinstance(value[0], (float, int)) or
               not isinstance(value[1], (float, int))):
-            return "Both values (%s) in point must be float or int" % repr(value)
+            return 'Both values (%s) in point must be float or int' % repr(value)
+
+    def _validate_multipoint(self, value):
+        if not isinstance(value, (list, tuple)):
+            return 'MultiPoint must be a list of Point'
+
+        # Quick and dirty validator
+        try:
+            value[0][0]
+        except (TypeError, IndexError):
+            return 'Invalid MultiPoint must contain at least one valid point'
+
+        errors = []
+        for point in value:
+            error = self._validate_point(point)
+            if error and error not in errors:
+                errors.append(error)
+
+        if errors:
+            return '%s' % ', '.join(errors)
+
+    def _validate_multilinestring(self, value, top_level=True):
+        if not isinstance(value, (list, tuple)):
+            return 'MultiLineString must be a list of LineString'
+
+        # Quick and dirty validator
+        try:
+            value[0][0][0]
+        except (TypeError, IndexError):
+            return 'Invalid MultiLineString must contain at least one valid linestring'
+
+        errors = []
+        for linestring in value:
+            error = self._validate_linestring(linestring, False)
+            if error and error not in errors:
+                errors.append(error)
+
+        if errors:
+            if top_level:
+                return 'Invalid MultiLineString:\n%s' % ', '.join(errors)
+            else:
+                return '%s' % ', '.join(errors)
+
+    def _validate_multipolygon(self, value):
+        if not isinstance(value, (list, tuple)):
+            return 'MultiPolygon must be a list of Polygon'
+
+        # Quick and dirty validator
+        try:
+            value[0][0][0][0]
+        except (TypeError, IndexError):
+            return 'Invalid MultiPolygon must contain at least one valid Polygon'
+
+        errors = []
+        for polygon in value:
+            error = self._validate_polygon(polygon, False)
+            if error and error not in errors:
+                errors.append(error)
+
+        if errors:
+            return 'Invalid MultiPolygon:\n%s' % ', '.join(errors)
 
     def to_mongo(self, value):
         if isinstance(value, dict):
             return value
-        return SON([("type", self._type), ("coordinates", value)])
+        return SON([('type', self._type), ('coordinates', value)])

mongoengine/base/metaclasses.py

@@ -1,34 +1,35 @@
 import warnings
 
-import pymongo
+import six
+from six import iteritems, itervalues
 
+from mongoengine.base.common import _document_registry
+from mongoengine.base.fields import BaseField, ComplexBaseField, ObjectIdField
 from mongoengine.common import _import_class
 from mongoengine.errors import InvalidDocumentError
-from mongoengine.python_support import PY3
 from mongoengine.queryset import (DO_NOTHING, DoesNotExist,
                                   MultipleObjectsReturned,
-                                  QuerySet, QuerySetManager)
+                                  QuerySetManager)
 
-from mongoengine.base.common import _document_registry, ALLOW_INHERITANCE
-from mongoengine.base.fields import BaseField, ComplexBaseField, ObjectIdField
 
 __all__ = ('DocumentMetaclass', 'TopLevelDocumentMetaclass')
 
 
 class DocumentMetaclass(type):
-    """Metaclass for all documents.
-    """
+    """Metaclass for all documents."""
 
-    def __new__(cls, name, bases, attrs):
-        flattened_bases = cls._get_bases(bases)
-        super_new = super(DocumentMetaclass, cls).__new__
+    # TODO lower complexity of this method
+    def __new__(mcs, name, bases, attrs):
+        flattened_bases = mcs._get_bases(bases)
+        super_new = super(DocumentMetaclass, mcs).__new__
 
         # If a base class just call super
         metaclass = attrs.get('my_metaclass')
         if metaclass and issubclass(metaclass, DocumentMetaclass):
-            return super_new(cls, name, bases, attrs)
+            return super_new(mcs, name, bases, attrs)
 
         attrs['_is_document'] = attrs.get('_is_document', False)
+        attrs['_cached_reference_fields'] = []
 
         # EmbeddedDocuments could have meta data for inheritance
         if 'meta' in attrs:
@@ -44,6 +45,12 @@ class DocumentMetaclass(type):
                 elif hasattr(base, '_meta'):
                     meta.merge(base._meta)
             attrs['_meta'] = meta
+            attrs['_meta']['abstract'] = False  # 789: EmbeddedDocument shouldn't inherit abstract
+
+        # If allow_inheritance is True, add a "_cls" string field to the attrs
+        if attrs['_meta'].get('allow_inheritance'):
+            StringField = _import_class('StringField')
+            attrs['_cls'] = StringField()
 
         # Handle document Fields
 
@@ -56,7 +63,7 @@ class DocumentMetaclass(type):
             # Standard object mixin - merge in any Fields
             if not hasattr(base, '_meta'):
                 base_fields = {}
-                for attr_name, attr_value in base.__dict__.iteritems():
+                for attr_name, attr_value in iteritems(base.__dict__):
                     if not isinstance(attr_value, BaseField):
                         continue
                     attr_value.name = attr_name
@@ -68,7 +75,7 @@ class DocumentMetaclass(type):
 
         # Discover any document fields
         field_names = {}
-        for attr_name, attr_value in attrs.iteritems():
+        for attr_name, attr_value in iteritems(attrs):
             if not isinstance(attr_value, BaseField):
                 continue
             attr_value.name = attr_name
@@ -83,20 +90,21 @@ class DocumentMetaclass(type):
         # Ensure no duplicate db_fields
         duplicate_db_fields = [k for k, v in field_names.items() if v > 1]
         if duplicate_db_fields:
-            msg = ("Multiple db_fields defined for: %s " %
-                   ", ".join(duplicate_db_fields))
+            msg = ('Multiple db_fields defined for: %s ' %
+                   ', '.join(duplicate_db_fields))
             raise InvalidDocumentError(msg)
 
         # Set _fields and db_field maps
         attrs['_fields'] = doc_fields
-        attrs['_db_field_map'] = dict([(k, getattr(v, 'db_field', k))
-                                      for k, v in doc_fields.iteritems()])
-        attrs['_reverse_db_field_map'] = dict(
-            (v, k) for k, v in attrs['_db_field_map'].iteritems())
+        attrs['_db_field_map'] = {k: getattr(v, 'db_field', k)
+                                  for k, v in doc_fields.items()}
+        attrs['_reverse_db_field_map'] = {
+            v: k for k, v in attrs['_db_field_map'].items()
+        }
 
         attrs['_fields_ordered'] = tuple(i[1] for i in sorted(
                                          (v.creation_counter, v.name)
-                                         for v in doc_fields.itervalues()))
+                                         for v in itervalues(doc_fields)))
 
         #
         # Set document hierarchy
@@ -105,18 +113,17 @@ class DocumentMetaclass(type):
         class_name = [name]
         for base in flattened_bases:
             if (not getattr(base, '_is_base_cls', True) and
-               not getattr(base, '_meta', {}).get('abstract', True)):
-                # Collate heirarchy for _cls and _subclasses
+                    not getattr(base, '_meta', {}).get('abstract', True)):
+                # Collate hierarchy for _cls and _subclasses
                 class_name.append(base.__name__)
 
             if hasattr(base, '_meta'):
                 # Warn if allow_inheritance isn't set and prevent
                 # inheritance of classes where inheritance is set to False
-                allow_inheritance = base._meta.get('allow_inheritance',
-                                                   ALLOW_INHERITANCE)
-                if (allow_inheritance is not True and
-                   not base._meta.get('abstract')):
-                    raise ValueError('Document %s may not be subclassed' %
+                allow_inheritance = base._meta.get('allow_inheritance')
+                if not allow_inheritance and not base._meta.get('abstract'):
+                    raise ValueError('Document %s may not be subclassed. '
+                                     'To enable inheritance, use the "allow_inheritance" meta attribute.' %
                                      base.__name__)
 
         # Get superclasses from last base superclass
@@ -133,15 +140,16 @@ class DocumentMetaclass(type):
         attrs['_types'] = attrs['_subclasses']  # TODO depreciate _types
 
         # Create the new_class
-        new_class = super_new(cls, name, bases, attrs)
+        new_class = super_new(mcs, name, bases, attrs)
 
         # Set _subclasses
         for base in document_bases:
             if _cls not in base._subclasses:
                 base._subclasses += (_cls,)
-            base._types = base._subclasses   # TODO depreciate _types
+            base._types = base._subclasses  # TODO depreciate _types
 
-        Document, EmbeddedDocument, DictField = cls._import_classes()
+        (Document, EmbeddedDocument, DictField,
+         CachedReferenceField) = mcs._import_classes()
 
         if issubclass(new_class, Document):
             new_class._collection = None
@@ -156,8 +164,8 @@ class DocumentMetaclass(type):
         # module continues to use im_func and im_self, so the code below
         # copies __func__ into im_func and __self__ into im_self for
         # classmethod objects in Document derived classes.
-        if PY3:
-            for key, val in new_class.__dict__.items():
+        if six.PY3:
+            for val in new_class.__dict__.values():
                 if isinstance(val, classmethod):
                     f = val.__get__(new_class)
                     if hasattr(f, '__func__') and not hasattr(f, 'im_func'):
@@ -166,17 +174,29 @@ class DocumentMetaclass(type):
                         f.__dict__.update({'im_self': getattr(f, '__self__')})
 
         # Handle delete rules
-        for field in new_class._fields.itervalues():
+        for field in itervalues(new_class._fields):
             f = field
-            f.owner_document = new_class
+            if f.owner_document is None:
+                f.owner_document = new_class
             delete_rule = getattr(f, 'reverse_delete_rule', DO_NOTHING)
+            if isinstance(f, CachedReferenceField):
+
+                if issubclass(new_class, EmbeddedDocument):
+                    raise InvalidDocumentError('CachedReferenceFields is not '
+                                               'allowed in EmbeddedDocuments')
+
+                if f.auto_sync:
+                    f.start_listener()
+
+                f.document_type._cached_reference_fields.append(f)
+
             if isinstance(f, ComplexBaseField) and hasattr(f, 'field'):
                 delete_rule = getattr(f.field,
                                       'reverse_delete_rule',
                                       DO_NOTHING)
                 if isinstance(f, DictField) and delete_rule != DO_NOTHING:
-                    msg = ("Reverse delete rules are not supported "
-                           "for %s (field: %s)" %
+                    msg = ('Reverse delete rules are not supported '
+                           'for %s (field: %s)' %
                            (field.__class__.__name__, field.name))
                     raise InvalidDocumentError(msg)
 
@@ -184,47 +204,45 @@ class DocumentMetaclass(type):
 
             if delete_rule != DO_NOTHING:
                 if issubclass(new_class, EmbeddedDocument):
-                    msg = ("Reverse delete rules are not supported for "
-                           "EmbeddedDocuments (field: %s)" % field.name)
+                    msg = ('Reverse delete rules are not supported for '
+                           'EmbeddedDocuments (field: %s)' % field.name)
                     raise InvalidDocumentError(msg)
                 f.document_type.register_delete_rule(new_class,
                                                      field.name, delete_rule)
 
             if (field.name and hasattr(Document, field.name) and
-               EmbeddedDocument not in new_class.mro()):
-                msg = ("%s is a document method and not a valid "
-                       "field name" % field.name)
+                    EmbeddedDocument not in new_class.mro()):
+                msg = ('%s is a document method and not a valid '
+                       'field name' % field.name)
                 raise InvalidDocumentError(msg)
 
         return new_class
 
-    def add_to_class(self, name, value):
-        setattr(self, name, value)
-
     @classmethod
-    def _get_bases(cls, bases):
+    def _get_bases(mcs, bases):
         if isinstance(bases, BasesTuple):
             return bases
         seen = []
-        bases = cls.__get_bases(bases)
+        bases = mcs.__get_bases(bases)
         unique_bases = (b for b in bases if not (b in seen or seen.append(b)))
         return BasesTuple(unique_bases)
 
     @classmethod
-    def __get_bases(cls, bases):
+    def __get_bases(mcs, bases):
         for base in bases:
             if base is object:
                 continue
             yield base
-            for child_base in cls.__get_bases(base.__bases__):
+            for child_base in mcs.__get_bases(base.__bases__):
                 yield child_base
 
     @classmethod
-    def _import_classes(cls):
+    def _import_classes(mcs):
         Document = _import_class('Document')
         EmbeddedDocument = _import_class('EmbeddedDocument')
         DictField = _import_class('DictField')
-        return (Document, EmbeddedDocument, DictField)
+        CachedReferenceField = _import_class('CachedReferenceField')
+        return Document, EmbeddedDocument, DictField, CachedReferenceField
 
 
 class TopLevelDocumentMetaclass(DocumentMetaclass):
@@ -232,12 +250,12 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
     collection in the database.
     """
 
-    def __new__(cls, name, bases, attrs):
-        flattened_bases = cls._get_bases(bases)
-        super_new = super(TopLevelDocumentMetaclass, cls).__new__
+    def __new__(mcs, name, bases, attrs):
+        flattened_bases = mcs._get_bases(bases)
+        super_new = super(TopLevelDocumentMetaclass, mcs).__new__
 
         # Set default _meta data if base class, otherwise get user defined meta
-        if (attrs.get('my_metaclass') == TopLevelDocumentMetaclass):
+        if attrs.get('my_metaclass') == TopLevelDocumentMetaclass:
             # defaults
             attrs['_meta'] = {
                 'abstract': True,
@@ -250,13 +268,18 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
                 'index_drop_dups': False,
                 'index_opts': None,
                 'delete_rules': None,
+
+                # allow_inheritance can be True, False, and None. True means
+                # "allow inheritance", False means "don't allow inheritance",
+                # None means "do whatever your parent does, or don't allow
+                # inheritance if you're a top-level class".
                 'allow_inheritance': None,
             }
             attrs['_is_base_cls'] = True
             attrs['_meta'].update(attrs.get('meta', {}))
         else:
             attrs['_meta'] = attrs.get('meta', {})
-            # Explictly set abstract to false unless set
+            # Explicitly set abstract to false unless set
             attrs['_meta']['abstract'] = attrs['_meta'].get('abstract', False)
             attrs['_is_base_cls'] = False
 
@@ -271,28 +294,28 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
 
         # Clean up top level meta
         if 'meta' in attrs:
-            del(attrs['meta'])
+            del attrs['meta']
 
         # Find the parent document class
         parent_doc_cls = [b for b in flattened_bases
-                        if b.__class__ == TopLevelDocumentMetaclass]
+                          if b.__class__ == TopLevelDocumentMetaclass]
         parent_doc_cls = None if not parent_doc_cls else parent_doc_cls[0]
 
         # Prevent classes setting collection different to their parents
         # If parent wasn't an abstract class
-        if (parent_doc_cls and 'collection' in attrs.get('_meta', {})
-            and not parent_doc_cls._meta.get('abstract', True)):
-                msg = "Trying to set a collection on a subclass (%s)" % name
-                warnings.warn(msg, SyntaxWarning)
-                del(attrs['_meta']['collection'])
+        if (parent_doc_cls and 'collection' in attrs.get('_meta', {}) and
+                not parent_doc_cls._meta.get('abstract', True)):
+            msg = 'Trying to set a collection on a subclass (%s)' % name
+            warnings.warn(msg, SyntaxWarning)
+            del attrs['_meta']['collection']
 
         # Ensure abstract documents have abstract bases
         if attrs.get('_is_base_cls') or attrs['_meta'].get('abstract'):
             if (parent_doc_cls and
-                not parent_doc_cls._meta.get('abstract', False)):
-                msg = "Abstract document cannot have non-abstract base"
+                    not parent_doc_cls._meta.get('abstract', False)):
+                msg = 'Abstract document cannot have non-abstract base'
                 raise ValueError(msg)
-            return super_new(cls, name, bases, attrs)
+            return super_new(mcs, name, bases, attrs)
 
         # Merge base class metas.
         # Uses a special MetaDict that handles various merging rules
@@ -306,19 +329,23 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
 
             # Set collection in the meta if its callable
             if (getattr(base, '_is_document', False) and
-                not base._meta.get('abstract')):
+                    not base._meta.get('abstract')):
                 collection = meta.get('collection', None)
                 if callable(collection):
                     meta['collection'] = collection(base)
 
         meta.merge(attrs.get('_meta', {}))  # Top level meta
 
-        # Only simple classes (direct subclasses of Document)
-        # may set allow_inheritance to False
+        # Only simple classes (i.e. direct subclasses of Document) may set
+        # allow_inheritance to False. If the base Document allows inheritance,
+        # none of its subclasses can override allow_inheritance to False.
         simple_class = all([b._meta.get('abstract')
                             for b in flattened_bases if hasattr(b, '_meta')])
-        if (not simple_class and meta['allow_inheritance'] is False and
-           not meta['abstract']):
+        if (
+            not simple_class and
+            meta['allow_inheritance'] is False and
+            not meta['abstract']
+        ):
             raise ValueError('Only direct subclasses of Document may set '
                              '"allow_inheritance" to False')
 
@@ -329,7 +356,7 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
         attrs['_meta'] = meta
 
         # Call super and get the new class
-        new_class = super_new(cls, name, bases, attrs)
+        new_class = super_new(mcs, name, bases, attrs)
 
         meta = new_class._meta
 
@@ -346,7 +373,7 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
             new_class.objects = QuerySetManager()
 
         # Validate the fields and set primary key if needed
-        for field_name, field in new_class._fields.iteritems():
+        for field_name, field in iteritems(new_class._fields):
             if field.primary_key:
                 # Ensure only one primary key is set
                 current_pk = new_class._meta.get('id_field')
@@ -359,17 +386,20 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
                     new_class.id = field
 
         # Set primary key if not defined by the document
-        new_class._auto_id_field = False
+        new_class._auto_id_field = getattr(parent_doc_cls,
+                                           '_auto_id_field', False)
         if not new_class._meta.get('id_field'):
+            # After 0.10, find not existing names, instead of overwriting
+            id_name, id_db_name = mcs.get_auto_id_names(new_class)
             new_class._auto_id_field = True
-            new_class._meta['id_field'] = 'id'
-            new_class._fields['id'] = ObjectIdField(db_field='_id')
-            new_class._fields['id'].name = 'id'
-            new_class.id = new_class._fields['id']
-
-        # Prepend id field to _fields_ordered
-        if 'id' in new_class._fields and 'id' not in new_class._fields_ordered:
-            new_class._fields_ordered = ('id', ) + new_class._fields_ordered
+            new_class._meta['id_field'] = id_name
+            new_class._fields[id_name] = ObjectIdField(db_field=id_db_name)
+            new_class._fields[id_name].name = id_name
+            new_class.id = new_class._fields[id_name]
+            new_class._db_field_map[id_name] = id_db_name
+            new_class._reverse_db_field_map[id_db_name] = id_name
+            # Prepend id field to _fields_ordered
+            new_class._fields_ordered = (id_name, ) + new_class._fields_ordered
 
         # Merge in exceptions with parent hierarchy
         exceptions_to_merge = (DoesNotExist, MultipleObjectsReturned)
@@ -377,13 +407,27 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
         for exc in exceptions_to_merge:
             name = exc.__name__
             parents = tuple(getattr(base, name) for base in flattened_bases
-                         if hasattr(base, name)) or (exc,)
+                            if hasattr(base, name)) or (exc,)
             # Create new exception and set to new_class
             exception = type(name, parents, {'__module__': module})
             setattr(new_class, name, exception)
 
         return new_class
 
+    @classmethod
+    def get_auto_id_names(mcs, new_class):
+        id_name, id_db_name = ('id', '_id')
+        if id_name not in new_class._fields and \
+                id_db_name not in (v.db_field for v in new_class._fields.values()):
+            return id_name, id_db_name
+        id_basename, id_db_basename, i = 'auto_id', '_auto_id', 0
+        while id_name in new_class._fields or \
+                id_db_name in (v.db_field for v in new_class._fields.values()):
+            id_name = '{0}_{1}'.format(id_basename, i)
+            id_db_name = '{0}_{1}'.format(id_db_basename, i)
+            i += 1
+        return id_name, id_db_name
+
 
 class MetaDict(dict):
     """Custom dictionary for meta classes.
@@ -392,7 +436,7 @@ class MetaDict(dict):
     _merge_options = ('indexes',)
 
     def merge(self, new_options):
-        for k, v in new_options.iteritems():
+        for k, v in iteritems(new_options):
             if k in self._merge_options:
                 self[k] = self.get(k, []) + v
             else:

mongoengine/base/utils.py

@@ -0,0 +1,22 @@
+import re
+
+
+class LazyRegexCompiler(object):
+    """Descriptor to allow lazy compilation of regex"""
+
+    def __init__(self, pattern, flags=0):
+        self._pattern = pattern
+        self._flags = flags
+        self._compiled_regex = None
+
+    @property
+    def compiled_regex(self):
+        if self._compiled_regex is None:
+            self._compiled_regex = re.compile(self._pattern, self._flags)
+        return self._compiled_regex
+
+    def __get__(self, instance, owner):
+        return self.compiled_regex
+
+    def __set__(self, instance, value):
+        raise AttributeError("Can not set attribute LazyRegexCompiler")

mongoengine/common.py

@@ -1,4 +1,5 @@
 _class_registry_cache = {}
+_field_list_cache = []
 
 
 def _import_class(cls_name):
@@ -20,29 +21,32 @@ def _import_class(cls_name):
 
     doc_classes = ('Document', 'DynamicEmbeddedDocument', 'EmbeddedDocument',
                    'MapReduceDocument')
-    field_classes = ('DictField', 'DynamicField', 'EmbeddedDocumentField',
-                     'FileField', 'GenericReferenceField',
-                     'GenericEmbeddedDocumentField', 'GeoPointField',
-                     'PointField', 'LineStringField', 'ListField',
-                     'PolygonField', 'ReferenceField', 'StringField',
-                     'ComplexBaseField', 'GeoJsonBaseField')
-    queryset_classes = ('OperationError',)
+
+    # Field Classes
+    if not _field_list_cache:
+        from mongoengine.fields import __all__ as fields
+        _field_list_cache.extend(fields)
+        from mongoengine.base.fields import __all__ as fields
+        _field_list_cache.extend(fields)
+
+    field_classes = _field_list_cache
+
     deref_classes = ('DeReference',)
 
-    if cls_name in doc_classes:
+    if cls_name == 'BaseDocument':
+        from mongoengine.base import document as module
+        import_classes = ['BaseDocument']
+    elif cls_name in doc_classes:
         from mongoengine import document as module
         import_classes = doc_classes
     elif cls_name in field_classes:
         from mongoengine import fields as module
         import_classes = field_classes
-    elif cls_name in queryset_classes:
-        from mongoengine import queryset as module
-        import_classes = queryset_classes
     elif cls_name in deref_classes:
         from mongoengine import dereference as module
         import_classes = deref_classes
     else:
-        raise ValueError('No import set for: ' % cls_name)
+        raise ValueError('No import set for: %s' % cls_name)
 
     for cls in import_classes:
         _class_registry_cache[cls] = getattr(module, cls)

mongoengine/connection.py

@@ -1,132 +1,331 @@
-import pymongo
-from pymongo import MongoClient, MongoReplicaSetClient, uri_parser
+from pymongo import MongoClient, ReadPreference, uri_parser
+from pymongo.database import _check_name
+import six
 
-
-__all__ = ['ConnectionError', 'connect', 'register_connection',
-           'DEFAULT_CONNECTION_NAME']
+__all__ = [
+    'DEFAULT_CONNECTION_NAME',
+    'DEFAULT_DATABASE_NAME',
+    'MongoEngineConnectionError',
+    'connect',
+    'disconnect',
+    'disconnect_all',
+    'get_connection',
+    'get_db',
+    'register_connection',
+]
 
 
 DEFAULT_CONNECTION_NAME = 'default'
-
-
-class ConnectionError(Exception):
-    pass
-
+DEFAULT_DATABASE_NAME = 'test'
+DEFAULT_HOST = 'localhost'
+DEFAULT_PORT = 27017
 
 _connection_settings = {}
 _connections = {}
 _dbs = {}
 
+READ_PREFERENCE = ReadPreference.PRIMARY
 
-def register_connection(alias, name, host=None, port=None,
-                        is_slave=False, read_preference=False, slaves=None,
-                        username=None, password=None, **kwargs):
-    """Add a connection.
-
-    :param alias: the name that will be used to refer to this connection
-        throughout MongoEngine
-    :param name: the name of the specific database to use
-    :param host: the host name of the :program:`mongod` instance to connect to
-    :param port: the port that the :program:`mongod` instance is running on
-    :param is_slave: whether the connection can act as a slave
-      ** Depreciated pymongo 2.0.1+
-    :param read_preference: The read preference for the collection
-       ** Added pymongo 2.1
-    :param slaves: a list of aliases of slave connections; each of these must
-        be a registered connection that has :attr:`is_slave` set to ``True``
-    :param username: username to authenticate with
-    :param password: password to authenticate with
-    :param kwargs: allow ad-hoc parameters to be passed into the pymongo driver
 
+class MongoEngineConnectionError(Exception):
+    """Error raised when the database connection can't be established or
+    when a connection with a requested alias can't be retrieved.
     """
-    global _connection_settings
+    pass
 
+
+def _check_db_name(name):
+    """Check if a database name is valid.
+    This functionality is copied from pymongo Database class constructor.
+    """
+    if not isinstance(name, six.string_types):
+        raise TypeError('name must be an instance of %s' % six.string_types)
+    elif name != '$external':
+        _check_name(name)
+
+
+def _get_connection_settings(
+        db=None, name=None, host=None, port=None,
+        read_preference=READ_PREFERENCE,
+        username=None, password=None,
+        authentication_source=None,
+        authentication_mechanism=None,
+        **kwargs):
+    """Get the connection settings as a dict
+
+    : param db: the name of the database to use, for compatibility with connect
+    : param name: the name of the specific database to use
+    : param host: the host name of the: program: `mongod` instance to connect to
+    : param port: the port that the: program: `mongod` instance is running on
+    : param read_preference: The read preference for the collection
+    : param username: username to authenticate with
+    : param password: password to authenticate with
+    : param authentication_source: database to authenticate against
+    : param authentication_mechanism: database authentication mechanisms.
+        By default, use SCRAM-SHA-1 with MongoDB 3.0 and later,
+        MONGODB-CR (MongoDB Challenge Response protocol) for older servers.
+    : param is_mock: explicitly use mongomock for this connection
+        (can also be done by using `mongomock: // ` as db host prefix)
+    : param kwargs: ad-hoc parameters to be passed into the pymongo driver,
+        for example maxpoolsize, tz_aware, etc. See the documentation
+        for pymongo's `MongoClient` for a full list.
+
+    .. versionchanged:: 0.10.6 - added mongomock support
+    """
     conn_settings = {
-        'name': name,
-        'host': host or 'localhost',
-        'port': port or 27017,
-        'is_slave': is_slave,
-        'slaves': slaves or [],
+        'name': name or db or DEFAULT_DATABASE_NAME,
+        'host': host or DEFAULT_HOST,
+        'port': port or DEFAULT_PORT,
+        'read_preference': read_preference,
         'username': username,
         'password': password,
-        'read_preference': read_preference
+        'authentication_source': authentication_source,
+        'authentication_mechanism': authentication_mechanism
     }
 
-    # Handle uri style connections
-    if "://" in conn_settings['host']:
-        uri_dict = uri_parser.parse_uri(conn_settings['host'])
-        conn_settings.update({
-            'name': uri_dict.get('database') or name,
-            'username': uri_dict.get('username'),
-            'password': uri_dict.get('password'),
-            'read_preference': read_preference,
-        })
-        if "replicaSet" in conn_settings['host']:
-            conn_settings['replicaSet'] = True
+    _check_db_name(conn_settings['name'])
+    conn_host = conn_settings['host']
+
+    # Host can be a list or a string, so if string, force to a list.
+    if isinstance(conn_host, six.string_types):
+        conn_host = [conn_host]
+
+    resolved_hosts = []
+    for entity in conn_host:
+
+        # Handle Mongomock
+        if entity.startswith('mongomock://'):
+            conn_settings['is_mock'] = True
+            # `mongomock://` is not a valid url prefix and must be replaced by `mongodb://`
+            resolved_hosts.append(entity.replace('mongomock://', 'mongodb://', 1))
+
+        # Handle URI style connections, only updating connection params which
+        # were explicitly specified in the URI.
+        elif '://' in entity:
+            uri_dict = uri_parser.parse_uri(entity)
+            resolved_hosts.append(entity)
+
+            if uri_dict.get('database'):
+                conn_settings['name'] = uri_dict.get('database')
+
+            for param in ('read_preference', 'username', 'password'):
+                if uri_dict.get(param):
+                    conn_settings[param] = uri_dict[param]
+
+            uri_options = uri_dict['options']
+            if 'replicaset' in uri_options:
+                conn_settings['replicaSet'] = uri_options['replicaset']
+            if 'authsource' in uri_options:
+                conn_settings['authentication_source'] = uri_options['authsource']
+            if 'authmechanism' in uri_options:
+                conn_settings['authentication_mechanism'] = uri_options['authmechanism']
+            if 'readpreference' in uri_options:
+                read_preferences = (
+                    ReadPreference.NEAREST,
+                    ReadPreference.PRIMARY,
+                    ReadPreference.PRIMARY_PREFERRED,
+                    ReadPreference.SECONDARY,
+                    ReadPreference.SECONDARY_PREFERRED,
+                )
+
+                # Starting with PyMongo v3.5, the "readpreference" option is
+                # returned as a string (e.g. "secondaryPreferred") and not an
+                # int (e.g. 3).
+                # TODO simplify the code below once we drop support for
+                # PyMongo v3.4.
+                read_pf_mode = uri_options['readpreference']
+                if isinstance(read_pf_mode, six.string_types):
+                    read_pf_mode = read_pf_mode.lower()
+                for preference in read_preferences:
+                    if (
+                        preference.name.lower() == read_pf_mode or
+                        preference.mode == read_pf_mode
+                    ):
+                        conn_settings['read_preference'] = preference
+                        break
+        else:
+            resolved_hosts.append(entity)
+    conn_settings['host'] = resolved_hosts
+
+    # Deprecated parameters that should not be passed on
+    kwargs.pop('slaves', None)
+    kwargs.pop('is_slave', None)
 
     conn_settings.update(kwargs)
+    return conn_settings
+
+
+def register_connection(alias, db=None, name=None, host=None, port=None,
+                        read_preference=READ_PREFERENCE,
+                        username=None, password=None,
+                        authentication_source=None,
+                        authentication_mechanism=None,
+                        **kwargs):
+    """Register the connection settings.
+
+    : param alias: the name that will be used to refer to this connection
+        throughout MongoEngine
+    : param name: the name of the specific database to use
+    : param db: the name of the database to use, for compatibility with connect
+    : param host: the host name of the: program: `mongod` instance to connect to
+    : param port: the port that the: program: `mongod` instance is running on
+    : param read_preference: The read preference for the collection
+    : param username: username to authenticate with
+    : param password: password to authenticate with
+    : param authentication_source: database to authenticate against
+    : param authentication_mechanism: database authentication mechanisms.
+        By default, use SCRAM-SHA-1 with MongoDB 3.0 and later,
+        MONGODB-CR (MongoDB Challenge Response protocol) for older servers.
+    : param is_mock: explicitly use mongomock for this connection
+        (can also be done by using `mongomock: // ` as db host prefix)
+    : param kwargs: ad-hoc parameters to be passed into the pymongo driver,
+        for example maxpoolsize, tz_aware, etc. See the documentation
+        for pymongo's `MongoClient` for a full list.
+
+    .. versionchanged:: 0.10.6 - added mongomock support
+    """
+    conn_settings = _get_connection_settings(
+        db=db, name=name, host=host, port=port,
+        read_preference=read_preference,
+        username=username, password=password,
+        authentication_source=authentication_source,
+        authentication_mechanism=authentication_mechanism,
+        **kwargs)
     _connection_settings[alias] = conn_settings
 
 
 def disconnect(alias=DEFAULT_CONNECTION_NAME):
-    global _connections
-    global _dbs
+    """Close the connection with a given alias."""
+    from mongoengine.base.common import _get_documents_by_db
+    from mongoengine import Document
 
     if alias in _connections:
-        get_connection(alias=alias).disconnect()
+        get_connection(alias=alias).close()
         del _connections[alias]
+
     if alias in _dbs:
+        # Detach all cached collections in Documents
+        for doc_cls in _get_documents_by_db(alias, DEFAULT_CONNECTION_NAME):
+            if issubclass(doc_cls, Document):     # Skip EmbeddedDocument
+                doc_cls._disconnect()
+
         del _dbs[alias]
 
+    if alias in _connection_settings:
+        del _connection_settings[alias]
+
+
+def disconnect_all():
+    """Close all registered database."""
+    for alias in list(_connections.keys()):
+        disconnect(alias)
+
 
 def get_connection(alias=DEFAULT_CONNECTION_NAME, reconnect=False):
-    global _connections
+    """Return a connection with a given alias."""
+
     # Connect to the database if not already connected
     if reconnect:
         disconnect(alias)
 
-    if alias not in _connections:
-        if alias not in _connection_settings:
-            msg = 'Connection with alias "%s" has not been defined' % alias
-            if alias == DEFAULT_CONNECTION_NAME:
-                msg = 'You have not defined a default connection'
-            raise ConnectionError(msg)
-        conn_settings = _connection_settings[alias].copy()
+    # If the requested alias already exists in the _connections list, return
+    # it immediately.
+    if alias in _connections:
+        return _connections[alias]
 
-        if hasattr(pymongo, 'version_tuple'):  # Support for 2.1+
-            conn_settings.pop('name', None)
-            conn_settings.pop('slaves', None)
-            conn_settings.pop('is_slave', None)
-            conn_settings.pop('username', None)
-            conn_settings.pop('password', None)
+    # Validate that the requested alias exists in the _connection_settings.
+    # Raise MongoEngineConnectionError if it doesn't.
+    if alias not in _connection_settings:
+        if alias == DEFAULT_CONNECTION_NAME:
+            msg = 'You have not defined a default connection'
         else:
-            # Get all the slave connections
-            if 'slaves' in conn_settings:
-                slaves = []
-                for slave_alias in conn_settings['slaves']:
-                    slaves.append(get_connection(slave_alias))
-                conn_settings['slaves'] = slaves
-                conn_settings.pop('read_preference', None)
+            msg = 'Connection with alias "%s" has not been defined' % alias
+        raise MongoEngineConnectionError(msg)
 
-        connection_class = MongoClient
-        if 'replicaSet' in conn_settings:
-            conn_settings['hosts_or_uri'] = conn_settings.pop('host', None)
-            # Discard port since it can't be used on MongoReplicaSetClient
-            conn_settings.pop('port', None)
-            # Discard replicaSet if not base string
-            if not isinstance(conn_settings['replicaSet'], basestring):
-                conn_settings.pop('replicaSet', None)
-            connection_class = MongoReplicaSetClient
+    def _clean_settings(settings_dict):
+        irrelevant_fields_set = {
+            'name', 'username', 'password',
+            'authentication_source', 'authentication_mechanism'
+        }
+        return {
+            k: v for k, v in settings_dict.items()
+            if k not in irrelevant_fields_set
+        }
 
+    raw_conn_settings = _connection_settings[alias].copy()
+
+    # Retrieve a copy of the connection settings associated with the requested
+    # alias and remove the database name and authentication info (we don't
+    # care about them at this point).
+    conn_settings = _clean_settings(raw_conn_settings)
+
+    # Determine if we should use PyMongo's or mongomock's MongoClient.
+    is_mock = conn_settings.pop('is_mock', False)
+    if is_mock:
         try:
-            _connections[alias] = connection_class(**conn_settings)
-        except Exception, e:
-            raise ConnectionError("Cannot connect to database %s :\n%s" % (alias, e))
+            import mongomock
+        except ImportError:
+            raise RuntimeError('You need mongomock installed to mock '
+                               'MongoEngine.')
+        connection_class = mongomock.MongoClient
+    else:
+        connection_class = MongoClient
+
+    # Re-use existing connection if one is suitable.
+    existing_connection = _find_existing_connection(raw_conn_settings)
+    if existing_connection:
+        connection = existing_connection
+    else:
+        connection = _create_connection(
+            alias=alias,
+            connection_class=connection_class,
+            **conn_settings
+        )
+    _connections[alias] = connection
     return _connections[alias]
 
 
+def _create_connection(alias, connection_class, **connection_settings):
+    """
+    Create the new connection for this alias. Raise
+    MongoEngineConnectionError if it can't be established.
+    """
+    try:
+        return connection_class(**connection_settings)
+    except Exception as e:
+        raise MongoEngineConnectionError(
+            'Cannot connect to database %s :\n%s' % (alias, e))
+
+
+def _find_existing_connection(connection_settings):
+    """
+    Check if an existing connection could be reused
+
+    Iterate over all of the connection settings and if an existing connection
+    with the same parameters is suitable, return it
+
+    :param connection_settings: the settings of the new connection
+    :return: An existing connection or None
+    """
+    connection_settings_bis = (
+        (db_alias, settings.copy())
+        for db_alias, settings in _connection_settings.items()
+    )
+
+    def _clean_settings(settings_dict):
+        # Only remove the name but it's important to
+        # keep the username/password/authentication_source/authentication_mechanism
+        # to identify if the connection could be shared (cfr https://github.com/MongoEngine/mongoengine/issues/2047)
+        return {k: v for k, v in settings_dict.items() if k != 'name'}
+
+    cleaned_conn_settings = _clean_settings(connection_settings)
+    for db_alias, connection_settings in connection_settings_bis:
+        db_conn_settings = _clean_settings(connection_settings)
+        if cleaned_conn_settings == db_conn_settings and _connections.get(db_alias):
+            return _connections[db_alias]
+
+
 def get_db(alias=DEFAULT_CONNECTION_NAME, reconnect=False):
-    global _dbs
     if reconnect:
         disconnect(alias)
 
@@ -134,28 +333,46 @@ def get_db(alias=DEFAULT_CONNECTION_NAME, reconnect=False):
         conn = get_connection(alias)
         conn_settings = _connection_settings[alias]
         db = conn[conn_settings['name']]
+        auth_kwargs = {'source': conn_settings['authentication_source']}
+        if conn_settings['authentication_mechanism'] is not None:
+            auth_kwargs['mechanism'] = conn_settings['authentication_mechanism']
         # Authenticate if necessary
-        if conn_settings['username'] and conn_settings['password']:
-            db.authenticate(conn_settings['username'],
-                            conn_settings['password'])
+        if conn_settings['username'] and (conn_settings['password'] or
+                                          conn_settings['authentication_mechanism'] == 'MONGODB-X509'):
+            db.authenticate(conn_settings['username'], conn_settings['password'], **auth_kwargs)
         _dbs[alias] = db
     return _dbs[alias]
 
 
-def connect(db, alias=DEFAULT_CONNECTION_NAME, **kwargs):
+def connect(db=None, alias=DEFAULT_CONNECTION_NAME, **kwargs):
     """Connect to the database specified by the 'db' argument.
 
     Connection settings may be provided here as well if the database is not
     running on the default port on localhost. If authentication is needed,
     provide username and password arguments as well.
 
-    Multiple databases are supported by using aliases.  Provide a separate
-    `alias` to connect to a different instance of :program:`mongod`.
+    Multiple databases are supported by using aliases. Provide a separate
+    `alias` to connect to a different instance of: program: `mongod`.
+
+    In order to replace a connection identified by a given alias, you'll
+    need to call ``disconnect`` first
+
+    See the docstring for `register_connection` for more details about all
+    supported kwargs.
 
     .. versionchanged:: 0.6 - added multiple database support.
     """
-    global _connections
-    if alias not in _connections:
+    if alias in _connections:
+        prev_conn_setting = _connection_settings[alias]
+        new_conn_settings = _get_connection_settings(db, **kwargs)
+
+        if new_conn_settings != prev_conn_setting:
+            err_msg = (
+                u'A different connection with alias `{}` was already '
+                u'registered. Use disconnect() first'
+            ).format(alias)
+            raise MongoEngineConnectionError(err_msg)
+    else:
         register_connection(alias, db, **kwargs)
 
     return get_connection(alias)

mongoengine/context_managers.py

@@ -1,14 +1,18 @@
+from contextlib import contextmanager
+
+from pymongo.write_concern import WriteConcern
+from six import iteritems
+
 from mongoengine.common import _import_class
 from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db
-from mongoengine.queryset import QuerySet
+from mongoengine.pymongo_support import count_documents
 
-
-__all__ = ("switch_db", "switch_collection", "no_dereference",
-           "no_sub_classes", "query_counter")
+__all__ = ('switch_db', 'switch_collection', 'no_dereference',
+           'no_sub_classes', 'query_counter', 'set_write_concern')
 
 
 class switch_db(object):
-    """ switch_db alias context manager.
+    """switch_db alias context manager.
 
     Example ::
 
@@ -19,15 +23,14 @@ class switch_db(object):
         class Group(Document):
             name = StringField()
 
-        Group(name="test").save()  # Saves in the default db
+        Group(name='test').save()  # Saves in the default db
 
         with switch_db(Group, 'testdb-1') as Group:
-            Group(name="hello testdb!").save()  # Saves in testdb-1
-
+            Group(name='hello testdb!').save()  # Saves in testdb-1
     """
 
     def __init__(self, cls, db_alias):
-        """ Construct the switch_db context manager
+        """Construct the switch_db context manager
 
         :param cls: the class to change the registered db
         :param db_alias: the name of the specific database to use
@@ -35,37 +38,36 @@ class switch_db(object):
         self.cls = cls
         self.collection = cls._get_collection()
         self.db_alias = db_alias
-        self.ori_db_alias = cls._meta.get("db_alias", DEFAULT_CONNECTION_NAME)
+        self.ori_db_alias = cls._meta.get('db_alias', DEFAULT_CONNECTION_NAME)
 
     def __enter__(self):
-        """ change the db_alias and clear the cached collection """
-        self.cls._meta["db_alias"] = self.db_alias
+        """Change the db_alias and clear the cached collection."""
+        self.cls._meta['db_alias'] = self.db_alias
         self.cls._collection = None
         return self.cls
 
     def __exit__(self, t, value, traceback):
-        """ Reset the db_alias and collection """
-        self.cls._meta["db_alias"] = self.ori_db_alias
+        """Reset the db_alias and collection."""
+        self.cls._meta['db_alias'] = self.ori_db_alias
         self.cls._collection = self.collection
 
 
 class switch_collection(object):
-    """ switch_collection alias context manager.
+    """switch_collection alias context manager.
 
     Example ::
 
         class Group(Document):
             name = StringField()
 
-        Group(name="test").save()  # Saves in the default db
+        Group(name='test').save()  # Saves in the default db
 
         with switch_collection(Group, 'group1') as Group:
-            Group(name="hello testdb!").save()  # Saves in group1 collection
-
+            Group(name='hello testdb!').save()  # Saves in group1 collection
     """
 
     def __init__(self, cls, collection_name):
-        """ Construct the switch_collection context manager
+        """Construct the switch_collection context manager.
 
         :param cls: the class to change the registered db
         :param collection_name: the name of the collection to use
@@ -76,7 +78,7 @@ class switch_collection(object):
         self.collection_name = collection_name
 
     def __enter__(self):
-        """ change the _get_collection_name and clear the cached collection """
+        """Change the _get_collection_name and clear the cached collection."""
 
         @classmethod
         def _get_collection_name(cls):
@@ -87,24 +89,23 @@ class switch_collection(object):
         return self.cls
 
     def __exit__(self, t, value, traceback):
-        """ Reset the collection """
+        """Reset the collection."""
         self.cls._collection = self.ori_collection
         self.cls._get_collection_name = self.ori_get_collection_name
 
 
 class no_dereference(object):
-    """ no_dereference context manager.
+    """no_dereference context manager.
 
     Turns off all dereferencing in Documents for the duration of the context
     manager::
 
         with no_dereference(Group) as Group:
             Group.objects.find()
-
     """
 
     def __init__(self, cls):
-        """ Construct the no_dereference context manager.
+        """Construct the no_dereference context manager.
 
         :param cls: the class to turn dereferencing off on
         """
@@ -114,115 +115,136 @@ class no_dereference(object):
         GenericReferenceField = _import_class('GenericReferenceField')
         ComplexBaseField = _import_class('ComplexBaseField')
 
-        self.deref_fields = [k for k, v in self.cls._fields.iteritems()
+        self.deref_fields = [k for k, v in iteritems(self.cls._fields)
                              if isinstance(v, (ReferenceField,
                                                GenericReferenceField,
                                                ComplexBaseField))]
 
     def __enter__(self):
-        """ change the objects default and _auto_dereference values"""
+        """Change the objects default and _auto_dereference values."""
         for field in self.deref_fields:
             self.cls._fields[field]._auto_dereference = False
         return self.cls
 
     def __exit__(self, t, value, traceback):
-        """ Reset the default and _auto_dereference values"""
+        """Reset the default and _auto_dereference values."""
         for field in self.deref_fields:
             self.cls._fields[field]._auto_dereference = True
         return self.cls
 
 
 class no_sub_classes(object):
-    """ no_sub_classes context manager.
+    """no_sub_classes context manager.
 
     Only returns instances of this class and no sub (inherited) classes::
 
         with no_sub_classes(Group) as Group:
             Group.objects.find()
-
     """
 
     def __init__(self, cls):
-        """ Construct the no_sub_classes context manager.
+        """Construct the no_sub_classes context manager.
 
         :param cls: the class to turn querying sub classes on
         """
         self.cls = cls
+        self.cls_initial_subclasses = None
 
     def __enter__(self):
-        """ change the objects default and _auto_dereference values"""
-        self.cls._all_subclasses = self.cls._subclasses
-        self.cls._subclasses = (self.cls,)
+        """Change the objects default and _auto_dereference values."""
+        self.cls_initial_subclasses = self.cls._subclasses
+        self.cls._subclasses = (self.cls._class_name,)
         return self.cls
 
     def __exit__(self, t, value, traceback):
-        """ Reset the default and _auto_dereference values"""
-        self.cls._subclasses = self.cls._all_subclasses
-        delattr(self.cls, '_all_subclasses')
-        return self.cls
-
-
-class QuerySetNoDeRef(QuerySet):
-    """Special no_dereference QuerySet"""
-    def __dereference(items, max_depth=1, instance=None, name=None):
-            return items
+        """Reset the default and _auto_dereference values."""
+        self.cls._subclasses = self.cls_initial_subclasses
 
 
 class query_counter(object):
-    """ Query_counter context manager to get the number of queries. """
+    """Query_counter context manager to get the number of queries.
+    This works by updating the `profiling_level` of the database so that all queries get logged,
+    resetting the db.system.profile collection at the beginnig of the context and counting the new entries.
+
+    This was designed for debugging purpose. In fact it is a global counter so queries issued by other threads/processes
+    can interfere with it
+
+    Be aware that:
+    - Iterating over large amount of documents (>101) makes pymongo issue `getmore` queries to fetch the next batch of
+        documents (https://docs.mongodb.com/manual/tutorial/iterate-a-cursor/#cursor-batches)
+    - Some queries are ignored by default by the counter (killcursors, db.system.indexes)
+    """
 
     def __init__(self):
-        """ Construct the query_counter. """
-        self.counter = 0
+        """Construct the query_counter
+        """
         self.db = get_db()
+        self.initial_profiling_level = None
+        self._ctx_query_counter = 0             # number of queries issued by the context
 
-    def __enter__(self):
-        """ On every with block we need to drop the profile collection. """
+        self._ignored_query = {
+            'ns':
+                {'$ne': '%s.system.indexes' % self.db.name},
+            'op':                       # MONGODB < 3.2
+                {'$ne': 'killcursors'},
+            'command.killCursors':      # MONGODB >= 3.2
+                {'$exists': False}
+        }
+
+    def _turn_on_profiling(self):
+        self.initial_profiling_level = self.db.profiling_level()
         self.db.set_profiling_level(0)
         self.db.system.profile.drop()
         self.db.set_profiling_level(2)
+
+    def _resets_profiling(self):
+        self.db.set_profiling_level(self.initial_profiling_level)
+
+    def __enter__(self):
+        self._turn_on_profiling()
         return self
 
     def __exit__(self, t, value, traceback):
-        """ Reset the profiling level. """
-        self.db.set_profiling_level(0)
+        self._resets_profiling()
 
     def __eq__(self, value):
-        """ == Compare querycounter. """
         counter = self._get_count()
         return value == counter
 
     def __ne__(self, value):
-        """ != Compare querycounter. """
         return not self.__eq__(value)
 
     def __lt__(self, value):
-        """ < Compare querycounter. """
         return self._get_count() < value
 
     def __le__(self, value):
-        """ <= Compare querycounter. """
         return self._get_count() <= value
 
     def __gt__(self, value):
-        """ > Compare querycounter. """
         return self._get_count() > value
 
     def __ge__(self, value):
-        """ >= Compare querycounter. """
         return self._get_count() >= value
 
     def __int__(self):
-        """ int representation. """
         return self._get_count()
 
     def __repr__(self):
-        """ repr query_counter as the number of queries. """
+        """repr query_counter as the number of queries."""
         return u"%s" % self._get_count()
 
     def _get_count(self):
-        """ Get the number of queries. """
-        ignore_query = {"ns": {"$ne": "%s.system.indexes" % self.db.name}}
-        count = self.db.system.profile.find(ignore_query).count() - self.counter
-        self.counter += 1
+        """Get the number of queries by counting the current number of entries in db.system.profile
+        and substracting the queries issued by this context. In fact everytime this is called, 1 query is
+        issued so we need to balance that
+        """
+        count = count_documents(self.db.system.profile, self._ignored_query) - self._ctx_query_counter
+        self._ctx_query_counter += 1    # Account for the query we just issued to gather the information
         return count
+
+
+@contextmanager
+def set_write_concern(collection, write_concerns):
+    combined_concerns = dict(collection.write_concern.document.items())
+    combined_concerns.update(write_concerns)
+    yield collection.with_options(write_concern=WriteConcern(**combined_concerns))

mongoengine/dereference.py

@@ -1,18 +1,21 @@
 from bson import DBRef, SON
+import six
+from six import iteritems
 
-from base import (BaseDict, BaseList, TopLevelDocumentMetaclass, get_document)
-from fields import (ReferenceField, ListField, DictField, MapField)
-from connection import get_db
-from queryset import QuerySet
-from document import Document, EmbeddedDocument
+from mongoengine.base import (BaseDict, BaseList, EmbeddedDocumentList,
+                              TopLevelDocumentMetaclass, get_document)
+from mongoengine.base.datastructures import LazyReference
+from mongoengine.connection import get_db
+from mongoengine.document import Document, EmbeddedDocument
+from mongoengine.fields import DictField, ListField, MapField, ReferenceField
+from mongoengine.queryset import QuerySet
 
 
 class DeReference(object):
-
     def __call__(self, items, max_depth=1, instance=None, name=None):
         """
         Cheaply dereferences the items to a set depth.
-        Also handles the convertion of complex data types.
+        Also handles the conversion of complex data types.
 
         :param items: The iterable (dict, list, queryset) to be dereferenced.
         :param max_depth: The maximum depth to recurse to
@@ -22,7 +25,7 @@ class DeReference(object):
             :class:`~mongoengine.base.ComplexBaseField`
         :param get: A boolean determining if being called by __get__
         """
-        if items is None or isinstance(items, basestring):
+        if items is None or isinstance(items, six.string_types):
             return items
 
         # cheapest way to convert a queryset to a list
@@ -36,7 +39,7 @@ class DeReference(object):
         if instance and isinstance(instance, (Document, EmbeddedDocument,
                                               TopLevelDocumentMetaclass)):
             doc_type = instance._fields.get(name)
-            if hasattr(doc_type, 'field'):
+            while hasattr(doc_type, 'field'):
                 doc_type = doc_type.field
 
             if isinstance(doc_type, ReferenceField):
@@ -46,20 +49,44 @@ class DeReference(object):
 
                 if is_list and all([i.__class__ == doc_type for i in items]):
                     return items
-                elif not is_list and all([i.__class__ == doc_type
-                                         for i in items.values()]):
+                elif not is_list and all(
+                        [i.__class__ == doc_type for i in items.values()]):
                     return items
                 elif not field.dbref:
+                    # We must turn the ObjectIds into DBRefs
+
+                    # Recursively dig into the sub items of a list/dict
+                    # to turn the ObjectIds into DBRefs
+                    def _get_items_from_list(items):
+                        new_items = []
+                        for v in items:
+                            value = v
+                            if isinstance(v, dict):
+                                value = _get_items_from_dict(v)
+                            elif isinstance(v, list):
+                                value = _get_items_from_list(v)
+                            elif not isinstance(v, (DBRef, Document)):
+                                value = field.to_python(v)
+                            new_items.append(value)
+                        return new_items
+
+                    def _get_items_from_dict(items):
+                        new_items = {}
+                        for k, v in iteritems(items):
+                            value = v
+                            if isinstance(v, list):
+                                value = _get_items_from_list(v)
+                            elif isinstance(v, dict):
+                                value = _get_items_from_dict(v)
+                            elif not isinstance(v, (DBRef, Document)):
+                                value = field.to_python(v)
+                            new_items[k] = value
+                        return new_items
+
                     if not hasattr(items, 'items'):
-                        items = [field.to_python(v)
-                             if not isinstance(v, (DBRef, Document)) else v
-                             for v in items]
+                        items = _get_items_from_list(items)
                     else:
-                        items = dict([
-                            (k, field.to_python(v))
-                            if not isinstance(v, (DBRef, Document)) else (k, v)
-                            for k, v in items.iteritems()]
-                        )
+                        items = _get_items_from_dict(items)
 
         self.reference_map = self._find_references(items)
         self.object_map = self._fetch_objects(doc_type=doc_type)
@@ -77,36 +104,42 @@ class DeReference(object):
             return reference_map
 
         # Determine the iterator to use
-        if not hasattr(items, 'items'):
-            iterator = enumerate(items)
+        if isinstance(items, dict):
+            iterator = items.values()
         else:
-            iterator = items.iteritems()
+            iterator = items
 
         # Recursively find dbreferences
         depth += 1
-        for k, item in iterator:
-            if isinstance(item, Document):
-                for field_name, field in item._fields.iteritems():
+        for item in iterator:
+            if isinstance(item, (Document, EmbeddedDocument)):
+                for field_name, field in iteritems(item._fields):
                     v = item._data.get(field_name, None)
-                    if isinstance(v, (DBRef)):
-                        reference_map.setdefault(field.document_type, []).append(v.id)
+                    if isinstance(v, LazyReference):
+                        # LazyReference inherits DBRef but should not be dereferenced here !
+                        continue
+                    elif isinstance(v, DBRef):
+                        reference_map.setdefault(field.document_type, set()).add(v.id)
                     elif isinstance(v, (dict, SON)) and '_ref' in v:
-                        reference_map.setdefault(get_document(v['_cls']), []).append(v['_ref'].id)
+                        reference_map.setdefault(get_document(v['_cls']), set()).add(v['_ref'].id)
                     elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth:
                         field_cls = getattr(getattr(field, 'field', None), 'document_type', None)
                         references = self._find_references(v, depth)
-                        for key, refs in references.iteritems():
+                        for key, refs in iteritems(references):
                             if isinstance(field_cls, (Document, TopLevelDocumentMetaclass)):
                                 key = field_cls
-                            reference_map.setdefault(key, []).extend(refs)
-            elif isinstance(item, (DBRef)):
-                reference_map.setdefault(item.collection, []).append(item.id)
+                            reference_map.setdefault(key, set()).update(refs)
+            elif isinstance(item, LazyReference):
+                # LazyReference inherits DBRef but should not be dereferenced here !
+                continue
+            elif isinstance(item, DBRef):
+                reference_map.setdefault(item.collection, set()).add(item.id)
             elif isinstance(item, (dict, SON)) and '_ref' in item:
-                reference_map.setdefault(get_document(item['_cls']), []).append(item['_ref'].id)
+                reference_map.setdefault(get_document(item['_cls']), set()).add(item['_ref'].id)
             elif isinstance(item, (dict, list, tuple)) and depth - 1 <= self.max_depth:
                 references = self._find_references(item, depth - 1)
-                for key, refs in references.iteritems():
-                    reference_map.setdefault(key, []).extend(refs)
+                for key, refs in iteritems(references):
+                    reference_map.setdefault(key, set()).update(refs)
 
         return reference_map
 
@@ -114,34 +147,43 @@ class DeReference(object):
         """Fetch all references and convert to their document objects
         """
         object_map = {}
-        for col, dbrefs in self.reference_map.iteritems():
-            keys = object_map.keys()
-            refs = list(set([dbref for dbref in dbrefs if unicode(dbref).encode('utf-8') not in keys]))
-            if hasattr(col, 'objects'):  # We have a document class for the refs
-                references = col.objects.in_bulk(refs)
-                for key, doc in references.iteritems():
-                    object_map[key] = doc
+        for collection, dbrefs in iteritems(self.reference_map):
+
+            # we use getattr instead of hasattr because hasattr swallows any exception under python2
+            # so it could hide nasty things without raising exceptions (cfr bug #1688))
+            ref_document_cls_exists = (getattr(collection, 'objects', None) is not None)
+
+            if ref_document_cls_exists:
+                col_name = collection._get_collection_name()
+                refs = [dbref for dbref in dbrefs
+                        if (col_name, dbref) not in object_map]
+                references = collection.objects.in_bulk(refs)
+                for key, doc in iteritems(references):
+                    object_map[(col_name, key)] = doc
             else:  # Generic reference: use the refs data to convert to document
-                if isinstance(doc_type, (ListField, DictField, MapField,)):
+                if isinstance(doc_type, (ListField, DictField, MapField)):
                     continue
 
+                refs = [dbref for dbref in dbrefs
+                        if (collection, dbref) not in object_map]
+
                 if doc_type:
-                    references = doc_type._get_db()[col].find({'_id': {'$in': refs}})
+                    references = doc_type._get_db()[collection].find({'_id': {'$in': refs}})
                     for ref in references:
                         doc = doc_type._from_son(ref)
-                        object_map[doc.id] = doc
+                        object_map[(collection, doc.id)] = doc
                 else:
-                    references = get_db()[col].find({'_id': {'$in': refs}})
+                    references = get_db()[collection].find({'_id': {'$in': refs}})
                     for ref in references:
                         if '_cls' in ref:
-                            doc = get_document(ref["_cls"])._from_son(ref)
+                            doc = get_document(ref['_cls'])._from_son(ref)
                         elif doc_type is None:
                             doc = get_document(
                                 ''.join(x.capitalize()
-                                    for x in col.split('_')))._from_son(ref)
+                                        for x in collection.split('_')))._from_son(ref)
                         else:
                             doc = doc_type._from_son(ref)
-                        object_map[doc.id] = doc
+                        object_map[(collection, doc.id)] = doc
         return object_map
 
     def _attach_objects(self, items, depth=0, instance=None, name=None):
@@ -167,20 +209,28 @@ class DeReference(object):
 
         if isinstance(items, (dict, SON)):
             if '_ref' in items:
-                return self.object_map.get(items['_ref'].id, items)
+                return self.object_map.get(
+                    (items['_ref'].collection, items['_ref'].id), items)
             elif '_cls' in items:
                 doc = get_document(items['_cls'])._from_son(items)
+                _cls = doc._data.pop('_cls', None)
+                del items['_cls']
                 doc._data = self._attach_objects(doc._data, depth, doc, None)
+                if _cls is not None:
+                    doc._data['_cls'] = _cls
                 return doc
 
         if not hasattr(items, 'items'):
             is_list = True
+            list_type = BaseList
+            if isinstance(items, EmbeddedDocumentList):
+                list_type = EmbeddedDocumentList
             as_tuple = isinstance(items, tuple)
             iterator = enumerate(items)
             data = []
         else:
             is_list = False
-            iterator = items.iteritems()
+            iterator = iteritems(items)
             data = {}
 
         depth += 1
@@ -192,25 +242,27 @@ class DeReference(object):
 
             if k in self.object_map and not is_list:
                 data[k] = self.object_map[k]
-            elif isinstance(v, Document):
-                for field_name, field in v._fields.iteritems():
+            elif isinstance(v, (Document, EmbeddedDocument)):
+                for field_name in v._fields:
                     v = data[k]._data.get(field_name, None)
-                    if isinstance(v, (DBRef)):
-                        data[k]._data[field_name] = self.object_map.get(v.id, v)
+                    if isinstance(v, DBRef):
+                        data[k]._data[field_name] = self.object_map.get(
+                            (v.collection, v.id), v)
                     elif isinstance(v, (dict, SON)) and '_ref' in v:
-                        data[k]._data[field_name] = self.object_map.get(v['_ref'].id, v)
-                    elif isinstance(v, dict) and depth <= self.max_depth:
-                        data[k]._data[field_name] = self._attach_objects(v, depth, instance=instance, name=name)
-                    elif isinstance(v, (list, tuple)) and depth <= self.max_depth:
-                        data[k]._data[field_name] = self._attach_objects(v, depth, instance=instance, name=name)
+                        data[k]._data[field_name] = self.object_map.get(
+                            (v['_ref'].collection, v['_ref'].id), v)
+                    elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth:
+                        item_name = six.text_type('{0}.{1}.{2}').format(name, k, field_name)
+                        data[k]._data[field_name] = self._attach_objects(v, depth, instance=instance, name=item_name)
             elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth:
-                data[k] = self._attach_objects(v, depth - 1, instance=instance, name=name)
-            elif hasattr(v, 'id'):
-                data[k] = self.object_map.get(v.id, v)
+                item_name = '%s.%s' % (name, k) if name else name
+                data[k] = self._attach_objects(v, depth - 1, instance=instance, name=item_name)
+            elif isinstance(v, DBRef) and hasattr(v, 'id'):
+                data[k] = self.object_map.get((v.collection, v.id), v)
 
         if instance and name:
             if is_list:
-                return tuple(data) if as_tuple else BaseList(data, instance, name)
+                return tuple(data) if as_tuple else list_type(data, instance, name)
             return BaseDict(data, instance, name)
         depth += 1
         return data

mongoengine/django/auth.py

@@ -1,406 +0,0 @@
-from mongoengine import *
-
-from django.utils.encoding import smart_str
-from django.contrib.auth.models import _user_has_perm, _user_get_all_permissions, _user_has_module_perms
-from django.db import models
-from django.contrib.contenttypes.models import ContentTypeManager
-from django.contrib import auth
-from django.contrib.auth.models import AnonymousUser
-from django.utils.translation import ugettext_lazy as _
-
-from .utils import datetime_now
-from .mongo_auth.models import get_user_document
-
-REDIRECT_FIELD_NAME = 'next'
-
-try:
-    from django.contrib.auth.hashers import check_password, make_password
-except ImportError:
-    """Handle older versions of Django"""
-    from django.utils.hashcompat import md5_constructor, sha_constructor
-
-    def get_hexdigest(algorithm, salt, raw_password):
-        raw_password, salt = smart_str(raw_password), smart_str(salt)
-        if algorithm == 'md5':
-            return md5_constructor(salt + raw_password).hexdigest()
-        elif algorithm == 'sha1':
-            return sha_constructor(salt + raw_password).hexdigest()
-        raise ValueError('Got unknown password algorithm type in password')
-
-    def check_password(raw_password, password):
-        algo, salt, hash = password.split('$')
-        return hash == get_hexdigest(algo, salt, raw_password)
-
-    def make_password(raw_password):
-        from random import random
-        algo = 'sha1'
-        salt = get_hexdigest(algo, str(random()), str(random()))[:5]
-        hash = get_hexdigest(algo, salt, raw_password)
-        return '%s$%s$%s' % (algo, salt, hash)
-
-
-class ContentType(Document):
-    name = StringField(max_length=100)
-    app_label = StringField(max_length=100)
-    model = StringField(max_length=100, verbose_name=_('python model class name'),
-                        unique_with='app_label')
-    objects = ContentTypeManager()
-
-    class Meta:
-        verbose_name = _('content type')
-        verbose_name_plural = _('content types')
-        # db_table = 'django_content_type'
-        # ordering = ('name',)
-        # unique_together = (('app_label', 'model'),)
-
-    def __unicode__(self):
-        return self.name
-
-    def model_class(self):
-        "Returns the Python model class for this type of content."
-        from django.db import models
-        return models.get_model(self.app_label, self.model)
-
-    def get_object_for_this_type(self, **kwargs):
-        """
-        Returns an object of this type for the keyword arguments given.
-        Basically, this is a proxy around this object_type's get_object() model
-        method. The ObjectNotExist exception, if thrown, will not be caught,
-        so code that calls this method should catch it.
-        """
-        return self.model_class()._default_manager.using(self._state.db).get(**kwargs)
-
-    def natural_key(self):
-        return (self.app_label, self.model)
-
-
-class SiteProfileNotAvailable(Exception):
-    pass
-
-
-class PermissionManager(models.Manager):
-    def get_by_natural_key(self, codename, app_label, model):
-        return self.get(
-            codename=codename,
-            content_type=ContentType.objects.get_by_natural_key(app_label, model)
-        )
-
-
-class Permission(Document):
-    """The permissions system provides a way to assign permissions to specific
-    users and groups of users.
-
-    The permission system is used by the Django admin site, but may also be
-    useful in your own code. The Django admin site uses permissions as follows:
-
-        - The "add" permission limits the user's ability to view the "add"
-          form and add an object.
-        - The "change" permission limits a user's ability to view the change
-          list, view the "change" form and change an object.
-        - The "delete" permission limits the ability to delete an object.
-
-    Permissions are set globally per type of object, not per specific object
-    instance. It is possible to say "Mary may change news stories," but it's
-    not currently possible to say "Mary may change news stories, but only the
-    ones she created herself" or "Mary may only change news stories that have
-    a certain status or publication date."
-
-    Three basic permissions -- add, change and delete -- are automatically
-    created for each Django model.
-    """
-    name = StringField(max_length=50, verbose_name=_('username'))
-    content_type = ReferenceField(ContentType)
-    codename = StringField(max_length=100, verbose_name=_('codename'))
-        # FIXME: don't access field of the other class
-        # unique_with=['content_type__app_label', 'content_type__model'])
-
-    objects = PermissionManager()
-
-    class Meta:
-        verbose_name = _('permission')
-        verbose_name_plural = _('permissions')
-        # unique_together = (('content_type', 'codename'),)
-        # ordering = ('content_type__app_label', 'content_type__model', 'codename')
-
-    def __unicode__(self):
-        return u"%s | %s | %s" % (
-            unicode(self.content_type.app_label),
-            unicode(self.content_type),
-            unicode(self.name))
-
-    def natural_key(self):
-        return (self.codename,) + self.content_type.natural_key()
-    natural_key.dependencies = ['contenttypes.contenttype']
-
-
-class Group(Document):
-    """Groups are a generic way of categorizing users to apply permissions,
-    or some other label, to those users. A user can belong to any number of
-    groups.
-
-    A user in a group automatically has all the permissions granted to that
-    group. For example, if the group Site editors has the permission
-    can_edit_home_page, any user in that group will have that permission.
-
-    Beyond permissions, groups are a convenient way to categorize users to
-    apply some label, or extended functionality, to them. For example, you
-    could create a group 'Special users', and you could write code that would
-    do special things to those users -- such as giving them access to a
-    members-only portion of your site, or sending them members-only
-    e-mail messages.
-    """
-    name = StringField(max_length=80, unique=True, verbose_name=_('name'))
-    permissions = ListField(ReferenceField(Permission, verbose_name=_('permissions'), required=False))
-
-    class Meta:
-        verbose_name = _('group')
-        verbose_name_plural = _('groups')
-
-    def __unicode__(self):
-        return self.name
-
-
-class UserManager(models.Manager):
-    def create_user(self, username, email, password=None):
-        """
-        Creates and saves a User with the given username, e-mail and password.
-        """
-        now = datetime_now()
-
-        # Normalize the address by lowercasing the domain part of the email
-        # address.
-        try:
-            email_name, domain_part = email.strip().split('@', 1)
-        except ValueError:
-            pass
-        else:
-            email = '@'.join([email_name, domain_part.lower()])
-
-        user = self.model(username=username, email=email, is_staff=False,
-                          is_active=True, is_superuser=False, last_login=now,
-                          date_joined=now)
-
-        user.set_password(password)
-        user.save(using=self._db)
-        return user
-
-    def create_superuser(self, username, email, password):
-        u = self.create_user(username, email, password)
-        u.is_staff = True
-        u.is_active = True
-        u.is_superuser = True
-        u.save(using=self._db)
-        return u
-
-    def make_random_password(self, length=10, allowed_chars='abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'):
-        "Generates a random password with the given length and given allowed_chars"
-        # Note that default value of allowed_chars does not have "I" or letters
-        # that look like it -- just to avoid confusion.
-        from random import choice
-        return ''.join([choice(allowed_chars) for i in range(length)])
-
-
-class User(Document):
-    """A User document that aims to mirror most of the API specified by Django
-    at http://docs.djangoproject.com/en/dev/topics/auth/#users
-    """
-    username = StringField(max_length=30, required=True,
-                           verbose_name=_('username'),
-                           help_text=_("Required. 30 characters or fewer. Letters, numbers and @/./+/-/_ characters"))
-
-    first_name = StringField(max_length=30,
-                             verbose_name=_('first name'))
-
-    last_name = StringField(max_length=30,
-                            verbose_name=_('last name'))
-    email = EmailField(verbose_name=_('e-mail address'))
-    password = StringField(max_length=128,
-                           verbose_name=_('password'),
-                           help_text=_("Use '[algo]$[iterations]$[salt]$[hexdigest]' or use the <a href=\"password/\">change password form</a>."))
-    is_staff = BooleanField(default=False,
-                            verbose_name=_('staff status'),
-                            help_text=_("Designates whether the user can log into this admin site."))
-    is_active = BooleanField(default=True,
-                             verbose_name=_('active'),
-                             help_text=_("Designates whether this user should be treated as active. Unselect this instead of deleting accounts."))
-    is_superuser = BooleanField(default=False,
-                                verbose_name=_('superuser status'),
-                                help_text=_("Designates that this user has all permissions without explicitly assigning them."))
-    last_login = DateTimeField(default=datetime_now,
-                               verbose_name=_('last login'))
-    date_joined = DateTimeField(default=datetime_now,
-                                verbose_name=_('date joined'))
-
-    user_permissions = ListField(ReferenceField(Permission), verbose_name=_('user permissions'),
-                                                help_text=_('Permissions for the user.'))
-
-    USERNAME_FIELD = 'username'
-    REQUIRED_FIELDS = ['email']
-
-    meta = {
-        'allow_inheritance': True,
-        'indexes': [
-            {'fields': ['username'], 'unique': True, 'sparse': True}
-        ]
-    }
-
-    def __unicode__(self):
-        return self.username
-
-    def get_full_name(self):
-        """Returns the users first and last names, separated by a space.
-        """
-        full_name = u'%s %s' % (self.first_name or '', self.last_name or '')
-        return full_name.strip()
-
-    def is_anonymous(self):
-        return False
-
-    def is_authenticated(self):
-        return True
-
-    def set_password(self, raw_password):
-        """Sets the user's password - always use this rather than directly
-        assigning to :attr:`~mongoengine.django.auth.User.password` as the
-        password is hashed before storage.
-        """
-        self.password = make_password(raw_password)
-        self.save()
-        return self
-
-    def check_password(self, raw_password):
-        """Checks the user's password against a provided password - always use
-        this rather than directly comparing to
-        :attr:`~mongoengine.django.auth.User.password` as the password is
-        hashed before storage.
-        """
-        return check_password(raw_password, self.password)
-
-    @classmethod
-    def create_user(cls, username, password, email=None):
-        """Create (and save) a new user with the given username, password and
-        email address.
-        """
-        now = datetime_now()
-
-        # Normalize the address by lowercasing the domain part of the email
-        # address.
-        if email is not None:
-            try:
-                email_name, domain_part = email.strip().split('@', 1)
-            except ValueError:
-                pass
-            else:
-                email = '@'.join([email_name, domain_part.lower()])
-
-        user = cls(username=username, email=email, date_joined=now)
-        user.set_password(password)
-        user.save()
-        return user
-
-    def get_group_permissions(self, obj=None):
-        """
-        Returns a list of permission strings that this user has through his/her
-        groups. This method queries all available auth backends. If an object
-        is passed in, only permissions matching this object are returned.
-        """
-        permissions = set()
-        for backend in auth.get_backends():
-            if hasattr(backend, "get_group_permissions"):
-                permissions.update(backend.get_group_permissions(self, obj))
-        return permissions
-
-    def get_all_permissions(self, obj=None):
-        return _user_get_all_permissions(self, obj)
-
-    def has_perm(self, perm, obj=None):
-        """
-        Returns True if the user has the specified permission. This method
-        queries all available auth backends, but returns immediately if any
-        backend returns True. Thus, a user who has permission from a single
-        auth backend is assumed to have permission in general. If an object is
-        provided, permissions for this specific object are checked.
-        """
-
-        # Active superusers have all permissions.
-        if self.is_active and self.is_superuser:
-            return True
-
-        # Otherwise we need to check the backends.
-        return _user_has_perm(self, perm, obj)
-
-    def has_module_perms(self, app_label):
-        """
-        Returns True if the user has any permissions in the given app label.
-        Uses pretty much the same logic as has_perm, above.
-        """
-        # Active superusers have all permissions.
-        if self.is_active and self.is_superuser:
-            return True
-
-        return _user_has_module_perms(self, app_label)
-
-    def email_user(self, subject, message, from_email=None):
-        "Sends an e-mail to this User."
-        from django.core.mail import send_mail
-        send_mail(subject, message, from_email, [self.email])
-
-    def get_profile(self):
-        """
-        Returns site-specific profile for this user. Raises
-        SiteProfileNotAvailable if this site does not allow profiles.
-        """
-        if not hasattr(self, '_profile_cache'):
-            from django.conf import settings
-            if not getattr(settings, 'AUTH_PROFILE_MODULE', False):
-                raise SiteProfileNotAvailable('You need to set AUTH_PROFILE_MO'
-                                              'DULE in your project settings')
-            try:
-                app_label, model_name = settings.AUTH_PROFILE_MODULE.split('.')
-            except ValueError:
-                raise SiteProfileNotAvailable('app_label and model_name should'
-                        ' be separated by a dot in the AUTH_PROFILE_MODULE set'
-                        'ting')
-
-            try:
-                model = models.get_model(app_label, model_name)
-                if model is None:
-                    raise SiteProfileNotAvailable('Unable to load the profile '
-                        'model, check AUTH_PROFILE_MODULE in your project sett'
-                        'ings')
-                self._profile_cache = model._default_manager.using(self._state.db).get(user__id__exact=self.id)
-                self._profile_cache.user = self
-            except (ImportError, ImproperlyConfigured):
-                raise SiteProfileNotAvailable
-        return self._profile_cache
-
-
-class MongoEngineBackend(object):
-    """Authenticate using MongoEngine and mongoengine.django.auth.User.
-    """
-
-    supports_object_permissions = False
-    supports_anonymous_user = False
-    supports_inactive_user = False
-
-    def authenticate(self, username=None, password=None):
-        user = get_user_document().objects(username=username).first()
-        if user:
-            if password and user.check_password(password):
-                backend = auth.get_backends()[0]
-                user.backend = "%s.%s" % (backend.__module__, backend.__class__.__name__)
-                return user
-        return None
-
-    def get_user(self, user_id):
-        return get_user_document().objects.with_id(user_id)
-
-
-def get_user(userid):
-    """Returns a User object from an id (User.id). Django's equivalent takes
-    request, but taking an id instead leaves it up to the developer to store
-    the id in any way they want (session, signed cookie, etc.)
-    """
-    if not userid:
-        return AnonymousUser()
-    return MongoEngineBackend().get_user(userid) or AnonymousUser()

mongoengine/django/mongo_auth/models.py

@@ -1,115 +0,0 @@
-from django.conf import settings
-from django.contrib.auth.hashers import make_password
-from django.contrib.auth.models import UserManager
-from django.core.exceptions import ImproperlyConfigured
-from django.db import models
-from django.utils.importlib import import_module
-from django.utils.translation import ugettext_lazy as _
-
-
-__all__ = (
-    'get_user_document',
-)
-
-
-MONGOENGINE_USER_DOCUMENT = getattr(
-    settings, 'MONGOENGINE_USER_DOCUMENT', 'mongoengine.django.auth.User')
-
-
-def get_user_document():
-    """Get the user document class used for authentication.
-
-    This is the class defined in settings.MONGOENGINE_USER_DOCUMENT, which
-    defaults to `mongoengine.django.auth.User`.
-
-    """
-
-    name = MONGOENGINE_USER_DOCUMENT
-    dot = name.rindex('.')
-    module = import_module(name[:dot])
-    return getattr(module, name[dot + 1:])
-
-
-class MongoUserManager(UserManager):
-    """A User manager wich allows the use of MongoEngine documents in Django.
-
-    To use the manager, you must tell django.contrib.auth to use MongoUser as
-    the user model. In you settings.py, you need:
-
-        INSTALLED_APPS = (
-            ...
-            'django.contrib.auth',
-            'mongoengine.django.mongo_auth',
-            ...
-        )
-        AUTH_USER_MODEL = 'mongo_auth.MongoUser'
-
-    Django will use the model object to access the custom Manager, which will
-    replace the original queryset with MongoEngine querysets.
-
-    By default, mongoengine.django.auth.User will be used to store users. You
-    can specify another document class in MONGOENGINE_USER_DOCUMENT in your
-    settings.py.
-
-    The User Document class has the same requirements as a standard custom user
-    model: https://docs.djangoproject.com/en/dev/topics/auth/customizing/
-
-    In particular, the User Document class must define USERNAME_FIELD and
-    REQUIRED_FIELDS.
-
-    `AUTH_USER_MODEL` has been added in Django 1.5.
-
-    """
-
-    def contribute_to_class(self, model, name):
-        super(MongoUserManager, self).contribute_to_class(model, name)
-        self.dj_model = self.model
-        self.model = get_user_document()
-
-        self.dj_model.USERNAME_FIELD = self.model.USERNAME_FIELD
-        username = models.CharField(_('username'), max_length=30, unique=True)
-        username.contribute_to_class(self.dj_model, self.dj_model.USERNAME_FIELD)
-
-        self.dj_model.REQUIRED_FIELDS = self.model.REQUIRED_FIELDS
-        for name in self.dj_model.REQUIRED_FIELDS:
-            field = models.CharField(_(name), max_length=30)
-            field.contribute_to_class(self.dj_model, name)
-
-
-    def get(self, *args, **kwargs):
-        try:
-            return self.get_query_set().get(*args, **kwargs)
-        except self.model.DoesNotExist:
-            # ModelBackend expects this exception
-            raise self.dj_model.DoesNotExist
-
-    @property
-    def db(self):
-        raise NotImplementedError
-
-    def get_empty_query_set(self):
-        return self.model.objects.none()
-
-    def get_query_set(self):
-        return self.model.objects
-
-
-class MongoUser(models.Model):
-    """"Dummy user model for Django.
-
-    MongoUser is used to replace Django's UserManager with MongoUserManager.
-    The actual user document class is mongoengine.django.auth.User or any
-    other document class specified in MONGOENGINE_USER_DOCUMENT.
-
-    To get the user document class, use `get_user_document()`.
-
-    """
-
-    objects = MongoUserManager()
-
-    class Meta:
-        app_label = 'mongo_auth'
-
-    def set_password(self, password):
-        """Doesn't do anything, but works around the issue with Django 1.6."""
-        make_password(password)

mongoengine/django/sessions.py

@@ -1,124 +0,0 @@
-from bson import json_util
-from django.conf import settings
-from django.contrib.sessions.backends.base import SessionBase, CreateError
-from django.core.exceptions import SuspiciousOperation
-try:
-    from django.utils.encoding import force_unicode
-except ImportError:
-    from django.utils.encoding import force_text as force_unicode
-
-from mongoengine.document import Document
-from mongoengine import fields
-from mongoengine.queryset import OperationError
-from mongoengine.connection import DEFAULT_CONNECTION_NAME
-
-from .utils import datetime_now
-
-
-MONGOENGINE_SESSION_DB_ALIAS = getattr(
-    settings, 'MONGOENGINE_SESSION_DB_ALIAS',
-    DEFAULT_CONNECTION_NAME)
-
-# a setting for the name of the collection used to store sessions
-MONGOENGINE_SESSION_COLLECTION = getattr(
-    settings, 'MONGOENGINE_SESSION_COLLECTION',
-    'django_session')
-
-# a setting for whether session data is stored encoded or not
-MONGOENGINE_SESSION_DATA_ENCODE = getattr(
-    settings, 'MONGOENGINE_SESSION_DATA_ENCODE',
-    True)
-
-
-class MongoSession(Document):
-    session_key = fields.StringField(primary_key=True, max_length=40)
-    session_data = fields.StringField() if MONGOENGINE_SESSION_DATA_ENCODE \
-                                        else fields.DictField()
-    expire_date = fields.DateTimeField()
-
-    meta = {
-        'collection': MONGOENGINE_SESSION_COLLECTION,
-        'db_alias': MONGOENGINE_SESSION_DB_ALIAS,
-        'allow_inheritance': False,
-        'indexes': [
-            {
-                'fields': ['expire_date'],
-                'expireAfterSeconds': 0
-            }
-        ]
-    }
-
-    def get_decoded(self):
-        return SessionStore().decode(self.session_data)
-
-
-class SessionStore(SessionBase):
-    """A MongoEngine-based session store for Django.
-    """
-
-    def _get_session(self, *args, **kwargs):
-        sess = super(SessionStore, self)._get_session(*args, **kwargs)
-        if sess.get('_auth_user_id', None):
-            sess['_auth_user_id'] = str(sess.get('_auth_user_id'))
-        return sess
-
-    def load(self):
-        try:
-            s = MongoSession.objects(session_key=self.session_key,
-                                     expire_date__gt=datetime_now)[0]
-            if MONGOENGINE_SESSION_DATA_ENCODE:
-                return self.decode(force_unicode(s.session_data))
-            else:
-                return s.session_data
-        except (IndexError, SuspiciousOperation):
-            self.create()
-            return {}
-
-    def exists(self, session_key):
-        return bool(MongoSession.objects(session_key=session_key).first())
-
-    def create(self):
-        while True:
-            self._session_key = self._get_new_session_key()
-            try:
-                self.save(must_create=True)
-            except CreateError:
-                continue
-            self.modified = True
-            self._session_cache = {}
-            return
-
-    def save(self, must_create=False):
-        if self.session_key is None:
-            self._session_key = self._get_new_session_key()
-        s = MongoSession(session_key=self.session_key)
-        if MONGOENGINE_SESSION_DATA_ENCODE:
-            s.session_data = self.encode(self._get_session(no_load=must_create))
-        else:
-            s.session_data = self._get_session(no_load=must_create)
-        s.expire_date = self.get_expiry_date()
-        try:
-            s.save(force_insert=must_create)
-        except OperationError:
-            if must_create:
-                raise CreateError
-            raise
-
-    def delete(self, session_key=None):
-        if session_key is None:
-            if self.session_key is None:
-                return
-            session_key = self.session_key
-        MongoSession.objects(session_key=session_key).delete()
-
-
-class BSONSerializer(object):
-    """
-    Serializer that can handle BSON types (eg ObjectId).
-    """
-    def dumps(self, obj):
-        return json_util.dumps(obj, separators=(',', ':')).encode('ascii')
-
-    def loads(self, data):
-        return json_util.loads(data.decode('ascii'))
-

mongoengine/django/shortcuts.py

@@ -1,47 +0,0 @@
-from mongoengine.queryset import QuerySet
-from mongoengine.base import BaseDocument
-from mongoengine.errors import ValidationError
-
-def _get_queryset(cls):
-    """Inspired by django.shortcuts.*"""
-    if isinstance(cls, QuerySet):
-        return cls
-    else:
-        return cls.objects
-
-def get_document_or_404(cls, *args, **kwargs):
-    """
-    Uses get() to return an document, or raises a Http404 exception if the document
-    does not exist.
-
-    cls may be a Document or QuerySet object. All other passed
-    arguments and keyword arguments are used in the get() query.
-
-    Note: Like with get(), an MultipleObjectsReturned will be raised if more than one
-    object is found.
-
-    Inspired by django.shortcuts.*
-    """
-    queryset = _get_queryset(cls)
-    try:
-        return queryset.get(*args, **kwargs)
-    except (queryset._document.DoesNotExist, ValidationError):
-        from django.http import Http404
-        raise Http404('No %s matches the given query.' % queryset._document._class_name)
-
-def get_list_or_404(cls, *args, **kwargs):
-    """
-    Uses filter() to return a list of documents, or raise a Http404 exception if
-    the list is empty.
-
-    cls may be a Document or QuerySet object. All other passed
-    arguments and keyword arguments are used in the filter() query.
-
-    Inspired by django.shortcuts.*
-    """
-    queryset = _get_queryset(cls)
-    obj_list = list(queryset.filter(*args, **kwargs))
-    if not obj_list:
-        from django.http import Http404
-        raise Http404('No %s matches the given query.' % queryset._document._class_name)
-    return obj_list

mongoengine/django/storage.py

@@ -1,112 +0,0 @@
-import os
-import itertools
-import urlparse
-
-from mongoengine import *
-from django.conf import settings
-from django.core.files.storage import Storage
-from django.core.exceptions import ImproperlyConfigured
-
-
-class FileDocument(Document):
-    """A document used to store a single file in GridFS.
-    """
-    file = FileField()
-
-
-class GridFSStorage(Storage):
-    """A custom storage backend to store files in GridFS
-    """
-
-    def __init__(self, base_url=None):
-
-        if base_url is None:
-            base_url = settings.MEDIA_URL
-        self.base_url = base_url
-        self.document = FileDocument
-        self.field = 'file'
-
-    def delete(self, name):
-        """Deletes the specified file from the storage system.
-        """
-        if self.exists(name):
-            doc = self.document.objects.first()
-            field = getattr(doc, self.field)
-            self._get_doc_with_name(name).delete()  # Delete the FileField
-            field.delete()                          # Delete the FileDocument
-
-    def exists(self, name):
-        """Returns True if a file referened by the given name already exists in the
-        storage system, or False if the name is available for a new file.
-        """
-        doc = self._get_doc_with_name(name)
-        if doc:
-            field = getattr(doc, self.field)
-            return bool(field.name)
-        else:
-            return False
-
-    def listdir(self, path=None):
-        """Lists the contents of the specified path, returning a 2-tuple of lists;
-        the first item being directories, the second item being files.
-        """
-        def name(doc):
-            return getattr(doc, self.field).name
-        docs = self.document.objects
-        return [], [name(d) for d in docs if name(d)]
-
-    def size(self, name):
-        """Returns the total size, in bytes, of the file specified by name.
-        """
-        doc = self._get_doc_with_name(name)
-        if doc:
-            return getattr(doc, self.field).length
-        else:
-            raise ValueError("No such file or directory: '%s'" % name)
-
-    def url(self, name):
-        """Returns an absolute URL where the file's contents can be accessed
-        directly by a web browser.
-        """
-        if self.base_url is None:
-            raise ValueError("This file is not accessible via a URL.")
-        return urlparse.urljoin(self.base_url, name).replace('\\', '/')
-
-    def _get_doc_with_name(self, name):
-        """Find the documents in the store with the given name
-        """
-        docs = self.document.objects
-        doc = [d for d in docs if hasattr(getattr(d, self.field), 'name') and getattr(d, self.field).name == name]
-        if doc:
-            return doc[0]
-        else:
-            return None
-
-    def _open(self, name, mode='rb'):
-        doc = self._get_doc_with_name(name)
-        if doc:
-            return getattr(doc, self.field)
-        else:
-            raise ValueError("No file found with the name '%s'." % name)
-
-    def get_available_name(self, name):
-        """Returns a filename that's free on the target storage system, and
-        available for new content to be written to.
-        """
-        file_root, file_ext = os.path.splitext(name)
-        # If the filename already exists, add an underscore and a number (before
-        # the file extension, if one exists) to the filename until the generated
-        # filename doesn't exist.
-        count = itertools.count(1)
-        while self.exists(name):
-            # file_ext includes the dot.
-            name = os.path.join("%s_%s%s" % (file_root, count.next(), file_ext))
-
-        return name
-
-    def _save(self, name, content):
-        doc = self.document()
-        getattr(doc, self.field).put(content, filename=name)
-        doc.save()
-
-        return name

mongoengine/django/tests.py

@@ -1,39 +0,0 @@
-#coding: utf-8
-from nose.plugins.skip import SkipTest
-
-from mongoengine.python_support import PY3
-from mongoengine import connect
-
-try:
-    from django.test import TestCase
-    from django.conf import settings
-except Exception as err:
-    if PY3:
-        from unittest import TestCase
-        # Dummy value so no error
-        class settings:
-            MONGO_DATABASE_NAME = 'dummy'
-    else:
-        raise err
-
-
-class MongoTestCase(TestCase):
-
-    def setUp(self):
-        if PY3:
-            raise SkipTest('django does not have Python 3 support')
-
-    """
-    TestCase class that clear the collection between the tests
-    """
-    db_name = 'test_%s' % settings.MONGO_DATABASE_NAME
-    def __init__(self, methodName='runtest'):
-        self.db = connect(self.db_name).get_db()
-        super(MongoTestCase, self).__init__(methodName)
-
-    def _post_teardown(self):
-        super(MongoTestCase, self)._post_teardown()
-        for collection in self.db.collection_names():
-            if collection == 'system.indexes':
-                continue
-            self.db.drop_collection(collection)

mongoengine/django/utils.py

@@ -1,6 +0,0 @@
-try:
-    # django >= 1.4
-    from django.utils.timezone import now as datetime_now
-except ImportError:
-    from datetime import datetime
-    datetime_now = datetime.now

mongoengine/errors.py

@@ -1,11 +1,12 @@
 from collections import defaultdict
 
-from mongoengine.python_support import txt_type
-
+import six
+from six import iteritems
 
 __all__ = ('NotRegistered', 'InvalidDocumentError', 'LookUpError',
            'DoesNotExist', 'MultipleObjectsReturned', 'InvalidQueryError',
-           'OperationError', 'NotUniqueError', 'ValidationError')
+           'OperationError', 'NotUniqueError', 'FieldDoesNotExist',
+           'ValidationError', 'SaveConditionError', 'DeprecatedError')
 
 
 class NotRegistered(Exception):
@@ -40,6 +41,21 @@ class NotUniqueError(OperationError):
     pass
 
 
+class SaveConditionError(OperationError):
+    pass
+
+
+class FieldDoesNotExist(Exception):
+    """Raised when trying to set a field
+    not declared in a :class:`~mongoengine.Document`
+    or an :class:`~mongoengine.EmbeddedDocument`.
+
+    To avoid this behavior on data loading,
+    you should set the :attr:`strict` to ``False``
+    in the :attr:`meta` dictionary.
+    """
+
+
 class ValidationError(AssertionError):
     """Validation exception.
 
@@ -55,13 +71,14 @@ class ValidationError(AssertionError):
     field_name = None
     _message = None
 
-    def __init__(self, message="", **kwargs):
+    def __init__(self, message='', **kwargs):
+        super(ValidationError, self).__init__(message)
         self.errors = kwargs.get('errors', {})
         self.field_name = kwargs.get('field_name')
         self.message = message
 
     def __str__(self):
-        return txt_type(self.message)
+        return six.text_type(self.message)
 
     def __repr__(self):
         return '%s(%s,)' % (self.__class__.__name__, self.message)
@@ -93,18 +110,19 @@ class ValidationError(AssertionError):
 
         def build_dict(source):
             errors_dict = {}
-            if not source:
-                return errors_dict
             if isinstance(source, dict):
-                for field_name, error in source.iteritems():
+                for field_name, error in iteritems(source):
                     errors_dict[field_name] = build_dict(error)
             elif isinstance(source, ValidationError) and source.errors:
                 return build_dict(source.errors)
             else:
-                return unicode(source)
+                return six.text_type(source)
+
             return errors_dict
+
         if not self.errors:
             return {}
+
         return build_dict(self.errors)
 
     def _format_errors(self):
@@ -113,14 +131,19 @@ class ValidationError(AssertionError):
         def generate_key(value, prefix=''):
             if isinstance(value, list):
                 value = ' '.join([generate_key(k) for k in value])
-            if isinstance(value, dict):
+            elif isinstance(value, dict):
                 value = ' '.join(
-                        [generate_key(v, k) for k, v in value.iteritems()])
+                    [generate_key(v, k) for k, v in iteritems(value)])
 
-            results = "%s.%s" % (prefix, value) if prefix else value
+            results = '%s.%s' % (prefix, value) if prefix else value
             return results
 
         error_dict = defaultdict(list)
-        for k, v in self.to_dict().iteritems():
+        for k, v in iteritems(self.to_dict()):
             error_dict[generate_key(v)].append(k)
-        return ' '.join(["%s: %s" % (k, v) for k, v in error_dict.iteritems()])
+        return ' '.join(['%s: %s' % (k, v) for k, v in iteritems(error_dict)])
+
+
+class DeprecatedError(Exception):
+    """Raise when a user uses a feature that has been Deprecated"""
+    pass

mongoengine/mongodb_support.py

@@ -0,0 +1,19 @@
+"""
+Helper functions, constants, and types to aid with MongoDB version support
+"""
+from mongoengine.connection import get_connection
+
+
+# Constant that can be used to compare the version retrieved with
+# get_mongodb_version()
+MONGODB_34 = (3, 4)
+MONGODB_36 = (3, 6)
+
+
+def get_mongodb_version():
+    """Return the version of the connected mongoDB (first 2 digits)
+
+    :return: tuple(int, int)
+    """
+    version_list = get_connection().server_info()['versionArray'][:2]     # e.g: (3, 2)
+    return tuple(version_list)

mongoengine/pymongo_support.py

@@ -0,0 +1,32 @@
+"""
+Helper functions, constants, and types to aid with PyMongo v2.7 - v3.x support.
+"""
+import pymongo
+
+_PYMONGO_37 = (3, 7)
+
+PYMONGO_VERSION = tuple(pymongo.version_tuple[:2])
+
+IS_PYMONGO_GTE_37 = PYMONGO_VERSION >= _PYMONGO_37
+
+
+def count_documents(collection, filter):
+    """Pymongo>3.7 deprecates count in favour of count_documents"""
+    if IS_PYMONGO_GTE_37:
+        return collection.count_documents(filter)
+    else:
+        count = collection.find(filter).count()
+    return count
+
+
+def list_collection_names(db, include_system_collections=False):
+    """Pymongo>3.7 deprecates collection_names in favour of list_collection_names"""
+    if IS_PYMONGO_GTE_37:
+        collections = db.list_collection_names()
+    else:
+        collections = db.collection_names()
+
+    if not include_system_collections:
+        collections = [c for c in collections if not c.startswith('system.')]
+
+    return collections

mongoengine/python_support.py

@@ -1,61 +1,23 @@
-"""Helper functions and types to aid with Python 2.5 - 3 support."""
+"""
+Helper functions, constants, and types to aid with Python v2.7 - v3.x support
+"""
+import six
 
-import sys
+# six.BytesIO resolves to StringIO.StringIO in Py2 and io.BytesIO in Py3.
+StringIO = six.BytesIO
 
-PY3 = sys.version_info[0] == 3
-PY25 = sys.version_info[:2] == (2, 5)
-UNICODE_KWARGS = int(''.join([str(x) for x in sys.version_info[:3]])) > 264
-
-if PY3:
-    import codecs
-    from io import BytesIO as StringIO
-    # return s converted to binary.  b('test') should be equivalent to b'test'
-    def b(s):
-        return codecs.latin_1_encode(s)[0]
-
-    bin_type = bytes
-    txt_type   = str
-else:
+# Additionally for Py2, try to use the faster cStringIO, if available
+if not six.PY3:
     try:
-        from cStringIO import StringIO
+        import cStringIO
     except ImportError:
-        from StringIO import StringIO
-
-    # Conversion to binary only necessary in Python 3
-    def b(s):
-        return s
-
-    bin_type = str
-    txt_type = unicode
-
-str_types = (bin_type, txt_type)
-
-if PY25:
-    def product(*args, **kwds):
-        pools = map(tuple, args) * kwds.get('repeat', 1)
-        result = [[]]
-        for pool in pools:
-            result = [x + [y] for x in result for y in pool]
-        for prod in result:
-            yield tuple(prod)
-    reduce = reduce
-else:
-    from itertools import product
-    from functools import reduce
-
-
-# For use with Python 2.5
-# converts all keys from unicode to str for d and all nested dictionaries
-def to_str_keys_recursive(d):
-    if isinstance(d, list):
-        for val in d:
-            if isinstance(val, (dict, list)):
-                to_str_keys_recursive(val)
-    elif isinstance(d, dict):
-        for key, val in d.items():
-            if isinstance(val, (dict, list)):
-                to_str_keys_recursive(val)
-            if isinstance(key, unicode):
-                d[str(key)] = d.pop(key)
+        pass
     else:
-        raise ValueError("non list/dict parameter not allowed")
+        StringIO = cStringIO.StringIO
+
+
+if six.PY3:
+    from collections.abc import Hashable
+else:
+    # raises DeprecationWarnings in Python >=3.7
+    from collections import Hashable

mongoengine/queryset/__init__.py

@@ -1,11 +1,17 @@
-from mongoengine.errors import (DoesNotExist, MultipleObjectsReturned,
-                                InvalidQueryError, OperationError,
-                                NotUniqueError)
+from mongoengine.errors import *
 from mongoengine.queryset.field_list import *
 from mongoengine.queryset.manager import *
 from mongoengine.queryset.queryset import *
 from mongoengine.queryset.transform import *
 from mongoengine.queryset.visitor import *
 
-__all__ = (field_list.__all__ + manager.__all__ + queryset.__all__ +
-           transform.__all__ + visitor.__all__)
+# Expose just the public subset of all imported objects and constants.
+__all__ = (
+    'QuerySet', 'QuerySetNoCache', 'Q', 'queryset_manager', 'QuerySetManager',
+    'QueryFieldList', 'DO_NOTHING', 'NULLIFY', 'CASCADE', 'DENY', 'PULL',
+
+    # Errors that might be related to a queryset, mostly here for backward
+    # compatibility
+    'DoesNotExist', 'InvalidQueryError', 'MultipleObjectsReturned',
+    'NotUniqueError', 'OperationError',
+)

mongoengine/queryset/field_list.py

@@ -1,4 +1,3 @@
-
 __all__ = ('QueryFieldList',)
 
 
@@ -64,11 +63,13 @@ class QueryFieldList(object):
             self._only_called = True
         return self
 
-    def __nonzero__(self):
+    def __bool__(self):
         return bool(self.fields)
 
+    __nonzero__ = __bool__  # For Py2 support
+
     def as_dict(self):
-        field_list = dict((field, self.value) for field in self.fields)
+        field_list = {field: self.value for field in self.fields}
         if self.slice:
             field_list.update(self.slice)
         if self._id is not None:

mongoengine/queryset/manager.py

@@ -29,14 +29,14 @@ class QuerySetManager(object):
         Document.objects is accessed.
         """
         if instance is not None:
-            # Document class being used rather than a document object
+            # Document object being used rather than a document class
             return self
 
         # owner is the document that contains the QuerySetManager
         queryset_class = owner._meta.get('queryset_class', self.default)
         queryset = queryset_class(owner, owner._get_collection())
         if self.get_queryset:
-            arg_count = self.get_queryset.func_code.co_argcount
+            arg_count = self.get_queryset.__code__.co_argcount
             if arg_count == 1:
                 queryset = self.get_queryset(queryset)
             elif arg_count == 2:

mongoengine/queryset/queryset.py

@@ -1,6 +1,8 @@
+import six
+
 from mongoengine.errors import OperationError
-from mongoengine.queryset.base import (BaseQuerySet, DO_NOTHING, NULLIFY,
-                                       CASCADE, DENY, PULL)
+from mongoengine.queryset.base import (BaseQuerySet, CASCADE, DENY, DO_NOTHING,
+                                       NULLIFY, PULL)
 
 __all__ = ('QuerySet', 'QuerySetNoCache', 'DO_NOTHING', 'NULLIFY', 'CASCADE',
            'DENY', 'PULL')
@@ -27,9 +29,10 @@ class QuerySet(BaseQuerySet):
         in batches of ``ITER_CHUNK_SIZE``.
 
         If ``self._has_more`` the cursor hasn't been exhausted so cache then
-        batch.  Otherwise iterate the result_cache.
+        batch. Otherwise iterate the result_cache.
         """
         self._iter = True
+
         if self._has_more:
             return self._iter_results()
 
@@ -38,45 +41,60 @@ class QuerySet(BaseQuerySet):
 
     def __len__(self):
         """Since __len__ is called quite frequently (for example, as part of
-        list(qs) we populate the result cache and cache the length.
+        list(qs)), we populate the result cache and cache the length.
         """
         if self._len is not None:
             return self._len
+
+        # Populate the result cache with *all* of the docs in the cursor
         if self._has_more:
-            # populate the cache
             list(self._iter_results())
 
+        # Cache the length of the complete result cache and return it
         self._len = len(self._result_cache)
         return self._len
 
     def __repr__(self):
-        """Provides the string representation of the QuerySet
-        """
+        """Provide a string representation of the QuerySet"""
         if self._iter:
             return '.. queryset mid-iteration ..'
 
         self._populate_cache()
         data = self._result_cache[:REPR_OUTPUT_SIZE + 1]
         if len(data) > REPR_OUTPUT_SIZE:
-            data[-1] = "...(remaining elements truncated)..."
+            data[-1] = '...(remaining elements truncated)...'
         return repr(data)
 
-
     def _iter_results(self):
         """A generator for iterating over the result cache.
 
-        Also populates the cache if there are more possible results to yield.
-        Raises StopIteration when there are no more results"""
+        Also populates the cache if there are more possible results to
+        yield. Raises StopIteration when there are no more results.
+        """
         if self._result_cache is None:
             self._result_cache = []
+
         pos = 0
         while True:
-            upper = len(self._result_cache)
-            while pos < upper:
+
+            # For all positions lower than the length of the current result
+            # cache, serve the docs straight from the cache w/o hitting the
+            # database.
+            # XXX it's VERY important to compute the len within the `while`
+            # condition because the result cache might expand mid-iteration
+            # (e.g. if we call len(qs) inside a loop that iterates over the
+            # queryset). Fortunately len(list) is O(1) in Python, so this
+            # doesn't cause performance issues.
+            while pos < len(self._result_cache):
                 yield self._result_cache[pos]
-                pos = pos + 1
+                pos += 1
+
+            # return if we already established there were no more
+            # docs in the db cursor.
             if not self._has_more:
-                raise StopIteration
+                return
+
+            # Otherwise, populate more of the cache and repeat.
             if len(self._result_cache) <= pos:
                 self._populate_cache()
 
@@ -87,14 +105,24 @@ class QuerySet(BaseQuerySet):
         """
         if self._result_cache is None:
             self._result_cache = []
-        if self._has_more:
-            try:
-                for i in xrange(ITER_CHUNK_SIZE):
-                    self._result_cache.append(self.next())
-            except StopIteration:
-                self._has_more = False
 
-    def count(self, with_limit_and_skip=True):
+        # Skip populating the cache if we already established there are no
+        # more docs to pull from the database.
+        if not self._has_more:
+            return
+
+        # Pull in ITER_CHUNK_SIZE docs from the database and store them in
+        # the result cache.
+        try:
+            for _ in six.moves.range(ITER_CHUNK_SIZE):
+                self._result_cache.append(six.next(self))
+        except StopIteration:
+            # Getting this exception means there are no more docs in the
+            # db cursor. Set _has_more to False so that we can use that
+            # information in other places.
+            self._has_more = False
+
+    def count(self, with_limit_and_skip=False):
         """Count the selected elements in the query.
 
         :param with_limit_and_skip (optional): take any :meth:`limit` or
@@ -110,13 +138,15 @@ class QuerySet(BaseQuerySet):
         return self._len
 
     def no_cache(self):
-        """Convert to a non_caching queryset
+        """Convert to a non-caching queryset
 
         .. versionadded:: 0.8.3 Convert to non caching queryset
         """
         if self._result_cache is not None:
-            raise OperationError("QuerySet already cached")
-        return self.clone_into(QuerySetNoCache(self._document, self._collection))
+            raise OperationError('QuerySet already cached')
+
+        return self._clone_into(QuerySetNoCache(self._document,
+                                                self._collection))
 
 
 class QuerySetNoCache(BaseQuerySet):
@@ -127,7 +157,7 @@ class QuerySetNoCache(BaseQuerySet):
 
         .. versionadded:: 0.8.3 Convert to caching queryset
         """
-        return self.clone_into(QuerySet(self._document, self._collection))
+        return self._clone_into(QuerySet(self._document, self._collection))
 
     def __repr__(self):
         """Provides the string representation of the QuerySet
@@ -138,13 +168,14 @@ class QuerySetNoCache(BaseQuerySet):
             return '.. queryset mid-iteration ..'
 
         data = []
-        for i in xrange(REPR_OUTPUT_SIZE + 1):
+        for _ in six.moves.range(REPR_OUTPUT_SIZE + 1):
             try:
-                data.append(self.next())
+                data.append(six.next(self))
             except StopIteration:
                 break
+
         if len(data) > REPR_OUTPUT_SIZE:
-            data[-1] = "...(remaining elements truncated)..."
+            data[-1] = '...(remaining elements truncated)...'
 
         self.rewind()
         return repr(data)

mongoengine/queryset/transform.py

@@ -1,44 +1,43 @@
 from collections import defaultdict
 
+from bson import ObjectId, SON
+from bson.dbref import DBRef
 import pymongo
-from bson import SON
+import six
+from six import iteritems
 
+from mongoengine.base import UPDATE_OPERATORS
 from mongoengine.common import _import_class
-from mongoengine.errors import InvalidQueryError, LookUpError
+from mongoengine.errors import InvalidQueryError
 
 __all__ = ('query', 'update')
 
-
 COMPARISON_OPERATORS = ('ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'mod',
-                        'all', 'size', 'exists', 'not')
-GEO_OPERATORS        = ('within_distance', 'within_spherical_distance',
-                        'within_box', 'within_polygon', 'near', 'near_sphere',
-                        'max_distance', 'geo_within', 'geo_within_box',
-                        'geo_within_polygon', 'geo_within_center',
-                        'geo_within_sphere', 'geo_intersects')
-STRING_OPERATORS     = ('contains', 'icontains', 'startswith',
-                        'istartswith', 'endswith', 'iendswith',
-                        'exact', 'iexact')
-CUSTOM_OPERATORS     = ('match',)
-MATCH_OPERATORS      = (COMPARISON_OPERATORS + GEO_OPERATORS +
-                        STRING_OPERATORS + CUSTOM_OPERATORS)
-
-UPDATE_OPERATORS     = ('set', 'unset', 'inc', 'dec', 'pop', 'push',
-                        'push_all', 'pull', 'pull_all', 'add_to_set',
-                        'set_on_insert')
+                        'all', 'size', 'exists', 'not', 'elemMatch', 'type')
+GEO_OPERATORS = ('within_distance', 'within_spherical_distance',
+                 'within_box', 'within_polygon', 'near', 'near_sphere',
+                 'max_distance', 'min_distance', 'geo_within', 'geo_within_box',
+                 'geo_within_polygon', 'geo_within_center',
+                 'geo_within_sphere', 'geo_intersects')
+STRING_OPERATORS = ('contains', 'icontains', 'startswith',
+                    'istartswith', 'endswith', 'iendswith',
+                    'exact', 'iexact')
+CUSTOM_OPERATORS = ('match',)
+MATCH_OPERATORS = (COMPARISON_OPERATORS + GEO_OPERATORS +
+                   STRING_OPERATORS + CUSTOM_OPERATORS)
 
 
-def query(_doc_cls=None, _field_operation=False, **query):
-    """Transform a query from Django-style format to Mongo format.
-    """
+# TODO make this less complex
+def query(_doc_cls=None, **kwargs):
+    """Transform a query from Django-style format to Mongo format."""
     mongo_query = {}
     merge_query = defaultdict(list)
-    for key, value in sorted(query.items()):
-        if key == "__raw__":
+    for key, value in sorted(kwargs.items()):
+        if key == '__raw__':
             mongo_query.update(value)
             continue
 
-        parts = key.split('__')
+        parts = key.rsplit('__')
         indices = [(i, p) for i, p in enumerate(parts) if p.isdigit()]
         parts = [part for part in parts if not part.isdigit()]
         # Check for an operator and transform to mongo-style if there is
@@ -46,6 +45,10 @@ def query(_doc_cls=None, _field_operation=False, **query):
         if len(parts) > 1 and parts[-1] in MATCH_OPERATORS:
             op = parts.pop()
 
+        # Allow to escape operator-like field name by __
+        if len(parts) > 1 and parts[-1] == '':
+            parts.pop()
+
         negate = False
         if len(parts) > 1 and parts[-1] == 'not':
             parts.pop()
@@ -55,18 +58,25 @@ def query(_doc_cls=None, _field_operation=False, **query):
             # Switch field names to proper names [set in Field(name='foo')]
             try:
                 fields = _doc_cls._lookup_field(parts)
-            except Exception, e:
+            except Exception as e:
                 raise InvalidQueryError(e)
             parts = []
 
+            CachedReferenceField = _import_class('CachedReferenceField')
+            GenericReferenceField = _import_class('GenericReferenceField')
+
             cleaned_fields = []
             for field in fields:
                 append_field = True
-                if isinstance(field, basestring):
+                if isinstance(field, six.string_types):
                     parts.append(field)
                     append_field = False
+                # is last and CachedReferenceField
+                elif isinstance(field, CachedReferenceField) and fields[-1] == field:
+                    parts.append('%s._id' % field.db_field)
                 else:
                     parts.append(field.db_field)
+
                 if append_field:
                     cleaned_fields.append(field)
 
@@ -76,30 +86,44 @@ def query(_doc_cls=None, _field_operation=False, **query):
             singular_ops = [None, 'ne', 'gt', 'gte', 'lt', 'lte', 'not']
             singular_ops += STRING_OPERATORS
             if op in singular_ops:
-                if isinstance(field, basestring):
-                    if (op in STRING_OPERATORS and
-                       isinstance(value, basestring)):
-                        StringField = _import_class('StringField')
-                        value = StringField.prepare_query_value(op, value)
-                    else:
-                        value = field
-                else:
-                    value = field.prepare_query_value(op, value)
+                value = field.prepare_query_value(op, value)
+
+                if isinstance(field, CachedReferenceField) and value:
+                    value = value['_id']
+
             elif op in ('in', 'nin', 'all', 'near') and not isinstance(value, dict):
-                # 'in', 'nin' and 'all' require a list of values
-                value = [field.prepare_query_value(op, v) for v in value]
+                # Raise an error if the in/nin/all/near param is not iterable.
+                value = _prepare_query_for_iterable(field, op, value)
+
+            # If we're querying a GenericReferenceField, we need to alter the
+            # key depending on the value:
+            # * If the value is a DBRef, the key should be "field_name._ref".
+            # * If the value is an ObjectId, the key should be "field_name._ref.$id".
+            if isinstance(field, GenericReferenceField):
+                if isinstance(value, DBRef):
+                    parts[-1] += '._ref'
+                elif isinstance(value, ObjectId):
+                    parts[-1] += '._ref.$id'
 
         # if op and op not in COMPARISON_OPERATORS:
         if op:
             if op in GEO_OPERATORS:
                 value = _geo_operator(field, op, value)
-            elif op in CUSTOM_OPERATORS:
-                if op == 'match':
-                    value = field.prepare_query_value(op, value)
-                    value = {"$elemMatch": value}
+            elif op in ('match', 'elemMatch'):
+                ListField = _import_class('ListField')
+                EmbeddedDocumentField = _import_class('EmbeddedDocumentField')
+                if (
+                    isinstance(value, dict) and
+                    isinstance(field, ListField) and
+                    isinstance(field.field, EmbeddedDocumentField)
+                ):
+                    value = query(field.field.document_type, **value)
                 else:
-                    NotImplementedError("Custom method '%s' has not "
-                                        "been implemented" % op)
+                    value = field.prepare_query_value(op, value)
+                value = {'$elemMatch': value}
+            elif op in CUSTOM_OPERATORS:
+                NotImplementedError('Custom method "%s" has not '
+                                    'been implemented' % op)
             elif op not in STRING_OPERATORS:
                 value = {'$' + op: value}
 
@@ -108,21 +132,40 @@ def query(_doc_cls=None, _field_operation=False, **query):
 
         for i, part in indices:
             parts.insert(i, part)
+
         key = '.'.join(parts)
+
         if op is None or key not in mongo_query:
             mongo_query[key] = value
         elif key in mongo_query:
-            if key in mongo_query and isinstance(mongo_query[key], dict):
+            if isinstance(mongo_query[key], dict) and isinstance(value, dict):
                 mongo_query[key].update(value)
-                # $maxDistance needs to come last - convert to SON
-                if '$maxDistance' in mongo_query[key]:
-                    value_dict = mongo_query[key]
+                # $max/minDistance needs to come last - convert to SON
+                value_dict = mongo_query[key]
+                if ('$maxDistance' in value_dict or '$minDistance' in value_dict) and \
+                        ('$near' in value_dict or '$nearSphere' in value_dict):
                     value_son = SON()
-                    for k, v in value_dict.iteritems():
-                        if k == '$maxDistance':
+                    for k, v in iteritems(value_dict):
+                        if k == '$maxDistance' or k == '$minDistance':
                             continue
                         value_son[k] = v
-                    value_son['$maxDistance'] = value_dict['$maxDistance']
+                    # Required for MongoDB >= 2.6, may fail when combining
+                    # PyMongo 3+ and MongoDB < 2.6
+                    near_embedded = False
+                    for near_op in ('$near', '$nearSphere'):
+                        if isinstance(value_dict.get(near_op), dict):
+                            value_son[near_op] = SON(value_son[near_op])
+                            if '$maxDistance' in value_dict:
+                                value_son[near_op]['$maxDistance'] = value_dict['$maxDistance']
+                            if '$minDistance' in value_dict:
+                                value_son[near_op]['$minDistance'] = value_dict['$minDistance']
+                            near_embedded = True
+
+                    if not near_embedded:
+                        if '$maxDistance' in value_dict:
+                            value_son['$maxDistance'] = value_dict['$maxDistance']
+                        if '$minDistance' in value_dict:
+                            value_son['$minDistance'] = value_dict['$minDistance']
                     mongo_query[key] = value_son
             else:
                 # Store for manually merging later
@@ -135,7 +178,7 @@ def query(_doc_cls=None, _field_operation=False, **query):
         if isinstance(v, list):
             value = [{k: val} for val in v]
             if '$and' in mongo_query.keys():
-                mongo_query['$and'].append(value)
+                mongo_query['$and'].extend(value)
             else:
                 mongo_query['$and'] = value
 
@@ -143,41 +186,55 @@ def query(_doc_cls=None, _field_operation=False, **query):
 
 
 def update(_doc_cls=None, **update):
-    """Transform an update spec from Django-style format to Mongo format.
+    """Transform an update spec from Django-style format to Mongo
+    format.
     """
     mongo_update = {}
+
     for key, value in update.items():
-        if key == "__raw__":
+        if key == '__raw__':
             mongo_update.update(value)
             continue
+
         parts = key.split('__')
+
+        # if there is no operator, default to 'set'
+        if len(parts) < 3 and parts[0] not in UPDATE_OPERATORS:
+            parts.insert(0, 'set')
+
         # Check for an operator and transform to mongo-style if there is
         op = None
         if parts[0] in UPDATE_OPERATORS:
             op = parts.pop(0)
             # Convert Pythonic names to Mongo equivalents
-            if op in ('push_all', 'pull_all'):
-                op = op.replace('_all', 'All')
-            elif op == 'dec':
+            operator_map = {
+                'push_all': 'pushAll',
+                'pull_all': 'pullAll',
+                'dec': 'inc',
+                'add_to_set': 'addToSet',
+                'set_on_insert': 'setOnInsert'
+            }
+            if op == 'dec':
                 # Support decrement by flipping a positive value's sign
                 # and using 'inc'
-                op = 'inc'
-                if value > 0:
-                    value = -value
-            elif op == 'add_to_set':
-                op = 'addToSet'
-            elif op == 'set_on_insert':
-                op = "setOnInsert"
+                value = -value
+            # If the operator doesn't found from operator map, the op value
+            # will stay unchanged
+            op = operator_map.get(op, op)
 
         match = None
         if parts[-1] in COMPARISON_OPERATORS:
             match = parts.pop()
 
+        # Allow to escape operator-like field name by __
+        if len(parts) > 1 and parts[-1] == '':
+            parts.pop()
+
         if _doc_cls:
             # Switch field names to proper names [set in Field(name='foo')]
             try:
                 fields = _doc_cls._lookup_field(parts)
-            except Exception, e:
+            except Exception as e:
                 raise InvalidQueryError(e)
             parts = []
 
@@ -185,7 +242,7 @@ def update(_doc_cls=None, **update):
             appended_sub_field = False
             for field in fields:
                 append_field = True
-                if isinstance(field, basestring):
+                if isinstance(field, six.string_types):
                     # Convert the S operator to $
                     if field == 'S':
                         field = '$'
@@ -206,11 +263,19 @@ def update(_doc_cls=None, **update):
             else:
                 field = cleaned_fields[-1]
 
-            GeoJsonBaseField = _import_class("GeoJsonBaseField")
+            GeoJsonBaseField = _import_class('GeoJsonBaseField')
             if isinstance(field, GeoJsonBaseField):
                 value = field.to_mongo(value)
 
-            if op in (None, 'set', 'push', 'pull'):
+            if op == 'pull':
+                if field.required or value is not None:
+                    if match in ('in', 'nin') and not isinstance(value, dict):
+                        value = _prepare_query_for_iterable(field, op, value)
+                    else:
+                        value = field.prepare_query_value(op, value)
+            elif op == 'push' and isinstance(value, (list, tuple, set)):
+                value = [field.prepare_query_value(op, v) for v in value]
+            elif op in (None, 'set', 'push'):
                 if field.required or value is not None:
                     value = field.prepare_query_value(op, value)
             elif op in ('pushAll', 'pullAll'):
@@ -220,8 +285,10 @@ def update(_doc_cls=None, **update):
                     value = [field.prepare_query_value(op, v) for v in value]
                 elif field.required or value is not None:
                     value = field.prepare_query_value(op, value)
-            elif op == "unset":
+            elif op == 'unset':
                 value = 1
+            elif op == 'inc':
+                value = field.prepare_query_value(op, value)
 
         if match:
             match = '$' + match
@@ -229,27 +296,30 @@ def update(_doc_cls=None, **update):
 
         key = '.'.join(parts)
 
-        if not op:
-            raise InvalidQueryError("Updates must supply an operation "
-                                    "eg: set__FIELD=value")
-
         if 'pull' in op and '.' in key:
             # Dot operators don't work on pull operations
             # unless they point to a list field
             # Otherwise it uses nested dict syntax
             if op == 'pullAll':
-                raise InvalidQueryError("pullAll operations only support "
-                                        "a single field depth")
+                raise InvalidQueryError('pullAll operations only support '
+                                        'a single field depth')
 
             # Look for the last list field and use dot notation until there
             field_classes = [c.__class__ for c in cleaned_fields]
             field_classes.reverse()
             ListField = _import_class('ListField')
-            if ListField in field_classes:
-                # Join all fields via dot notation to the last ListField
+            EmbeddedDocumentListField = _import_class('EmbeddedDocumentListField')
+            if ListField in field_classes or EmbeddedDocumentListField in field_classes:
+                # Join all fields via dot notation to the last ListField or EmbeddedDocumentListField
                 # Then process as normal
-                last_listField = len(cleaned_fields) - field_classes.index(ListField)
-                key = ".".join(parts[:last_listField])
+                if ListField in field_classes:
+                    _check_field = ListField
+                else:
+                    _check_field = EmbeddedDocumentListField
+
+                last_listField = len(
+                    cleaned_fields) - field_classes.index(_check_field)
+                key = '.'.join(parts[:last_listField])
                 parts = parts[last_listField:]
                 parts.insert(0, key)
 
@@ -257,11 +327,27 @@ def update(_doc_cls=None, **update):
             for key in parts:
                 value = {key: value}
         elif op == 'addToSet' and isinstance(value, list):
-            value = {key: {"$each": value}}
+            value = {key: {'$each': value}}
+        elif op in ('push', 'pushAll'):
+            if parts[-1].isdigit():
+                key = '.'.join(parts[0:-1])
+                position = int(parts[-1])
+                # $position expects an iterable. If pushing a single value,
+                # wrap it in a list.
+                if not isinstance(value, (set, tuple, list)):
+                    value = [value]
+                value = {key: {'$each': value, '$position': position}}
+            else:
+                if op == 'pushAll':
+                    op = 'push'  # convert to non-deprecated keyword
+                    if not isinstance(value, (set, tuple, list)):
+                        value = [value]
+                    value = {key: {'$each': value}}
+                else:
+                    value = {key: value}
         else:
             value = {key: value}
         key = '$' + op
-
         if key not in mongo_update:
             mongo_update[key] = value
         elif key in mongo_update and isinstance(mongo_update[key], dict):
@@ -271,73 +357,100 @@ def update(_doc_cls=None, **update):
 
 
 def _geo_operator(field, op, value):
-    """Helper to return the query for a given geo query"""
-    if field._geo_index == pymongo.GEO2D:
-        if op == "within_distance":
+    """Helper to return the query for a given geo query."""
+    if op == 'max_distance':
+        value = {'$maxDistance': value}
+    elif op == 'min_distance':
+        value = {'$minDistance': value}
+    elif field._geo_index == pymongo.GEO2D:
+        if op == 'within_distance':
             value = {'$within': {'$center': value}}
-        elif op == "within_spherical_distance":
+        elif op == 'within_spherical_distance':
             value = {'$within': {'$centerSphere': value}}
-        elif op == "within_polygon":
+        elif op == 'within_polygon':
             value = {'$within': {'$polygon': value}}
-        elif op == "near":
+        elif op == 'near':
             value = {'$near': value}
-        elif op == "near_sphere":
+        elif op == 'near_sphere':
             value = {'$nearSphere': value}
         elif op == 'within_box':
             value = {'$within': {'$box': value}}
-        elif op == "max_distance":
-            value = {'$maxDistance': value}
         else:
-            raise NotImplementedError("Geo method '%s' has not "
-                                      "been implemented for a GeoPointField" % op)
+            raise NotImplementedError('Geo method "%s" has not been '
+                                      'implemented for a GeoPointField' % op)
     else:
-        if op == "geo_within":
-            value = {"$geoWithin": _infer_geometry(value)}
-        elif op == "geo_within_box":
-            value = {"$geoWithin": {"$box": value}}
-        elif op == "geo_within_polygon":
-            value = {"$geoWithin": {"$polygon": value}}
-        elif op == "geo_within_center":
-            value = {"$geoWithin": {"$center": value}}
-        elif op == "geo_within_sphere":
-            value = {"$geoWithin": {"$centerSphere": value}}
-        elif op == "geo_intersects":
-            value = {"$geoIntersects": _infer_geometry(value)}
-        elif op == "near":
+        if op == 'geo_within':
+            value = {'$geoWithin': _infer_geometry(value)}
+        elif op == 'geo_within_box':
+            value = {'$geoWithin': {'$box': value}}
+        elif op == 'geo_within_polygon':
+            value = {'$geoWithin': {'$polygon': value}}
+        elif op == 'geo_within_center':
+            value = {'$geoWithin': {'$center': value}}
+        elif op == 'geo_within_sphere':
+            value = {'$geoWithin': {'$centerSphere': value}}
+        elif op == 'geo_intersects':
+            value = {'$geoIntersects': _infer_geometry(value)}
+        elif op == 'near':
             value = {'$near': _infer_geometry(value)}
-        elif op == "max_distance":
-            value = {'$maxDistance': value}
         else:
-            raise NotImplementedError("Geo method '%s' has not "
-                                      "been implemented for a %s " % (op, field._name))
+            raise NotImplementedError(
+                'Geo method "%s" has not been implemented for a %s '
+                % (op, field._name)
+            )
     return value
 
 
 def _infer_geometry(value):
-    """Helper method that tries to infer the $geometry shape for a given value"""
+    """Helper method that tries to infer the $geometry shape for a
+    given value.
+    """
     if isinstance(value, dict):
-        if "$geometry" in value:
+        if '$geometry' in value:
             return value
         elif 'coordinates' in value and 'type' in value:
-            return {"$geometry": value}
-        raise InvalidQueryError("Invalid $geometry dictionary should have "
-                                "type and coordinates keys")
+            return {'$geometry': value}
+        raise InvalidQueryError('Invalid $geometry dictionary should have '
+                                'type and coordinates keys')
     elif isinstance(value, (list, set)):
+        # TODO: shouldn't we test value[0][0][0][0] to see if it is MultiPolygon?
+
         try:
             value[0][0][0]
-            return {"$geometry": {"type": "Polygon", "coordinates": value}}
-        except:
-            pass
-        try:
-            value[0][0]
-            return {"$geometry": {"type": "LineString", "coordinates": value}}
-        except:
-            pass
-        try:
-            value[0]
-            return {"$geometry": {"type": "Point", "coordinates": value}}
-        except:
+            return {'$geometry': {'type': 'Polygon', 'coordinates': value}}
+        except (TypeError, IndexError):
             pass
 
-    raise InvalidQueryError("Invalid $geometry data. Can be either a dictionary "
-                            "or (nested) lists of coordinate(s)")
+        try:
+            value[0][0]
+            return {'$geometry': {'type': 'LineString', 'coordinates': value}}
+        except (TypeError, IndexError):
+            pass
+
+        try:
+            value[0]
+            return {'$geometry': {'type': 'Point', 'coordinates': value}}
+        except (TypeError, IndexError):
+            pass
+
+    raise InvalidQueryError('Invalid $geometry data. Can be either a '
+                            'dictionary or (nested) lists of coordinate(s)')
+
+
+def _prepare_query_for_iterable(field, op, value):
+    # We need a special check for BaseDocument, because - although it's iterable - using
+    # it as such in the context of this method is most definitely a mistake.
+    BaseDocument = _import_class('BaseDocument')
+
+    if isinstance(value, BaseDocument):
+        raise TypeError("When using the `in`, `nin`, `all`, or "
+                        "`near`-operators you can\'t use a "
+                        "`Document`, you must wrap your object "
+                        "in a list (object -> [object]).")
+
+    if not hasattr(value, '__iter__'):
+        raise TypeError("The `in`, `nin`, `all`, or "
+                        "`near`-operators must be applied to an "
+                        "iterable (e.g. a list).")
+
+    return [field.prepare_query_value(op, v) for v in value]

mongoengine/queryset/visitor.py

@@ -1,11 +1,9 @@
 import copy
 
 from mongoengine.errors import InvalidQueryError
-from mongoengine.python_support import product, reduce
-
 from mongoengine.queryset import transform
 
-__all__ = ('Q',)
+__all__ = ('Q', 'QNode')
 
 
 class QNodeVisitor(object):
@@ -28,7 +26,7 @@ class DuplicateQueryConditionsError(InvalidQueryError):
 
 
 class SimplificationVisitor(QNodeVisitor):
-    """Simplifies query trees by combinging unnecessary 'and' connection nodes
+    """Simplifies query trees by combining unnecessary 'and' connection nodes
     into a single Q-object.
     """
 
@@ -71,9 +69,9 @@ class QueryCompilerVisitor(QNodeVisitor):
         self.document = document
 
     def visit_combination(self, combination):
-        operator = "$and"
+        operator = '$and'
         if combination.operation == combination.OR:
-            operator = "$or"
+            operator = '$or'
         return {operator: combination.children}
 
     def visit_query(self, query):
@@ -81,8 +79,7 @@ class QueryCompilerVisitor(QNodeVisitor):
 
 
 class QNode(object):
-    """Base class for nodes in query trees.
-    """
+    """Base class for nodes in query trees."""
 
     AND = 0
     OR = 1
@@ -96,7 +93,8 @@ class QNode(object):
         raise NotImplementedError
 
     def _combine(self, other, operation):
-        """Combine this node with another node into a QCombination object.
+        """Combine this node with another node into a QCombination
+        object.
         """
         if getattr(other, 'empty', True):
             return self
@@ -118,8 +116,8 @@ class QNode(object):
 
 
 class QCombination(QNode):
-    """Represents the combination of several conditions by a given logical
-    operator.
+    """Represents the combination of several conditions by a given
+    logical operator.
     """
 
     def __init__(self, operation, children):
@@ -133,6 +131,10 @@ class QCombination(QNode):
             else:
                 self.children.append(node)
 
+    def __repr__(self):
+        op = ' & ' if self.operation is self.AND else ' | '
+        return '(%s)' % op.join([repr(node) for node in self.children])
+
     def accept(self, visitor):
         for i in range(len(self.children)):
             if isinstance(self.children[i], QNode):
@@ -153,6 +155,9 @@ class Q(QNode):
     def __init__(self, **query):
         self.query = query
 
+    def __repr__(self):
+        return 'Q(**%s)' % repr(self.query)
+
     def accept(self, visitor):
         return visitor.visit_query(self)
 

mongoengine/signals.py

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
-
-__all__ = ['pre_init', 'post_init', 'pre_save', 'pre_save_post_validation',
-           'post_save', 'pre_delete', 'post_delete']
+__all__ = ('pre_init', 'post_init', 'pre_save', 'pre_save_post_validation',
+           'post_save', 'pre_delete', 'post_delete')
 
 signals_available = False
 try:
     from blinker import Namespace
+
     signals_available = True
 except ImportError:
     class Namespace(object):
@@ -27,11 +26,13 @@ except ImportError:
             raise RuntimeError('signalling support is unavailable '
                                'because the blinker library is '
                                'not installed.')
-        send = lambda *a, **kw: None
+
+        send = lambda *a, **kw: None  # noqa
         connect = disconnect = has_receivers_for = receivers_for = \
             temporarily_connected_to = _fail
         del _fail
 
+
 # the namespace for code signals.  If you are not mongoengine code, do
 # not put signals in here.  Create your own namespace instead.
 _signals = Namespace()

python-mongoengine.spec

@@ -5,7 +5,7 @@
 %define srcname mongoengine
 
 Name:           python-%{srcname}
-Version:        0.8.6
+Version:        0.8.7
 Release:        1%{?dist}
 Summary:        A Python Document-Object Mapper for working with MongoDB
 

requirements.txt

@@ -1 +1,7 @@
-pymongo
+nose
+pymongo>=3.4
+six==1.10.0
+flake8
+flake8-import-order
+Sphinx==1.5.5
+sphinx-rtd-theme==0.2.4

setup.cfg

@@ -1,11 +1,11 @@
 [nosetests]
-verbosity = 3
-detailed-errors = 1
-#with-coverage = 1
-#cover-erase = 1
-#cover-html = 1
-#cover-html-dir = ../htmlcov
-#cover-package = mongoengine
-py3where = build
-where = tests
-#tests =  document/__init__.py
+verbosity=2
+detailed-errors=1
+#tests=tests
+cover-package=mongoengine
+
+[flake8]
+ignore=E501,F401,F403,F405,I201,I202,W504, W605
+exclude=build,dist,docs,venv,venv3,.tox,.eggs,tests
+max-complexity=47
+application-import-names=mongoengine,tests

setup.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from setuptools import setup, find_packages
+from setuptools import find_packages, setup
 
 # Hack to silence atexit traceback in newer python versions
 try:
@@ -8,20 +8,25 @@ try:
 except ImportError:
     pass
 
-DESCRIPTION = 'MongoEngine is a Python Object-Document ' + \
-'Mapper for working with MongoDB.'
-LONG_DESCRIPTION = None
+DESCRIPTION = (
+    'MongoEngine is a Python Object-Document '
+    'Mapper for working with MongoDB.'
+)
+
 try:
-    LONG_DESCRIPTION = open('README.rst').read()
-except:
-    pass
+    with open('README.rst') as fin:
+        LONG_DESCRIPTION = fin.read()
+except Exception:
+    LONG_DESCRIPTION = None
 
 
 def get_version(version_tuple):
-    if not isinstance(version_tuple[-1], int):
-        return '.'.join(map(str, version_tuple[:-1])) + version_tuple[-1]
+    """Return the version tuple as a string, e.g. for (0, 10, 7),
+    return '0.10.7'.
+    """
     return '.'.join(map(str, version_tuple))
 
+
 # Dirty hack to get version number from monogengine/__init__.py - we can't
 # import it as it depends on PyMongo and PyMongo isn't installed until this
 # file is read
@@ -29,7 +34,6 @@ init = os.path.join(os.path.dirname(__file__), 'mongoengine', '__init__.py')
 version_line = list(filter(lambda l: l.startswith('VERSION'), open(init)))[0]
 
 VERSION = get_version(eval(version_line.split('=')[-1]))
-print(VERSION)
 
 CLASSIFIERS = [
     'Development Status :: 4 - Beta',
@@ -38,41 +42,45 @@ CLASSIFIERS = [
     'Operating System :: OS Independent',
     'Programming Language :: Python',
     "Programming Language :: Python :: 2",
-    "Programming Language :: Python :: 2.6",
     "Programming Language :: Python :: 2.7",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.1",
-    "Programming Language :: Python :: 3.2",
+    "Programming Language :: Python :: 3.5",
+    "Programming Language :: Python :: 3.6",
     "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
     'Topic :: Database',
     'Topic :: Software Development :: Libraries :: Python Modules',
 ]
 
-extra_opts = {"packages": find_packages(exclude=["tests", "tests.*"])}
+extra_opts = {
+    'packages': find_packages(exclude=['tests', 'tests.*']),
+    'tests_require': ['nose', 'coverage==4.2', 'blinker', 'Pillow>=2.0.0']
+}
 if sys.version_info[0] == 3:
     extra_opts['use_2to3'] = True
-    extra_opts['tests_require'] = ['nose', 'coverage', 'blinker', 'jinja2==2.6', 'django>=1.5.1']
-    if "test" in sys.argv or "nosetests" in sys.argv:
+    if 'test' in sys.argv or 'nosetests' in sys.argv:
         extra_opts['packages'] = find_packages()
-        extra_opts['package_data'] = {"tests": ["fields/mongoengine.png", "fields/mongodb_leaf.png"]}
+        extra_opts['package_data'] = {
+            'tests': ['fields/mongoengine.png', 'fields/mongodb_leaf.png']}
 else:
-    extra_opts['tests_require'] = ['nose', 'coverage', 'blinker', 'django>=1.4.2', 'PIL', 'jinja2>=2.6', 'python-dateutil']
+    extra_opts['tests_require'] += ['python-dateutil']
 
-setup(name='mongoengine',
-      version=VERSION,
-      author='Harry Marr',
-      author_email='harry.marr@{nospam}gmail.com',
-      maintainer="Ross Lawley",
-      maintainer_email="ross.lawley@{nospam}gmail.com",
-      url='http://mongoengine.org/',
-      download_url='https://github.com/MongoEngine/mongoengine/tarball/master',
-      license='MIT',
-      include_package_data=True,
-      description=DESCRIPTION,
-      long_description=LONG_DESCRIPTION,
-      platforms=['any'],
-      classifiers=CLASSIFIERS,
-      install_requires=['pymongo>=2.5'],
-      test_suite='nose.collector',
-      **extra_opts
+setup(
+    name='mongoengine',
+    version=VERSION,
+    author='Harry Marr',
+    author_email='harry.marr@gmail.com',
+    maintainer="Stefan Wojcik",
+    maintainer_email="wojcikstefan@gmail.com",
+    url='http://mongoengine.org/',
+    download_url='https://github.com/MongoEngine/mongoengine/tarball/master',
+    license='MIT',
+    include_package_data=True,
+    description=DESCRIPTION,
+    long_description=LONG_DESCRIPTION,
+    platforms=['any'],
+    classifiers=CLASSIFIERS,
+    install_requires=['pymongo>=3.4', 'six'],
+    test_suite='nose.collector',
+    **extra_opts
 )

tests/__init__.py

@@ -1,5 +1,4 @@
-from all_warnings import AllWarnings
-from document import *
-from queryset import *
-from fields import *
-from migration import *
+from .all_warnings import AllWarnings
+from .document import *
+from .queryset import *
+from .fields import *

tests/all_warnings/__init__.py

@@ -3,8 +3,6 @@ This test has been put into a module.  This is because it tests warnings that
 only get triggered on first hit.  This way we can ensure its imported into the
 top level and called first by the test suite.
 """
-import sys
-sys.path[0:0] = [""]
 import unittest
 import warnings
 

tests/document/__init__.py

@@ -1,15 +1,13 @@
-import sys
-sys.path[0:0] = [""]
 import unittest
 
-from class_methods import *
-from delta import *
-from dynamic import *
-from indexes import *
-from inheritance import *
-from instance import *
-from json_serialisation import *
-from validation import *
+from .class_methods import *
+from .delta import *
+from .dynamic import *
+from .indexes import *
+from .inheritance import *
+from .instance import *
+from .json_serialisation import *
+from .validation import *
 
 if __name__ == '__main__':
     unittest.main()

tests/document/class_methods.py

@@ -1,9 +1,8 @@
 # -*- coding: utf-8 -*-
-import sys
-sys.path[0:0] = [""]
 import unittest
 
 from mongoengine import *
+from mongoengine.pymongo_support import list_collection_names
 
 from mongoengine.queryset import NULLIFY, PULL
 from mongoengine.connection import get_db
@@ -28,17 +27,15 @@ class ClassMethodsTest(unittest.TestCase):
         self.Person = Person
 
     def tearDown(self):
-        for collection in self.db.collection_names():
-            if 'system.' in collection:
-                continue
+        for collection in list_collection_names(self.db):
             self.db.drop_collection(collection)
 
     def test_definition(self):
         """Ensure that document may be defined using fields.
         """
-        self.assertEqual(['age', 'id', 'name'],
+        self.assertEqual(['_cls', 'age', 'id', 'name'],
                          sorted(self.Person._fields.keys()))
-        self.assertEqual(["IntField", "ObjectIdField", "StringField"],
+        self.assertEqual(["IntField", "ObjectIdField", "StringField", "StringField"],
                         sorted([x.__class__.__name__ for x in
                                 self.Person._fields.values()]))
 
@@ -67,10 +64,10 @@ class ClassMethodsTest(unittest.TestCase):
         """
         collection_name = 'person'
         self.Person(name='Test').save()
-        self.assertTrue(collection_name in self.db.collection_names())
+        self.assertIn(collection_name, list_collection_names(self.db))
 
         self.Person.drop_collection()
-        self.assertFalse(collection_name in self.db.collection_names())
+        self.assertNotIn(collection_name, list_collection_names(self.db))
 
     def test_register_delete_rule(self):
         """Ensure that register delete rule adds a delete rule to the document
@@ -103,16 +100,16 @@ class ClassMethodsTest(unittest.TestCase):
         BlogPost.drop_collection()
 
         BlogPost.ensure_indexes()
-        self.assertEqual(BlogPost.compare_indexes(), { 'missing': [], 'extra': [] })
+        self.assertEqual(BlogPost.compare_indexes(), {'missing': [], 'extra': []})
 
         BlogPost.ensure_index(['author', 'description'])
-        self.assertEqual(BlogPost.compare_indexes(), { 'missing': [], 'extra': [[('author', 1), ('description', 1)]] })
+        self.assertEqual(BlogPost.compare_indexes(), {'missing': [], 'extra': [[('author', 1), ('description', 1)]]})
 
         BlogPost._get_collection().drop_index('author_1_description_1')
-        self.assertEqual(BlogPost.compare_indexes(), { 'missing': [], 'extra': [] })
+        self.assertEqual(BlogPost.compare_indexes(), {'missing': [], 'extra': []})
 
         BlogPost._get_collection().drop_index('author_1_title_1')
-        self.assertEqual(BlogPost.compare_indexes(), { 'missing': [[('author', 1), ('title', 1)]], 'extra': [] })
+        self.assertEqual(BlogPost.compare_indexes(), {'missing': [[('author', 1), ('title', 1)]], 'extra': []})
 
     def test_compare_indexes_inheritance(self):
         """ Ensure that the indexes are properly created and that
@@ -141,16 +138,16 @@ class ClassMethodsTest(unittest.TestCase):
 
         BlogPost.ensure_indexes()
         BlogPostWithTags.ensure_indexes()
-        self.assertEqual(BlogPost.compare_indexes(), { 'missing': [], 'extra': [] })
+        self.assertEqual(BlogPost.compare_indexes(), {'missing': [], 'extra': []})
 
         BlogPostWithTags.ensure_index(['author', 'tag_list'])
-        self.assertEqual(BlogPost.compare_indexes(), { 'missing': [], 'extra': [[('_cls', 1), ('author', 1), ('tag_list', 1)]] })
+        self.assertEqual(BlogPost.compare_indexes(), {'missing': [], 'extra': [[('_cls', 1), ('author', 1), ('tag_list', 1)]]})
 
         BlogPostWithTags._get_collection().drop_index('_cls_1_author_1_tag_list_1')
-        self.assertEqual(BlogPost.compare_indexes(), { 'missing': [], 'extra': [] })
+        self.assertEqual(BlogPost.compare_indexes(), {'missing': [], 'extra': []})
 
         BlogPostWithTags._get_collection().drop_index('_cls_1_author_1_tags_1')
-        self.assertEqual(BlogPost.compare_indexes(), { 'missing': [[('_cls', 1), ('author', 1), ('tags', 1)]], 'extra': [] })
+        self.assertEqual(BlogPost.compare_indexes(), {'missing': [[('_cls', 1), ('author', 1), ('tags', 1)]], 'extra': []})
 
     def test_compare_indexes_multiple_subclasses(self):
         """ Ensure that compare_indexes behaves correctly if called from a
@@ -185,9 +182,28 @@ class ClassMethodsTest(unittest.TestCase):
         BlogPostWithTags.ensure_indexes()
         BlogPostWithCustomField.ensure_indexes()
 
-        self.assertEqual(BlogPost.compare_indexes(), { 'missing': [], 'extra': [] })
-        self.assertEqual(BlogPostWithTags.compare_indexes(), { 'missing': [], 'extra': [] })
-        self.assertEqual(BlogPostWithCustomField.compare_indexes(), { 'missing': [], 'extra': [] })
+        self.assertEqual(BlogPost.compare_indexes(), {'missing': [], 'extra': []})
+        self.assertEqual(BlogPostWithTags.compare_indexes(), {'missing': [], 'extra': []})
+        self.assertEqual(BlogPostWithCustomField.compare_indexes(), {'missing': [], 'extra': []})
+
+    def test_compare_indexes_for_text_indexes(self):
+        """ Ensure that compare_indexes behaves correctly for text indexes """
+
+        class Doc(Document):
+            a = StringField()
+            b = StringField()
+            meta = {'indexes': [
+                {'fields': ['$a', "$b"],
+                 'default_language': 'english',
+                 'weights': {'a': 10, 'b': 2}
+                }
+            ]}
+
+        Doc.drop_collection()
+        Doc.ensure_indexes()
+        actual = Doc.compare_indexes()
+        expected = {'missing': [], 'extra': []}
+        self.assertEqual(actual, expected)
 
     def test_list_indexes_inheritance(self):
         """ ensure that all of the indexes are listed regardless of the super-
@@ -321,7 +337,7 @@ class ClassMethodsTest(unittest.TestCase):
             meta = {'collection': collection_name}
 
         Person(name="Test User").save()
-        self.assertTrue(collection_name in self.db.collection_names())
+        self.assertIn(collection_name, list_collection_names(self.db))
 
         user_obj = self.db[collection_name].find_one()
         self.assertEqual(user_obj['name'], "Test User")
@@ -330,7 +346,7 @@ class ClassMethodsTest(unittest.TestCase):
         self.assertEqual(user_obj.name, "Test User")
 
         Person.drop_collection()
-        self.assertFalse(collection_name in self.db.collection_names())
+        self.assertNotIn(collection_name, list_collection_names(self.db))
 
     def test_collection_name_and_primary(self):
         """Ensure that a collection with a specified name may be used.

tests/document/delta.py

@@ -1,20 +1,16 @@
 # -*- coding: utf-8 -*-
-import sys
-sys.path[0:0] = [""]
 import unittest
 
 from bson import SON
 from mongoengine import *
-from mongoengine.connection import get_db
-
-__all__ = ("DeltaTest",)
+from mongoengine.pymongo_support import list_collection_names
+from tests.utils import MongoDBTestCase
 
 
-class DeltaTest(unittest.TestCase):
+class DeltaTest(MongoDBTestCase):
 
     def setUp(self):
-        connect(db='mongoenginetest')
-        self.db = get_db()
+        super(DeltaTest, self).setUp()
 
         class Person(Document):
             name = StringField()
@@ -27,9 +23,7 @@ class DeltaTest(unittest.TestCase):
         self.Person = Person
 
     def tearDown(self):
-        for collection in self.db.collection_names():
-            if 'system.' in collection:
-                continue
+        for collection in list_collection_names(self.db):
             self.db.drop_collection(collection)
 
     def test_delta(self):
@@ -93,6 +87,7 @@ class DeltaTest(unittest.TestCase):
     def delta_recursive(self, DocClass, EmbeddedClass):
 
         class Embedded(EmbeddedClass):
+            id = StringField()
             string_field = StringField()
             int_field = IntField()
             dict_field = DictField()
@@ -114,6 +109,7 @@ class DeltaTest(unittest.TestCase):
         self.assertEqual(doc._delta(), ({}, {}))
 
         embedded_1 = Embedded()
+        embedded_1.id = "010101"
         embedded_1.string_field = 'hello'
         embedded_1.int_field = 1
         embedded_1.dict_field = {'hello': 'world'}
@@ -123,6 +119,7 @@ class DeltaTest(unittest.TestCase):
         self.assertEqual(doc._get_changed_fields(), ['embedded_field'])
 
         embedded_delta = {
+            'id': "010101",
             'string_field': 'hello',
             'int_field': 1,
             'dict_field': {'hello': 'world'},
@@ -207,22 +204,21 @@ class DeltaTest(unittest.TestCase):
         doc.embedded_field.list_field[2].string_field = 'hello world'
         doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2]
         self.assertEqual(doc._get_changed_fields(),
-                         ['embedded_field.list_field'])
-        self.assertEqual(doc.embedded_field._delta(), ({
-            'list_field': ['1', 2, {
-            '_cls': 'Embedded',
-            'string_field': 'hello world',
-            'int_field': 1,
-            'list_field': ['1', 2, {'hello': 'world'}],
-            'dict_field': {'hello': 'world'}}]}, {}))
-        self.assertEqual(doc._delta(), ({
-            'embedded_field.list_field': ['1', 2, {
+                         ['embedded_field.list_field.2'])
+        self.assertEqual(doc.embedded_field._delta(), ({'list_field.2': {
                 '_cls': 'Embedded',
                 'string_field': 'hello world',
                 'int_field': 1,
                 'list_field': ['1', 2, {'hello': 'world'}],
                 'dict_field': {'hello': 'world'}}
-            ]}, {}))
+            }, {}))
+        self.assertEqual(doc._delta(), ({'embedded_field.list_field.2': {
+                '_cls': 'Embedded',
+                'string_field': 'hello world',
+                'int_field': 1,
+                'list_field': ['1', 2, {'hello': 'world'}],
+                'dict_field': {'hello': 'world'}}
+            }, {}))
         doc.save()
         doc = doc.reload(10)
         self.assertEqual(doc.embedded_field.list_field[2].string_field,
@@ -251,13 +247,13 @@ class DeltaTest(unittest.TestCase):
         self.assertEqual(doc.embedded_field.list_field[2].list_field,
                          [1, 2, {'hello': 'world'}])
 
-        del(doc.embedded_field.list_field[2].list_field[2]['hello'])
+        del doc.embedded_field.list_field[2].list_field[2]['hello']
         self.assertEqual(doc._delta(),
-                         ({'embedded_field.list_field.2.list_field': [1, 2, {}]}, {}))
+                         ({}, {'embedded_field.list_field.2.list_field.2.hello': 1}))
         doc.save()
         doc = doc.reload(10)
 
-        del(doc.embedded_field.list_field[2].list_field)
+        del doc.embedded_field.list_field[2].list_field
         self.assertEqual(doc._delta(),
                          ({}, {'embedded_field.list_field.2.list_field': 1}))
 
@@ -548,22 +544,21 @@ class DeltaTest(unittest.TestCase):
         doc.embedded_field.list_field[2].string_field = 'hello world'
         doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2]
         self.assertEqual(doc._get_changed_fields(),
-            ['db_embedded_field.db_list_field'])
-        self.assertEqual(doc.embedded_field._delta(), ({
-            'db_list_field': ['1', 2, {
+            ['db_embedded_field.db_list_field.2'])
+        self.assertEqual(doc.embedded_field._delta(), ({'db_list_field.2': {
             '_cls': 'Embedded',
             'db_string_field': 'hello world',
             'db_int_field': 1,
             'db_list_field': ['1', 2, {'hello': 'world'}],
-            'db_dict_field': {'hello': 'world'}}]}, {}))
+            'db_dict_field': {'hello': 'world'}}}, {}))
         self.assertEqual(doc._delta(), ({
-            'db_embedded_field.db_list_field': ['1', 2, {
+            'db_embedded_field.db_list_field.2': {
                 '_cls': 'Embedded',
                 'db_string_field': 'hello world',
                 'db_int_field': 1,
                 'db_list_field': ['1', 2, {'hello': 'world'}],
                 'db_dict_field': {'hello': 'world'}}
-            ]}, {}))
+            }, {}))
         doc.save()
         doc = doc.reload(10)
         self.assertEqual(doc.embedded_field.list_field[2].string_field,
@@ -592,14 +587,13 @@ class DeltaTest(unittest.TestCase):
         self.assertEqual(doc.embedded_field.list_field[2].list_field,
             [1, 2, {'hello': 'world'}])
 
-        del(doc.embedded_field.list_field[2].list_field[2]['hello'])
+        del doc.embedded_field.list_field[2].list_field[2]['hello']
         self.assertEqual(doc._delta(),
-            ({'db_embedded_field.db_list_field.2.db_list_field':
-                [1, 2, {}]}, {}))
+            ({}, {'db_embedded_field.db_list_field.2.db_list_field.2.hello': 1}))
         doc.save()
         doc = doc.reload(10)
 
-        del(doc.embedded_field.list_field[2].list_field)
+        del doc.embedded_field.list_field[2].list_field
         self.assertEqual(doc._delta(), ({},
             {'db_embedded_field.db_list_field.2.db_list_field': 1}))
 
@@ -615,7 +609,7 @@ class DeltaTest(unittest.TestCase):
             SON([('_cls', 'Person'), ('name', 'James'), ('age', 34)]), {}))
 
         p.doc = 123
-        del(p.doc)
+        del p.doc
         self.assertEqual(p._delta(), (
             SON([('_cls', 'Person'), ('name', 'James'), ('age', 34)]), {}))
 
@@ -696,7 +690,7 @@ class DeltaTest(unittest.TestCase):
         organization.employees.append(person)
         updates, removals = organization._delta()
         self.assertEqual({}, removals)
-        self.assertTrue('employees' in updates)
+        self.assertIn('employees', updates)
 
     def test_delta_with_dbref_false(self):
         person, organization, employee = self.circular_reference_deltas_2(Document, Document, False)
@@ -711,7 +705,7 @@ class DeltaTest(unittest.TestCase):
         organization.employees.append(person)
         updates, removals = organization._delta()
         self.assertEqual({}, removals)
-        self.assertTrue('employees' in updates)
+        self.assertIn('employees', updates)
 
     def test_nested_nested_fields_mark_as_changed(self):
         class EmbeddedDoc(EmbeddedDocument):
@@ -735,5 +729,136 @@ class DeltaTest(unittest.TestCase):
         mydoc._clear_changed_fields()
         self.assertEqual([], mydoc._get_changed_fields())
 
+    def test_lower_level_mark_as_changed(self):
+        class EmbeddedDoc(EmbeddedDocument):
+            name = StringField()
+
+        class MyDoc(Document):
+            subs = MapField(EmbeddedDocumentField(EmbeddedDoc))
+
+        MyDoc.drop_collection()
+
+        MyDoc().save()
+
+        mydoc = MyDoc.objects.first()
+        mydoc.subs['a'] = EmbeddedDoc()
+        self.assertEqual(["subs.a"], mydoc._get_changed_fields())
+
+        subdoc = mydoc.subs['a']
+        subdoc.name = 'bar'
+
+        self.assertEqual(["name"], subdoc._get_changed_fields())
+        self.assertEqual(["subs.a"], mydoc._get_changed_fields())
+        mydoc.save()
+
+        mydoc._clear_changed_fields()
+        self.assertEqual([], mydoc._get_changed_fields())
+
+    def test_upper_level_mark_as_changed(self):
+        class EmbeddedDoc(EmbeddedDocument):
+            name = StringField()
+
+        class MyDoc(Document):
+            subs = MapField(EmbeddedDocumentField(EmbeddedDoc))
+
+        MyDoc.drop_collection()
+
+        MyDoc(subs={'a': EmbeddedDoc(name='foo')}).save()
+
+        mydoc = MyDoc.objects.first()
+        subdoc = mydoc.subs['a']
+        subdoc.name = 'bar'
+
+        self.assertEqual(["name"], subdoc._get_changed_fields())
+        self.assertEqual(["subs.a.name"], mydoc._get_changed_fields())
+
+        mydoc.subs['a'] = EmbeddedDoc()
+        self.assertEqual(["subs.a"], mydoc._get_changed_fields())
+        mydoc.save()
+
+        mydoc._clear_changed_fields()
+        self.assertEqual([], mydoc._get_changed_fields())
+
+    def test_referenced_object_changed_attributes(self):
+        """Ensures that when you save a new reference to a field, the referenced object isn't altered"""
+
+        class Organization(Document):
+            name = StringField()
+
+        class User(Document):
+            name = StringField()
+            org = ReferenceField('Organization', required=True)
+
+        Organization.drop_collection()
+        User.drop_collection()
+
+        org1 = Organization(name='Org 1')
+        org1.save()
+
+        org2 = Organization(name='Org 2')
+        org2.save()
+
+        user = User(name='Fred', org=org1)
+        user.save()
+
+        org1.reload()
+        org2.reload()
+        user.reload()
+        self.assertEqual(org1.name, 'Org 1')
+        self.assertEqual(org2.name, 'Org 2')
+        self.assertEqual(user.name, 'Fred')
+
+        user.name = 'Harold'
+        user.org = org2
+
+        org2.name = 'New Org 2'
+        self.assertEqual(org2.name, 'New Org 2')
+
+        user.save()
+        org2.save()
+
+        self.assertEqual(org2.name, 'New Org 2')
+        org2.reload()
+        self.assertEqual(org2.name, 'New Org 2')
+
+    def test_delta_for_nested_map_fields(self):
+        class UInfoDocument(Document):
+            phone = StringField()
+
+        class EmbeddedRole(EmbeddedDocument):
+            type = StringField()
+
+        class EmbeddedUser(EmbeddedDocument):
+            name = StringField()
+            roles = MapField(field=EmbeddedDocumentField(EmbeddedRole))
+            rolist = ListField(field=EmbeddedDocumentField(EmbeddedRole))
+            info = ReferenceField(UInfoDocument)
+
+        class Doc(Document):
+            users = MapField(field=EmbeddedDocumentField(EmbeddedUser))
+            num = IntField(default=-1)
+
+        Doc.drop_collection()
+
+        doc = Doc(num=1)
+        doc.users["007"] = EmbeddedUser(name="Agent007")
+        doc.save()
+
+        uinfo = UInfoDocument(phone="79089269066")
+        uinfo.save()
+
+        d = Doc.objects(num=1).first()
+        d.users["007"]["roles"]["666"] = EmbeddedRole(type="superadmin")
+        d.users["007"]["rolist"].append(EmbeddedRole(type="oops"))
+        d.users["007"]["info"] = uinfo
+        delta = d._delta()
+        self.assertEqual(True, "users.007.roles.666" in delta[0])
+        self.assertEqual(True, "users.007.rolist" in delta[0])
+        self.assertEqual(True, "users.007.info" in delta[0])
+        self.assertEqual('superadmin', delta[0]["users.007.roles.666"]["type"])
+        self.assertEqual('oops', delta[0]["users.007.rolist"][0]["type"])
+        self.assertEqual(uinfo.id, delta[0]["users.007.info"])
+
+
 if __name__ == '__main__':
     unittest.main()

tests/document/dynamic.py

@@ -1,18 +1,15 @@
 import unittest
-import sys
-sys.path[0:0] = [""]
 
 from mongoengine import *
-from mongoengine.connection import get_db
+from tests.utils import MongoDBTestCase
 
-__all__ = ("DynamicTest", )
+__all__ = ("TestDynamicDocument", )
 
 
-class DynamicTest(unittest.TestCase):
+class TestDynamicDocument(MongoDBTestCase):
 
     def setUp(self):
-        connect(db='mongoenginetest')
-        self.db = get_db()
+        super(TestDynamicDocument, self).setUp()
 
         class Person(DynamicDocument):
             name = StringField()
@@ -72,7 +69,7 @@ class DynamicTest(unittest.TestCase):
         obj = collection.find_one()
         self.assertEqual(sorted(obj.keys()), ['_cls', '_id', 'misc', 'name'])
 
-        del(p.misc)
+        del p.misc
         p.save()
 
         p = self.Person.objects.get()
@@ -81,6 +78,91 @@ class DynamicTest(unittest.TestCase):
         obj = collection.find_one()
         self.assertEqual(sorted(obj.keys()), ['_cls', '_id', 'name'])
 
+    def test_reload_after_unsetting(self):
+        p = self.Person()
+        p.misc = 22
+        p.save()
+        p.update(unset__misc=1)
+        p.reload()
+
+    def test_reload_dynamic_field(self):
+        self.Person.objects.delete()
+        p = self.Person.objects.create()
+        p.update(age=1)
+
+        self.assertEqual(len(p._data), 3)
+        self.assertEqual(sorted(p._data.keys()), ['_cls', 'id', 'name'])
+
+        p.reload()
+        self.assertEqual(len(p._data), 4)
+        self.assertEqual(sorted(p._data.keys()), ['_cls', 'age', 'id', 'name'])
+
+    def test_fields_without_underscore(self):
+        """Ensure we can query dynamic fields"""
+        Person = self.Person
+
+        p = self.Person(name='Dean')
+        p.save()
+
+        raw_p = Person.objects.as_pymongo().get(id=p.id)
+        self.assertEqual(
+            raw_p,
+            {
+                '_cls': u'Person',
+                '_id': p.id,
+                'name': u'Dean'
+             }
+        )
+
+        p.name = 'OldDean'
+        p.newattr = 'garbage'
+        p.save()
+        raw_p = Person.objects.as_pymongo().get(id=p.id)
+        self.assertEqual(
+            raw_p,
+            {
+                '_cls': u'Person',
+                '_id': p.id,
+                'name': 'OldDean',
+                'newattr': u'garbage'
+            }
+        )
+
+    def test_fields_containing_underscore(self):
+        """Ensure we can query dynamic fields"""
+        class WeirdPerson(DynamicDocument):
+            name = StringField()
+            _name = StringField()
+
+        WeirdPerson.drop_collection()
+
+        p = WeirdPerson(name='Dean', _name='Dean')
+        p.save()
+
+        raw_p = WeirdPerson.objects.as_pymongo().get(id=p.id)
+        self.assertEqual(
+            raw_p,
+            {
+                '_id': p.id,
+                '_name': u'Dean',
+                'name': u'Dean'
+            }
+        )
+
+        p.name = 'OldDean'
+        p._name = 'NewDean'
+        p._newattr1 = 'garbage'    # Unknown fields won't be added
+        p.save()
+        raw_p = WeirdPerson.objects.as_pymongo().get(id=p.id)
+        self.assertEqual(
+            raw_p,
+            {
+                '_id': p.id,
+                '_name': u'NewDean',
+                'name': u'OldDean',
+            }
+        )
+
     def test_dynamic_document_queries(self):
         """Ensure we can query dynamic fields"""
         p = self.Person()
@@ -122,6 +204,13 @@ class DynamicTest(unittest.TestCase):
 
         self.assertEqual(1, self.Person.objects(misc__hello='world').count())
 
+    def test_three_level_complex_data_lookups(self):
+        """Ensure you can query three level document dynamic fields"""
+        p = self.Person.objects.create(
+            misc={'hello': {'hello2': 'world'}}
+        )
+        self.assertEqual(1, self.Person.objects(misc__hello__hello2='world').count())
+
     def test_complex_embedded_document_validation(self):
         """Ensure embedded dynamic documents may be validated"""
         class Embedded(DynamicEmbeddedDocument):
@@ -150,8 +239,8 @@ class DynamicTest(unittest.TestCase):
 
         Employee.drop_collection()
 
-        self.assertTrue('name' in Employee._fields)
-        self.assertTrue('salary' in Employee._fields)
+        self.assertIn('name', Employee._fields)
+        self.assertIn('salary', Employee._fields)
         self.assertEqual(Employee._get_collection_name(),
                          self.Person._get_collection_name())
 
@@ -165,7 +254,7 @@ class DynamicTest(unittest.TestCase):
         self.assertEqual(1, Employee.objects(age=20).count())
 
         joe_bloggs = self.Person.objects.first()
-        self.assertTrue(isinstance(joe_bloggs, Employee))
+        self.assertIsInstance(joe_bloggs, Employee)
 
     def test_embedded_dynamic_document(self):
         """Test dynamic embedded documents"""
@@ -292,6 +381,59 @@ class DynamicTest(unittest.TestCase):
         person.save()
         self.assertEqual(Person.objects.first().age, 35)
 
+    def test_dynamic_embedded_works_with_only(self):
+        """Ensure custom fieldnames on a dynamic embedded document are found by qs.only()"""
+
+        class Address(DynamicEmbeddedDocument):
+            city = StringField()
+
+        class Person(DynamicDocument):
+            address = EmbeddedDocumentField(Address)
+
+        Person.drop_collection()
+
+        Person(name="Eric", address=Address(city="San Francisco", street_number="1337")).save()
+
+        self.assertEqual(Person.objects.first().address.street_number, '1337')
+        self.assertEqual(Person.objects.only('address__street_number').first().address.street_number, '1337')
+
+    def test_dynamic_and_embedded_dict_access(self):
+        """Ensure embedded dynamic documents work with dict[] style access"""
+
+        class Address(EmbeddedDocument):
+            city = StringField()
+
+        class Person(DynamicDocument):
+            name = StringField()
+
+        Person.drop_collection()
+
+        Person(name="Ross", address=Address(city="London")).save()
+
+        person = Person.objects.first()
+        person.attrval = "This works"
+
+        person["phone"] = "555-1212"  # but this should too
+
+        # Same thing two levels deep
+        person["address"]["city"] = "Lundenne"
+        person.save()
+
+        self.assertEqual(Person.objects.first().address.city, "Lundenne")
+
+        self.assertEqual(Person.objects.first().phone, "555-1212")
+
+        person = Person.objects.first()
+        person.address = Address(city="Londinium")
+        person.save()
+
+        self.assertEqual(Person.objects.first().address.city, "Londinium")
+
+        person = Person.objects.first()
+        person["age"] = 35
+        person.save()
+        self.assertEqual(Person.objects.first().age, 35)
+
 
 if __name__ == '__main__':
     unittest.main()

tests/document/indexes.py

@@ -1,16 +1,14 @@
 # -*- coding: utf-8 -*-
 import unittest
-import sys
-sys.path[0:0] = [""]
-
-import os
-import pymongo
-
-from nose.plugins.skip import SkipTest
 from datetime import datetime
 
+from nose.plugins.skip import SkipTest
+from pymongo.errors import OperationFailure
+import pymongo
+from six import iteritems
+
 from mongoengine import *
-from mongoengine.connection import get_db, get_connection
+from mongoengine.connection import get_db
 
 __all__ = ("IndexesTest", )
 
@@ -18,7 +16,7 @@ __all__ = ("IndexesTest", )
 class IndexesTest(unittest.TestCase):
 
     def setUp(self):
-        connect(db='mongoenginetest')
+        self.connection = connect(db='mongoenginetest')
         self.db = get_db()
 
         class Person(Document):
@@ -32,10 +30,7 @@ class IndexesTest(unittest.TestCase):
         self.Person = Person
 
     def tearDown(self):
-        for collection in self.db.collection_names():
-            if 'system.' in collection:
-                continue
-            self.db.drop_collection(collection)
+        self.connection.drop_database(self.db)
 
     def test_indexes_document(self):
         """Ensure that indexes are used when meta[indexes] is specified for
@@ -72,9 +67,9 @@ class IndexesTest(unittest.TestCase):
         info = BlogPost.objects._collection.index_information()
         # _id, '-date', 'tags', ('cat', 'date')
         self.assertEqual(len(info), 4)
-        info = [value['key'] for key, value in info.iteritems()]
+        info = [value['key'] for key, value in iteritems(info)]
         for expected in expected_specs:
-            self.assertTrue(expected['fields'] in info)
+            self.assertIn(expected['fields'], info)
 
     def _index_test_inheritance(self, InheritFrom):
 
@@ -104,9 +99,9 @@ class IndexesTest(unittest.TestCase):
         # the indices on -date and tags will both contain
         # _cls as first element in the key
         self.assertEqual(len(info), 4)
-        info = [value['key'] for key, value in info.iteritems()]
+        info = [value['key'] for key, value in iteritems(info)]
         for expected in expected_specs:
-            self.assertTrue(expected['fields'] in info)
+            self.assertIn(expected['fields'], info)
 
         class ExtendedBlogPost(BlogPost):
             title = StringField()
@@ -119,9 +114,9 @@ class IndexesTest(unittest.TestCase):
 
         ExtendedBlogPost.ensure_indexes()
         info = ExtendedBlogPost.objects._collection.index_information()
-        info = [value['key'] for key, value in info.iteritems()]
+        info = [value['key'] for key, value in iteritems(info)]
         for expected in expected_specs:
-            self.assertTrue(expected['fields'] in info)
+            self.assertIn(expected['fields'], info)
 
     def test_indexes_document_inheritance(self):
         """Ensure that indexes are used when meta[indexes] is specified for
@@ -143,7 +138,7 @@ class IndexesTest(unittest.TestCase):
             meta = {
                 'indexes': [
                         {
-                        'fields': ('title',),
+                            'fields': ('title',),
                         },
                 ],
                 'allow_inheritance': True,
@@ -175,6 +170,16 @@ class IndexesTest(unittest.TestCase):
         info = A._get_collection().index_information()
         self.assertEqual(len(info.keys()), 2)
 
+        class B(A):
+            c = StringField()
+            d = StringField()
+            meta = {
+                'indexes': [{'fields': ['c']}, {'fields': ['d'], 'cls': True}],
+                'allow_inheritance': True
+            }
+        self.assertEqual([('c', 1)], B._meta['index_specs'][1]['fields'])
+        self.assertEqual([('_cls', 1), ('d', 1)], B._meta['index_specs'][2]['fields'])
+
     def test_build_index_spec_is_not_destructive(self):
 
         class MyDoc(Document):
@@ -219,8 +224,8 @@ class IndexesTest(unittest.TestCase):
         # Indexes are lazy so use list() to perform query
         list(Person.objects)
         info = Person.objects._collection.index_information()
-        info = [value['key'] for key, value in info.iteritems()]
-        self.assertTrue([('rank.title', 1)] in info)
+        info = [value['key'] for key, value in iteritems(info)]
+        self.assertIn([('rank.title', 1)], info)
 
     def test_explicit_geo2d_index(self):
         """Ensure that geo2d indexes work when created via meta[indexes]
@@ -239,8 +244,8 @@ class IndexesTest(unittest.TestCase):
 
         Place.ensure_indexes()
         info = Place._get_collection().index_information()
-        info = [value['key'] for key, value in info.iteritems()]
-        self.assertTrue([('location.point', '2d')] in info)
+        info = [value['key'] for key, value in iteritems(info)]
+        self.assertIn([('location.point', '2d')], info)
 
     def test_explicit_geo2d_index_embedded(self):
         """Ensure that geo2d indexes work when created via meta[indexes]
@@ -262,8 +267,62 @@ class IndexesTest(unittest.TestCase):
 
         Place.ensure_indexes()
         info = Place._get_collection().index_information()
-        info = [value['key'] for key, value in info.iteritems()]
-        self.assertTrue([('current.location.point', '2d')] in info)
+        info = [value['key'] for key, value in iteritems(info)]
+        self.assertIn([('current.location.point', '2d')], info)
+
+    def test_explicit_geosphere_index(self):
+        """Ensure that geosphere indexes work when created via meta[indexes]
+        """
+        class Place(Document):
+            location = DictField()
+            meta = {
+                'allow_inheritance': True,
+                'indexes': [
+                    '(location.point',
+                ]
+            }
+
+        self.assertEqual([{'fields': [('location.point', '2dsphere')]}],
+                         Place._meta['index_specs'])
+
+        Place.ensure_indexes()
+        info = Place._get_collection().index_information()
+        info = [value['key'] for key, value in iteritems(info)]
+        self.assertIn([('location.point', '2dsphere')], info)
+
+    def test_explicit_geohaystack_index(self):
+        """Ensure that geohaystack indexes work when created via meta[indexes]
+        """
+        raise SkipTest('GeoHaystack index creation is not supported for now'
+                       'from meta, as it requires a bucketSize parameter.')
+
+        class Place(Document):
+            location = DictField()
+            name = StringField()
+            meta = {
+                'indexes': [
+                    (')location.point', 'name')
+                ]
+            }
+        self.assertEqual([{'fields': [('location.point', 'geoHaystack'), ('name', 1)]}],
+                         Place._meta['index_specs'])
+
+        Place.ensure_indexes()
+        info = Place._get_collection().index_information()
+        info = [value['key'] for key, value in iteritems(info)]
+        self.assertIn([('location.point', 'geoHaystack')], info)
+
+    def test_create_geohaystack_index(self):
+        """Ensure that geohaystack indexes can be created
+        """
+        class Place(Document):
+            location = DictField()
+            name = StringField()
+
+        Place.create_index({'fields': (')location.point', 'name')}, bucketSize=10)
+        info = Place._get_collection().index_information()
+        info = [value['key'] for key, value in iteritems(info)]
+        self.assertIn([('location.point', 'geoHaystack'), ('name', 1)], info)
 
     def test_dictionary_indexes(self):
         """Ensure that indexes are used when meta[indexes] contains
@@ -295,8 +354,8 @@ class IndexesTest(unittest.TestCase):
         info = [(value['key'],
                  value.get('unique', False),
                  value.get('sparse', False))
-                for key, value in info.iteritems()]
-        self.assertTrue(([('addDate', -1)], True, True) in info)
+                for key, value in iteritems(info)]
+        self.assertIn(([('addDate', -1)], True, True), info)
 
         BlogPost.drop_collection()
 
@@ -347,12 +406,11 @@ class IndexesTest(unittest.TestCase):
 
         self.assertEqual(2, User.objects.count())
         info = User.objects._collection.index_information()
-        self.assertEqual(info.keys(), ['_id_'])
+        self.assertEqual(list(info.keys()), ['_id_'])
 
         User.ensure_indexes()
         info = User.objects._collection.index_information()
         self.assertEqual(sorted(info.keys()), ['_cls_1_user_guid_1', '_id_'])
-        User.drop_collection()
 
     def test_embedded_document_index(self):
         """Tests settings an index on an embedded document
@@ -374,7 +432,6 @@ class IndexesTest(unittest.TestCase):
 
         info = BlogPost.objects._collection.index_information()
         self.assertEqual(sorted(info.keys()), ['_id_', 'date.yr_-1'])
-        BlogPost.drop_collection()
 
     def test_list_embedded_document_index(self):
         """Ensure list embedded documents can be indexed
@@ -401,7 +458,6 @@ class IndexesTest(unittest.TestCase):
         post1 = BlogPost(title="Embedded Indexes tests in place",
                          tags=[Tag(name="about"), Tag(name="time")])
         post1.save()
-        BlogPost.drop_collection()
 
     def test_recursive_embedded_objects_dont_break_indexes(self):
 
@@ -419,9 +475,9 @@ class IndexesTest(unittest.TestCase):
     def test_covered_index(self):
         """Ensure that covered indexes can be used
         """
-
         class Test(Document):
             a = IntField()
+            b = IntField()
 
             meta = {
                 'indexes': ['a'],
@@ -436,16 +492,38 @@ class IndexesTest(unittest.TestCase):
         # Need to be explicit about covered indexes as mongoDB doesn't know if
         # the documents returned might have more keys in that here.
         query_plan = Test.objects(id=obj.id).exclude('a').explain()
-        self.assertFalse(query_plan['indexOnly'])
+        self.assertEqual(
+            query_plan.get('queryPlanner').get('winningPlan').get('inputStage').get('stage'),
+            'IDHACK'
+        )
 
         query_plan = Test.objects(id=obj.id).only('id').explain()
-        self.assertTrue(query_plan['indexOnly'])
+        self.assertEqual(
+            query_plan.get('queryPlanner').get('winningPlan').get('inputStage').get('stage'),
+            'IDHACK'
+        )
 
         query_plan = Test.objects(a=1).only('a').exclude('id').explain()
-        self.assertTrue(query_plan['indexOnly'])
+        self.assertEqual(
+            query_plan.get('queryPlanner').get('winningPlan').get('inputStage').get('stage'),
+            'IXSCAN'
+        )
+        self.assertEqual(
+            query_plan.get('queryPlanner').get('winningPlan').get('stage'),
+            'PROJECTION'
+        )
+
+        query_plan = Test.objects(a=1).explain()
+        self.assertEqual(
+            query_plan.get('queryPlanner').get('winningPlan').get('inputStage').get('stage'),
+            'IXSCAN'
+        )
+        self.assertEqual(
+            query_plan.get('queryPlanner').get('winningPlan').get('stage'),
+            'FETCH'
+        )
 
     def test_index_on_id(self):
-
         class BlogPost(Document):
             meta = {
                 'indexes': [
@@ -464,34 +542,46 @@ class IndexesTest(unittest.TestCase):
                                  [('categories', 1), ('_id', 1)])
 
     def test_hint(self):
+        TAGS_INDEX_NAME = 'tags_1'
 
         class BlogPost(Document):
             tags = ListField(StringField())
             meta = {
                 'indexes': [
-                    'tags',
+                    {
+                        'fields': ['tags'],
+                        'name': TAGS_INDEX_NAME
+                    }
                 ],
             }
 
         BlogPost.drop_collection()
 
-        for i in xrange(0, 10):
-            tags = [("tag %i" % n) for n in xrange(0, i % 2)]
+        for i in range(10):
+            tags = [("tag %i" % n) for n in range(i % 2)]
             BlogPost(tags=tags).save()
 
-        self.assertEqual(BlogPost.objects.count(), 10)
-        self.assertEqual(BlogPost.objects.hint().count(), 10)
+        # Hinting by shape should work.
         self.assertEqual(BlogPost.objects.hint([('tags', 1)]).count(), 10)
 
-        self.assertEqual(BlogPost.objects.hint([('ZZ', 1)]).count(), 10)
+        # Hinting by index name should work.
+        self.assertEqual(BlogPost.objects.hint(TAGS_INDEX_NAME).count(), 10)
 
-        def invalid_index():
-            BlogPost.objects.hint('tags')
-        self.assertRaises(TypeError, invalid_index)
+        # Clearing the hint should work fine.
+        self.assertEqual(BlogPost.objects.hint().count(), 10)
+        self.assertEqual(BlogPost.objects.hint([('ZZ', 1)]).hint().count(), 10)
 
-        def invalid_index_2():
-            return BlogPost.objects.hint(('tags', 1))
-        self.assertRaises(TypeError, invalid_index_2)
+        # Hinting on a non-existent index shape should fail.
+        with self.assertRaises(OperationFailure):
+            BlogPost.objects.hint([('ZZ', 1)]).count()
+
+        # Hinting on a non-existent index name should fail.
+        with self.assertRaises(OperationFailure):
+            BlogPost.objects.hint('Bad Name').count()
+
+        # Invalid shape argument (missing list brackets) should fail.
+        with self.assertRaises(ValueError):
+            BlogPost.objects.hint(('tags', 1)).count()
 
     def test_unique(self):
         """Ensure that uniqueness constraints are applied to fields.
@@ -508,10 +598,32 @@ class IndexesTest(unittest.TestCase):
         # Two posts with the same slug is not allowed
         post2 = BlogPost(title='test2', slug='test')
         self.assertRaises(NotUniqueError, post2.save)
+        self.assertRaises(NotUniqueError, BlogPost.objects.insert, post2)
 
-        # Ensure backwards compatibilty for errors
+        # Ensure backwards compatibility for errors
         self.assertRaises(OperationError, post2.save)
 
+    def test_primary_key_unique_not_working(self):
+        """Relates to #1445"""
+        class Blog(Document):
+            id = StringField(primary_key=True, unique=True)
+
+        Blog.drop_collection()
+
+        with self.assertRaises(OperationFailure) as ctx_err:
+            Blog(id='garbage').save()
+
+        # One of the errors below should happen. Which one depends on the
+        # PyMongo version and dict order.
+        err_msg = str(ctx_err.exception)
+        self.assertTrue(
+            any([
+                "The field 'unique' is not valid for an _id index specification" in err_msg,
+                "The field 'background' is not valid for an _id index specification" in err_msg,
+                "The field 'sparse' is not valid for an _id index specification" in err_msg,
+            ])
+        )
+
     def test_unique_with(self):
         """Ensure that unique_with constraints are applied to fields.
         """
@@ -536,8 +648,6 @@ class IndexesTest(unittest.TestCase):
         post3 = BlogPost(title='test3', date=Date(year=2010), slug='test')
         self.assertRaises(OperationError, post3.save)
 
-        BlogPost.drop_collection()
-
     def test_unique_embedded_document(self):
         """Ensure that uniqueness constraints are applied to fields on embedded documents.
         """
@@ -565,8 +675,107 @@ class IndexesTest(unittest.TestCase):
                          sub=SubDocument(year=2010, slug='test'))
         self.assertRaises(NotUniqueError, post3.save)
 
+    def test_unique_embedded_document_in_list(self):
+        """
+        Ensure that the uniqueness constraints are applied to fields in
+        embedded documents, even when the embedded documents in in a
+        list field.
+        """
+        class SubDocument(EmbeddedDocument):
+            year = IntField(db_field='yr')
+            slug = StringField(unique=True)
+
+        class BlogPost(Document):
+            title = StringField()
+            subs = ListField(EmbeddedDocumentField(SubDocument))
+
         BlogPost.drop_collection()
 
+        post1 = BlogPost(
+            title='test1', subs=[
+                SubDocument(year=2009, slug='conflict'),
+                SubDocument(year=2009, slug='conflict')
+            ]
+        )
+        post1.save()
+
+        post2 = BlogPost(
+            title='test2', subs=[SubDocument(year=2014, slug='conflict')]
+        )
+
+        self.assertRaises(NotUniqueError, post2.save)
+
+    def test_unique_embedded_document_in_sorted_list(self):
+        """
+        Ensure that the uniqueness constraints are applied to fields in
+        embedded documents, even when the embedded documents in a sorted list
+        field.
+        """
+        class SubDocument(EmbeddedDocument):
+            year = IntField()
+            slug = StringField(unique=True)
+
+        class BlogPost(Document):
+            title = StringField()
+            subs = SortedListField(EmbeddedDocumentField(SubDocument),
+                                   ordering='year')
+
+        BlogPost.drop_collection()
+
+        post1 = BlogPost(
+            title='test1', subs=[
+                SubDocument(year=2009, slug='conflict'),
+                SubDocument(year=2009, slug='conflict')
+            ]
+        )
+        post1.save()
+
+        # confirm that the unique index is created
+        indexes = BlogPost._get_collection().index_information()
+        self.assertIn('subs.slug_1', indexes)
+        self.assertTrue(indexes['subs.slug_1']['unique'])
+
+        post2 = BlogPost(
+            title='test2', subs=[SubDocument(year=2014, slug='conflict')]
+        )
+
+        self.assertRaises(NotUniqueError, post2.save)
+
+    def test_unique_embedded_document_in_embedded_document_list(self):
+        """
+        Ensure that the uniqueness constraints are applied to fields in
+        embedded documents, even when the embedded documents in an embedded
+        list field.
+        """
+        class SubDocument(EmbeddedDocument):
+            year = IntField()
+            slug = StringField(unique=True)
+
+        class BlogPost(Document):
+            title = StringField()
+            subs = EmbeddedDocumentListField(SubDocument)
+
+        BlogPost.drop_collection()
+
+        post1 = BlogPost(
+            title='test1', subs=[
+                SubDocument(year=2009, slug='conflict'),
+                SubDocument(year=2009, slug='conflict')
+            ]
+        )
+        post1.save()
+
+        # confirm that the unique index is created
+        indexes = BlogPost._get_collection().index_information()
+        self.assertIn('subs.slug_1', indexes)
+        self.assertTrue(indexes['subs.slug_1']['unique'])
+
+        post2 = BlogPost(
+            title='test2', subs=[SubDocument(year=2014, slug='conflict')]
+        )
+
+        self.assertRaises(NotUniqueError, post2.save)
+
     def test_unique_with_embedded_document_and_embedded_unique(self):
         """Ensure that uniqueness constraints are applied to fields on
         embedded documents.  And work with unique_with as well.
@@ -600,8 +809,6 @@ class IndexesTest(unittest.TestCase):
                          sub=SubDocument(year=2009, slug='test-1'))
         self.assertRaises(NotUniqueError, post3.save)
 
-        BlogPost.drop_collection()
-
     def test_ttl_indexes(self):
 
         class Log(Document):
@@ -614,20 +821,24 @@ class IndexesTest(unittest.TestCase):
 
         Log.drop_collection()
 
-        if pymongo.version_tuple[0] < 2 and pymongo.version_tuple[1] < 3:
-            raise SkipTest('pymongo needs to be 2.3 or higher for this test')
-
-        connection = get_connection()
-        version_array = connection.server_info()['versionArray']
-        if version_array[0] < 2 and version_array[1] < 2:
-            raise SkipTest('MongoDB needs to be 2.2 or higher for this test')
-
         # Indexes are lazy so use list() to perform query
         list(Log.objects)
         info = Log.objects._collection.index_information()
         self.assertEqual(3600,
                          info['created_1']['expireAfterSeconds'])
 
+    def test_index_drop_dups_silently_ignored(self):
+        class Customer(Document):
+            cust_id = IntField(unique=True, required=True)
+            meta = {
+                'indexes': ['cust_id'],
+                'index_drop_dups': True,
+                'allow_inheritance': False,
+            }
+
+        Customer.drop_collection()
+        Customer.objects.first()
+
     def test_unique_and_indexes(self):
         """Ensure that 'unique' constraints aren't overridden by
         meta.indexes.
@@ -644,20 +855,23 @@ class IndexesTest(unittest.TestCase):
         cust.save()
 
         cust_dupe = Customer(cust_id=1)
-        try:
+        with self.assertRaises(NotUniqueError):
             cust_dupe.save()
-            raise AssertionError("We saved a dupe!")
-        except NotUniqueError:
-            pass
-        Customer.drop_collection()
 
-    def test_unique_and_primary(self):
+        cust = Customer(cust_id=2)
+        cust.save()
+
+        # duplicate key on update
+        with self.assertRaises(NotUniqueError):
+            cust.cust_id = 1
+            cust.save()
+
+    def test_primary_save_duplicate_update_existing_object(self):
         """If you set a field as primary, then unexpected behaviour can occur.
         You won't create a duplicate but you will update an existing document.
         """
-
         class User(Document):
-            name = StringField(primary_key=True, unique=True)
+            name = StringField(primary_key=True)
             password = StringField()
 
         User.drop_collection()
@@ -671,8 +885,23 @@ class IndexesTest(unittest.TestCase):
         self.assertEqual(User.objects.count(), 1)
         self.assertEqual(User.objects.get().password, 'secret2')
 
+    def test_unique_and_primary_create(self):
+        """Create a new record with a duplicate primary key
+        throws an exception
+        """
+        class User(Document):
+            name = StringField(primary_key=True)
+            password = StringField()
+
         User.drop_collection()
 
+        User.objects.create(name='huangz', password='secret')
+        with self.assertRaises(NotUniqueError):
+            User.objects.create(name='huangz', password='secret2')
+
+        self.assertEqual(User.objects.count(), 1)
+        self.assertEqual(User.objects.get().password, 'secret')
+
     def test_index_with_pk(self):
         """Ensure you can use `pk` as part of a query"""
 
@@ -689,9 +918,9 @@ class IndexesTest(unittest.TestCase):
             self.fail('Unbound local error at index + pk definition')
 
         info = BlogPost.objects._collection.index_information()
-        info = [value['key'] for key, value in info.iteritems()]
+        info = [value['key'] for key, value in iteritems(info)]
         index_item = [('_id', 1), ('comments.comment_id', 1)]
-        self.assertTrue(index_item in info)
+        self.assertIn(index_item, info)
 
     def test_compound_key_embedded(self):
 
@@ -699,33 +928,208 @@ class IndexesTest(unittest.TestCase):
             name = StringField(required=True)
             term = StringField(required=True)
 
-        class Report(Document):
+        class ReportEmbedded(Document):
             key = EmbeddedDocumentField(CompoundKey, primary_key=True)
             text = StringField()
 
-        Report.drop_collection()
-
         my_key = CompoundKey(name="n", term="ok")
-        report = Report(text="OK", key=my_key).save()
+        report = ReportEmbedded(text="OK", key=my_key).save()
 
         self.assertEqual({'text': 'OK', '_id': {'term': 'ok', 'name': 'n'}},
                          report.to_mongo())
-        self.assertEqual(report, Report.objects.get(pk=my_key))
+        self.assertEqual(report, ReportEmbedded.objects.get(pk=my_key))
 
     def test_compound_key_dictfield(self):
 
-        class Report(Document):
+        class ReportDictField(Document):
             key = DictField(primary_key=True)
             text = StringField()
 
-        Report.drop_collection()
-
         my_key = {"name": "n", "term": "ok"}
-        report = Report(text="OK", key=my_key).save()
+        report = ReportDictField(text="OK", key=my_key).save()
 
         self.assertEqual({'text': 'OK', '_id': {'term': 'ok', 'name': 'n'}},
                          report.to_mongo())
-        self.assertEqual(report, Report.objects.get(pk=my_key))
+
+        # We can't directly call ReportDictField.objects.get(pk=my_key),
+        # because dicts are unordered, and if the order in MongoDB is
+        # different than the one in `my_key`, this test will fail.
+        self.assertEqual(report, ReportDictField.objects.get(pk__name=my_key['name']))
+        self.assertEqual(report, ReportDictField.objects.get(pk__term=my_key['term']))
+
+    def test_string_indexes(self):
+
+        class MyDoc(Document):
+            provider_ids = DictField()
+            meta = {
+                "indexes": ["provider_ids.foo", "provider_ids.bar"],
+            }
+
+        info = MyDoc.objects._collection.index_information()
+        info = [value['key'] for key, value in iteritems(info)]
+        self.assertIn([('provider_ids.foo', 1)], info)
+        self.assertIn([('provider_ids.bar', 1)], info)
+
+    def test_sparse_compound_indexes(self):
+
+        class MyDoc(Document):
+            provider_ids = DictField()
+            meta = {
+                "indexes": [{'fields': ("provider_ids.foo", "provider_ids.bar"),
+                             'sparse': True}],
+            }
+
+        info = MyDoc.objects._collection.index_information()
+        self.assertEqual([('provider_ids.foo', 1), ('provider_ids.bar', 1)],
+                         info['provider_ids.foo_1_provider_ids.bar_1']['key'])
+        self.assertTrue(info['provider_ids.foo_1_provider_ids.bar_1']['sparse'])
+
+    def test_text_indexes(self):
+        class Book(Document):
+            title = DictField()
+            meta = {
+                "indexes": ["$title"],
+            }
+
+        indexes = Book.objects._collection.index_information()
+        self.assertIn("title_text", indexes)
+        key = indexes["title_text"]["key"]
+        self.assertIn(('_fts', 'text'), key)
+
+    def test_hashed_indexes(self):
+
+        class Book(Document):
+            ref_id = StringField()
+            meta = {
+                "indexes": ["#ref_id"],
+            }
+
+        indexes = Book.objects._collection.index_information()
+        self.assertIn("ref_id_hashed", indexes)
+        self.assertIn(('ref_id', 'hashed'), indexes["ref_id_hashed"]["key"])
+
+    def test_indexes_after_database_drop(self):
+        """
+        Test to ensure that indexes are re-created on a collection even
+        after the database has been dropped.
+
+        Issue #812
+        """
+        # Use a new connection and database since dropping the database could
+        # cause concurrent tests to fail.
+        connection = connect(db='tempdatabase',
+                             alias='test_indexes_after_database_drop')
+
+        class BlogPost(Document):
+            title = StringField()
+            slug = StringField(unique=True)
+
+            meta = {'db_alias': 'test_indexes_after_database_drop'}
+
+        try:
+            BlogPost.drop_collection()
+
+            # Create Post #1
+            post1 = BlogPost(title='test1', slug='test')
+            post1.save()
+
+            # Drop the Database
+            connection.drop_database('tempdatabase')
+
+            # Re-create Post #1
+            post1 = BlogPost(title='test1', slug='test')
+            post1.save()
+
+            # Create Post #2
+            post2 = BlogPost(title='test2', slug='test')
+            self.assertRaises(NotUniqueError, post2.save)
+        finally:
+            # Drop the temporary database at the end
+            connection.drop_database('tempdatabase')
+
+    def test_index_dont_send_cls_option(self):
+        """
+        Ensure that 'cls' option is not sent through ensureIndex. We shouldn't
+        send internal MongoEngine arguments that are not a part of the index
+        spec.
+
+        This is directly related to the fact that MongoDB doesn't validate the
+        options that are passed to ensureIndex. For more details, see:
+        https://jira.mongodb.org/browse/SERVER-769
+        """
+        class TestDoc(Document):
+            txt = StringField()
+
+            meta = {
+                'allow_inheritance': True,
+                'indexes': [
+                    {'fields': ('txt',), 'cls': False}
+                ]
+            }
+
+        class TestChildDoc(TestDoc):
+            txt2 = StringField()
+
+            meta = {
+                'indexes': [
+                    {'fields': ('txt2',), 'cls': False}
+                ]
+            }
+
+        TestDoc.drop_collection()
+        TestDoc.ensure_indexes()
+        TestChildDoc.ensure_indexes()
+
+        index_info = TestDoc._get_collection().index_information()
+        for key in index_info:
+            del index_info[key]['v']  # drop the index version - we don't care about that here
+            if 'ns' in index_info[key]:
+                del index_info[key]['ns']  # drop the index namespace - we don't care about that here, MongoDB 3+
+            if 'dropDups' in index_info[key]:
+                del index_info[key]['dropDups']  # drop the index dropDups - it is deprecated in MongoDB 3+
+
+        self.assertEqual(index_info, {
+            'txt_1': {
+                'key': [('txt', 1)],
+                'background': False
+            },
+            '_id_': {
+                'key': [('_id', 1)],
+            },
+            'txt2_1': {
+                'key': [('txt2', 1)],
+                'background': False
+            },
+            '_cls_1': {
+                'key': [('_cls', 1)],
+                'background': False,
+            }
+        })
+
+    def test_compound_index_underscore_cls_not_overwritten(self):
+        """
+        Test that the compound index doesn't get another _cls when it is specified
+        """
+        class TestDoc(Document):
+            shard_1 = StringField()
+            txt_1 = StringField()
+
+            meta = {
+                'collection': 'test',
+                'allow_inheritance': True,
+                'sparse': True,
+                'shard_key': 'shard_1',
+                'indexes': [
+                    ('shard_1', '_cls', 'txt_1'),
+                ]
+            }
+
+        TestDoc.drop_collection()
+        TestDoc.ensure_indexes()
+
+        index_info = TestDoc._get_collection().index_information()
+        self.assertIn('shard_1_1__cls_1_txt_1_1', index_info)
+
 
 if __name__ == '__main__':
     unittest.main()

tests/document/inheritance.py

@@ -1,33 +1,46 @@
 # -*- coding: utf-8 -*-
-import sys
-sys.path[0:0] = [""]
 import unittest
 import warnings
 
-from datetime import datetime
+from six import iteritems
 
+from mongoengine import (BooleanField, Document, EmbeddedDocument,
+                         EmbeddedDocumentField, GenericReferenceField,
+                         IntField, ReferenceField, StringField)
+from mongoengine.pymongo_support import list_collection_names
+from tests.utils import MongoDBTestCase
 from tests.fixtures import Base
 
-from mongoengine import Document, EmbeddedDocument, connect
-from mongoengine.connection import get_db
-from mongoengine.fields import (BooleanField, GenericReferenceField,
-                                IntField, StringField)
-
 __all__ = ('InheritanceTest', )
 
 
-class InheritanceTest(unittest.TestCase):
-
-    def setUp(self):
-        connect(db='mongoenginetest')
-        self.db = get_db()
+class InheritanceTest(MongoDBTestCase):
 
     def tearDown(self):
-        for collection in self.db.collection_names():
-            if 'system.' in collection:
-                continue
+        for collection in list_collection_names(self.db):
             self.db.drop_collection(collection)
 
+    def test_constructor_cls(self):
+        # Ensures _cls is properly set during construction
+        # and when object gets reloaded (prevent regression of #1950)
+        class EmbedData(EmbeddedDocument):
+            data = StringField()
+            meta = {'allow_inheritance': True}
+
+        class DataDoc(Document):
+            name = StringField()
+            embed = EmbeddedDocumentField(EmbedData)
+            meta = {'allow_inheritance': True}
+
+        test_doc = DataDoc(name='test', embed=EmbedData(data='data'))
+        self.assertEqual(test_doc._cls, 'DataDoc')
+        self.assertEqual(test_doc.embed._cls, 'EmbedData')
+        test_doc.save()
+        saved_doc = DataDoc.objects.with_id(test_doc.id)
+        self.assertEqual(test_doc._cls, saved_doc._cls)
+        self.assertEqual(test_doc.embed._cls, saved_doc.embed._cls)
+        test_doc.delete()
+
     def test_superclasses(self):
         """Ensure that the correct list of superclasses is assembled.
         """
@@ -163,7 +176,7 @@ class InheritanceTest(unittest.TestCase):
         class Employee(Person):
             salary = IntField()
 
-        self.assertEqual(['age', 'id', 'name', 'salary'],
+        self.assertEqual(['_cls', 'age', 'id', 'name', 'salary'],
                          sorted(Employee._fields.keys()))
         self.assertEqual(Employee._get_collection_name(),
                          Person._get_collection_name())
@@ -180,7 +193,7 @@ class InheritanceTest(unittest.TestCase):
         class Employee(Person):
             salary = IntField()
 
-        self.assertEqual(['age', 'id', 'name', 'salary'],
+        self.assertEqual(['_cls', 'age', 'id', 'name', 'salary'],
                          sorted(Employee._fields.keys()))
         self.assertEqual(Person(name="Bob", age=35).to_mongo().keys(),
                          ['_cls', 'name', 'age'])
@@ -253,18 +266,17 @@ class InheritanceTest(unittest.TestCase):
         self.assertEqual(classes, [Human])
 
     def test_allow_inheritance(self):
-        """Ensure that inheritance may be disabled on simple classes and that
-        _cls and _subclasses will not be used.
+        """Ensure that inheritance is disabled by default on simple
+        classes and that _cls will not be used.
         """
-
         class Animal(Document):
             name = StringField()
 
-        def create_dog_class():
+        # can't inherit because Animal didn't explicitly allow inheritance
+        with self.assertRaises(ValueError) as cm:
             class Dog(Animal):
                 pass
-
-        self.assertRaises(ValueError, create_dog_class)
+        self.assertIn("Document Animal may not be subclassed", str(cm.exception))
 
         # Check that _cls etc aren't present on simple documents
         dog = Animal(name='dog').save()
@@ -272,20 +284,19 @@ class InheritanceTest(unittest.TestCase):
 
         collection = self.db[Animal._get_collection_name()]
         obj = collection.find_one()
-        self.assertFalse('_cls' in obj)
+        self.assertNotIn('_cls', obj)
 
     def test_cant_turn_off_inheritance_on_subclass(self):
-        """Ensure if inheritance is on in a subclass you cant turn it off
+        """Ensure if inheritance is on in a subclass you cant turn it off.
         """
-
         class Animal(Document):
             name = StringField()
             meta = {'allow_inheritance': True}
 
-        def create_mammal_class():
+        with self.assertRaises(ValueError) as cm:
             class Mammal(Animal):
                 meta = {'allow_inheritance': False}
-        self.assertRaises(ValueError, create_mammal_class)
+        self.assertEqual(str(cm.exception), 'Only direct subclasses of Document may set "allow_inheritance" to False')
 
     def test_allow_inheritance_abstract_document(self):
         """Ensure that abstract documents can set inheritance rules and that
@@ -298,37 +309,131 @@ class InheritanceTest(unittest.TestCase):
         class Animal(FinalDocument):
             name = StringField()
 
-        def create_mammal_class():
+        with self.assertRaises(ValueError) as cm:
             class Mammal(Animal):
                 pass
-        self.assertRaises(ValueError, create_mammal_class)
 
         # Check that _cls isn't present in simple documents
         doc = Animal(name='dog')
-        self.assertFalse('_cls' in doc.to_mongo())
+        self.assertNotIn('_cls', doc.to_mongo())
+
+    def test_using_abstract_class_in_reference_field(self):
+        # Ensures no regression of #1920
+        class AbstractHuman(Document):
+            meta = {'abstract': True}
+
+        class Dad(AbstractHuman):
+            name = StringField()
+
+        class Home(Document):
+            dad = ReferenceField(AbstractHuman)  # Referencing the abstract class
+            address = StringField()
+
+        dad = Dad(name='5').save()
+        Home(dad=dad, address='street').save()
+
+        home = Home.objects.first()
+        home.address = 'garbage'
+        home.save()     # Was failing with ValidationError
+
+    def test_abstract_class_referencing_self(self):
+        # Ensures no regression of #1920
+        class Human(Document):
+            meta = {'abstract': True}
+            creator = ReferenceField('self', dbref=True)
+
+        class User(Human):
+            name = StringField()
+
+        user = User(name='John').save()
+        user2 = User(name='Foo', creator=user).save()
+
+        user2 = User.objects.with_id(user2.id)
+        user2.name = 'Bar'
+        user2.save()    # Was failing with ValidationError
+
+    def test_abstract_handle_ids_in_metaclass_properly(self):
+
+        class City(Document):
+            continent = StringField()
+            meta = {'abstract': True,
+                    'allow_inheritance': False}
+
+        class EuropeanCity(City):
+            name = StringField()
+
+        berlin = EuropeanCity(name='Berlin', continent='Europe')
+        self.assertEqual(len(berlin._db_field_map), len(berlin._fields_ordered))
+        self.assertEqual(len(berlin._reverse_db_field_map), len(berlin._fields_ordered))
+        self.assertEqual(len(berlin._fields_ordered), 3)
+        self.assertEqual(berlin._fields_ordered[0], 'id')
+
+    def test_auto_id_not_set_if_specific_in_parent_class(self):
+
+        class City(Document):
+            continent = StringField()
+            city_id = IntField(primary_key=True)
+            meta = {'abstract': True,
+                    'allow_inheritance': False}
+
+        class EuropeanCity(City):
+            name = StringField()
+
+        berlin = EuropeanCity(name='Berlin', continent='Europe')
+        self.assertEqual(len(berlin._db_field_map), len(berlin._fields_ordered))
+        self.assertEqual(len(berlin._reverse_db_field_map), len(berlin._fields_ordered))
+        self.assertEqual(len(berlin._fields_ordered), 3)
+        self.assertEqual(berlin._fields_ordered[0], 'city_id')
+
+    def test_auto_id_vs_non_pk_id_field(self):
+
+        class City(Document):
+            continent = StringField()
+            id = IntField()
+            meta = {'abstract': True,
+                    'allow_inheritance': False}
+
+        class EuropeanCity(City):
+            name = StringField()
+
+        berlin = EuropeanCity(name='Berlin', continent='Europe')
+        self.assertEqual(len(berlin._db_field_map), len(berlin._fields_ordered))
+        self.assertEqual(len(berlin._reverse_db_field_map), len(berlin._fields_ordered))
+        self.assertEqual(len(berlin._fields_ordered), 4)
+        self.assertEqual(berlin._fields_ordered[0], 'auto_id_0')
+        berlin.save()
+        self.assertEqual(berlin.pk, berlin.auto_id_0)
+
+    def test_abstract_document_creation_does_not_fail(self):
+        class City(Document):
+            continent = StringField()
+            meta = {'abstract': True,
+                    'allow_inheritance': False}
+
+        city = City(continent='asia')
+        self.assertEqual(None, city.pk)
+        # TODO: expected error? Shouldn't we create a new error type?
+        with self.assertRaises(KeyError):
+            setattr(city, 'pk', 1)
 
     def test_allow_inheritance_embedded_document(self):
-        """Ensure embedded documents respect inheritance
-        """
-
+        """Ensure embedded documents respect inheritance."""
         class Comment(EmbeddedDocument):
             content = StringField()
 
-        def create_special_comment():
+        with self.assertRaises(ValueError):
             class SpecialComment(Comment):
                 pass
 
-        self.assertRaises(ValueError, create_special_comment)
-
         doc = Comment(content='test')
-        self.assertFalse('_cls' in doc.to_mongo())
+        self.assertNotIn('_cls', doc.to_mongo())
 
         class Comment(EmbeddedDocument):
             content = StringField()
             meta = {'allow_inheritance': True}
 
         doc = Comment(content='test')
-        self.assertTrue('_cls' in doc.to_mongo())
+        self.assertIn('_cls', doc.to_mongo())
 
     def test_document_inheritance(self):
         """Ensure mutliple inheritance of abstract documents
@@ -348,7 +453,7 @@ class InheritanceTest(unittest.TestCase):
         try:
             class MyDocument(DateCreatedDocument, DateUpdatedDocument):
                 pass
-        except:
+        except Exception:
             self.assertTrue(False, "Couldn't create MyDocument class")
 
     def test_abstract_documents(self):
@@ -377,12 +482,12 @@ class InheritanceTest(unittest.TestCase):
             meta = {'abstract': True}
         class Human(Mammal): pass
 
-        for k, v in defaults.iteritems():
+        for k, v in iteritems(defaults):
             for cls in [Animal, Fish, Guppy]:
                 self.assertEqual(cls._meta[k], v)
 
-        self.assertFalse('collection' in Animal._meta)
-        self.assertFalse('collection' in Mammal._meta)
+        self.assertNotIn('collection', Animal._meta)
+        self.assertNotIn('collection', Mammal._meta)
 
         self.assertEqual(Animal._get_collection_name(), None)
         self.assertEqual(Mammal._get_collection_name(), None)
@@ -391,11 +496,21 @@ class InheritanceTest(unittest.TestCase):
         self.assertEqual(Guppy._get_collection_name(), 'fish')
         self.assertEqual(Human._get_collection_name(), 'human')
 
-        def create_bad_abstract():
+        # ensure that a subclass of a non-abstract class can't be abstract
+        with self.assertRaises(ValueError):
             class EvilHuman(Human):
                 evil = BooleanField(default=True)
                 meta = {'abstract': True}
-        self.assertRaises(ValueError, create_bad_abstract)
+
+    def test_abstract_embedded_documents(self):
+        # 789: EmbeddedDocument shouldn't inherit abstract
+        class A(EmbeddedDocument):
+            meta = {"abstract": True}
+
+        class B(A):
+            pass
+
+        self.assertFalse(B._meta["abstract"])
 
     def test_inherited_collections(self):
         """Ensure that subclassed documents don't override parents'

tests/document/json_serialisation.py

@@ -1,6 +1,3 @@
-import sys
-sys.path[0:0] = [""]
-
 import unittest
 import uuid
 
@@ -20,6 +17,28 @@ class TestJson(unittest.TestCase):
     def setUp(self):
         connect(db='mongoenginetest')
 
+    def test_json_names(self):
+        """
+        Going to test reported issue:
+            https://github.com/MongoEngine/mongoengine/issues/654
+        where the reporter asks for the availability to perform
+        a to_json with the original class names and not the abreviated
+        mongodb document keys
+        """
+        class Embedded(EmbeddedDocument):
+            string = StringField(db_field='s')
+
+        class Doc(Document):
+            string = StringField(db_field='s')
+            embedded = EmbeddedDocumentField(Embedded, db_field='e')
+
+        doc = Doc(string="Hello", embedded=Embedded(string="Inner Hello"))
+        doc_json = doc.to_json(sort_keys=True, use_db_field=False, separators=(',', ':'))
+
+        expected_json = """{"embedded":{"string":"Inner Hello"},"string":"Hello"}"""
+
+        self.assertEqual(doc_json, expected_json)
+
     def test_json_simple(self):
 
         class Embedded(EmbeddedDocument):
@@ -29,6 +48,10 @@ class TestJson(unittest.TestCase):
             string = StringField()
             embedded_field = EmbeddedDocumentField(Embedded)
 
+            def __eq__(self, other):
+                return (self.string == other.string and
+                        self.embedded_field == other.embedded_field)
+
         doc = Doc(string="Hi", embedded_field=Embedded(string="Hi"))
 
         doc_json = doc.to_json(sort_keys=True, separators=(',', ':'))
@@ -38,10 +61,6 @@ class TestJson(unittest.TestCase):
         self.assertEqual(doc, Doc.from_json(doc.to_json()))
 
     def test_json_complex(self):
-
-        if pymongo.version_tuple[0] <= 2 and pymongo.version_tuple[1] <= 3:
-            raise SkipTest("Need pymongo 2.4 as has a fix for DBRefs")
-
         class EmbeddedDoc(EmbeddedDocument):
             pass
 
@@ -77,6 +96,10 @@ class TestJson(unittest.TestCase):
             generic_embedded_document_field = GenericEmbeddedDocumentField(
                                         default=lambda: EmbeddedDoc())
 
+            def __eq__(self, other):
+                import json
+                return json.loads(self.to_json()) == json.loads(other.to_json())
+
         doc = Doc()
         self.assertEqual(doc, Doc.from_json(doc.to_json()))
 

tests/document/validation.py

@@ -1,7 +1,4 @@
 # -*- coding: utf-8 -*-
-import sys
-sys.path[0:0] = [""]
-
 import unittest
 from datetime import datetime
 
@@ -23,16 +20,16 @@ class ValidatorErrorTest(unittest.TestCase):
 
         # 1st level error schema
         error.errors = {'1st': ValidationError('bad 1st'), }
-        self.assertTrue('1st' in error.to_dict())
+        self.assertIn('1st', error.to_dict())
         self.assertEqual(error.to_dict()['1st'], 'bad 1st')
 
         # 2nd level error schema
         error.errors = {'1st': ValidationError('bad 1st', errors={
             '2nd': ValidationError('bad 2nd'),
         })}
-        self.assertTrue('1st' in error.to_dict())
-        self.assertTrue(isinstance(error.to_dict()['1st'], dict))
-        self.assertTrue('2nd' in error.to_dict()['1st'])
+        self.assertIn('1st', error.to_dict())
+        self.assertIsInstance(error.to_dict()['1st'], dict)
+        self.assertIn('2nd', error.to_dict()['1st'])
         self.assertEqual(error.to_dict()['1st']['2nd'], 'bad 2nd')
 
         # moar levels
@@ -43,10 +40,10 @@ class ValidatorErrorTest(unittest.TestCase):
                 }),
             }),
         })}
-        self.assertTrue('1st' in error.to_dict())
-        self.assertTrue('2nd' in error.to_dict()['1st'])
-        self.assertTrue('3rd' in error.to_dict()['1st']['2nd'])
-        self.assertTrue('4th' in error.to_dict()['1st']['2nd']['3rd'])
+        self.assertIn('1st', error.to_dict())
+        self.assertIn('2nd', error.to_dict()['1st'])
+        self.assertIn('3rd', error.to_dict()['1st']['2nd'])
+        self.assertIn('4th', error.to_dict()['1st']['2nd']['3rd'])
         self.assertEqual(error.to_dict()['1st']['2nd']['3rd']['4th'],
                          'Inception')
 
@@ -60,8 +57,8 @@ class ValidatorErrorTest(unittest.TestCase):
 
         try:
             User().validate()
-        except ValidationError, e:
-            self.assertTrue("User:None" in e.message)
+        except ValidationError as e:
+            self.assertIn("User:None", e.message)
             self.assertEqual(e.to_dict(), {
                 'username': 'Field is required',
                 'name': 'Field is required'})
@@ -70,8 +67,8 @@ class ValidatorErrorTest(unittest.TestCase):
         user.name = None
         try:
             user.save()
-        except ValidationError, e:
-            self.assertTrue("User:RossC0" in e.message)
+        except ValidationError as e:
+            self.assertIn("User:RossC0", e.message)
             self.assertEqual(e.to_dict(), {
                 'name': 'Field is required'})
 
@@ -118,8 +115,8 @@ class ValidatorErrorTest(unittest.TestCase):
 
         try:
             Doc(id="bad").validate()
-        except ValidationError, e:
-            self.assertTrue("SubDoc:None" in e.message)
+        except ValidationError as e:
+            self.assertIn("SubDoc:None", e.message)
             self.assertEqual(e.to_dict(), {
                 "e": {'val': 'OK could not be converted to int'}})
 
@@ -130,17 +127,88 @@ class ValidatorErrorTest(unittest.TestCase):
         doc = Doc.objects.first()
         keys = doc._data.keys()
         self.assertEqual(2, len(keys))
-        self.assertTrue('e' in keys)
-        self.assertTrue('id' in keys)
+        self.assertIn('e', keys)
+        self.assertIn('id', keys)
 
         doc.e.val = "OK"
         try:
             doc.save()
-        except ValidationError, e:
-            self.assertTrue("Doc:test" in e.message)
+        except ValidationError as e:
+            self.assertIn("Doc:test", e.message)
             self.assertEqual(e.to_dict(), {
                 "e": {'val': 'OK could not be converted to int'}})
 
+    def test_embedded_weakref(self):
+
+        class SubDoc(EmbeddedDocument):
+            val = IntField(required=True)
+
+        class Doc(Document):
+            e = EmbeddedDocumentField(SubDoc, db_field='eb')
+
+        Doc.drop_collection()
+
+        d1 = Doc()
+        d2 = Doc()
+
+        s = SubDoc()
+
+        self.assertRaises(ValidationError, s.validate)
+
+        d1.e = s
+        d2.e = s
+
+        del d1
+
+        self.assertRaises(ValidationError, d2.validate)
+
+    def test_parent_reference_in_child_document(self):
+        """
+        Test to ensure a ReferenceField can store a reference to a parent
+        class when inherited. Issue #954.
+        """
+        class Parent(Document):
+            meta = {'allow_inheritance': True}
+            reference = ReferenceField('self')
+
+        class Child(Parent):
+            pass
+
+        parent = Parent()
+        parent.save()
+
+        child = Child(reference=parent)
+
+        # Saving child should not raise a ValidationError
+        try:
+            child.save()
+        except ValidationError as e:
+            self.fail("ValidationError raised: %s" % e.message)
+
+    def test_parent_reference_set_as_attribute_in_child_document(self):
+        """
+        Test to ensure a ReferenceField can store a reference to a parent
+        class when inherited and when set via attribute. Issue #954.
+        """
+        class Parent(Document):
+            meta = {'allow_inheritance': True}
+            reference = ReferenceField('self')
+
+        class Child(Parent):
+            pass
+
+        parent = Parent()
+        parent.save()
+
+        child = Child()
+        child.reference = parent
+
+        # Saving the child should not raise a ValidationError
+        try:
+            child.save()
+        except ValidationError as e:
+            self.fail("ValidationError raised: %s" % e.message)
+
 
 if __name__ == '__main__':
     unittest.main()

tests/fields/__init__.py

@@ -1,3 +1,3 @@
-from fields import *
-from file_tests import *
-from geo import *
+from .fields import *
+from .file_tests import *
+from .geo import *

tests/fields/file_tests.py

@@ -1,18 +1,16 @@
 # -*- coding: utf-8 -*-
-import sys
-sys.path[0:0] = [""]
-
 import copy
 import os
 import unittest
 import tempfile
 
 import gridfs
+import six
 
 from nose.plugins.skip import SkipTest
 from mongoengine import *
 from mongoengine.connection import get_db
-from mongoengine.python_support import PY3, b, StringIO
+from mongoengine.python_support import StringIO
 
 try:
     from PIL import Image
@@ -20,15 +18,23 @@ try:
 except ImportError:
     HAS_PIL = False
 
+from tests.utils import MongoDBTestCase
+
 TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__), 'mongoengine.png')
 TEST_IMAGE2_PATH = os.path.join(os.path.dirname(__file__), 'mongodb_leaf.png')
 
 
-class FileTest(unittest.TestCase):
+def get_file(path):
+    """Use a BytesIO instead of a file to allow
+    to have a one-liner and avoid that the file remains opened"""
+    bytes_io = StringIO()
+    with open(path, 'rb') as f:
+        bytes_io.write(f.read())
+    bytes_io.seek(0)
+    return bytes_io
 
-    def setUp(self):
-        connect(db='mongoenginetest')
-        self.db = get_db()
+
+class FileTest(MongoDBTestCase):
 
     def tearDown(self):
         self.db.drop_collection('fs.files')
@@ -49,7 +55,7 @@ class FileTest(unittest.TestCase):
 
         PutFile.drop_collection()
 
-        text = b('Hello, World!')
+        text = six.b('Hello, World!')
         content_type = 'text/plain'
 
         putfile = PutFile()
@@ -57,8 +63,8 @@ class FileTest(unittest.TestCase):
         putfile.save()
 
         result = PutFile.objects.first()
-        self.assertTrue(putfile == result)
-        self.assertEqual("%s" % result.the_file, "<GridFSProxy: hello>")
+        self.assertEqual(putfile, result)
+        self.assertEqual("%s" % result.the_file, "<GridFSProxy: hello (%s)>" % result.the_file.grid_id)
         self.assertEqual(result.the_file.read(), text)
         self.assertEqual(result.the_file.content_type, content_type)
         result.the_file.delete()  # Remove file from GridFS
@@ -75,7 +81,7 @@ class FileTest(unittest.TestCase):
         putfile.save()
 
         result = PutFile.objects.first()
-        self.assertTrue(putfile == result)
+        self.assertEqual(putfile, result)
         self.assertEqual(result.the_file.read(), text)
         self.assertEqual(result.the_file.content_type, content_type)
         result.the_file.delete()
@@ -88,8 +94,8 @@ class FileTest(unittest.TestCase):
 
         StreamFile.drop_collection()
 
-        text = b('Hello, World!')
-        more_text = b('Foo Bar')
+        text = six.b('Hello, World!')
+        more_text = six.b('Foo Bar')
         content_type = 'text/plain'
 
         streamfile = StreamFile()
@@ -100,7 +106,7 @@ class FileTest(unittest.TestCase):
         streamfile.save()
 
         result = StreamFile.objects.first()
-        self.assertTrue(streamfile == result)
+        self.assertEqual(streamfile, result)
         self.assertEqual(result.the_file.read(), text + more_text)
         self.assertEqual(result.the_file.content_type, content_type)
         result.the_file.seek(0)
@@ -112,15 +118,51 @@ class FileTest(unittest.TestCase):
         result.the_file.delete()
 
         # Ensure deleted file returns None
-        self.assertTrue(result.the_file.read() == None)
+        self.assertTrue(result.the_file.read() is None)
+
+    def test_file_fields_stream_after_none(self):
+        """Ensure that a file field can be written to after it has been saved as
+        None
+        """
+        class StreamFile(Document):
+            the_file = FileField()
+
+        StreamFile.drop_collection()
+
+        text = six.b('Hello, World!')
+        more_text = six.b('Foo Bar')
+        content_type = 'text/plain'
+
+        streamfile = StreamFile()
+        streamfile.save()
+        streamfile.the_file.new_file()
+        streamfile.the_file.write(text)
+        streamfile.the_file.write(more_text)
+        streamfile.the_file.close()
+        streamfile.save()
+
+        result = StreamFile.objects.first()
+        self.assertEqual(streamfile, result)
+        self.assertEqual(result.the_file.read(), text + more_text)
+        # self.assertEqual(result.the_file.content_type, content_type)
+        result.the_file.seek(0)
+        self.assertEqual(result.the_file.tell(), 0)
+        self.assertEqual(result.the_file.read(len(text)), text)
+        self.assertEqual(result.the_file.tell(), len(text))
+        self.assertEqual(result.the_file.read(len(more_text)), more_text)
+        self.assertEqual(result.the_file.tell(), len(text + more_text))
+        result.the_file.delete()
+
+        # Ensure deleted file returns None
+        self.assertTrue(result.the_file.read() is None)
 
     def test_file_fields_set(self):
 
         class SetFile(Document):
             the_file = FileField()
 
-        text = b('Hello, World!')
-        more_text = b('Foo Bar')
+        text = six.b('Hello, World!')
+        more_text = six.b('Foo Bar')
 
         SetFile.drop_collection()
 
@@ -129,7 +171,7 @@ class FileTest(unittest.TestCase):
         setfile.save()
 
         result = SetFile.objects.first()
-        self.assertTrue(setfile == result)
+        self.assertEqual(setfile, result)
         self.assertEqual(result.the_file.read(), text)
 
         # Try replacing file with new one
@@ -137,7 +179,7 @@ class FileTest(unittest.TestCase):
         result.save()
 
         result = SetFile.objects.first()
-        self.assertTrue(setfile == result)
+        self.assertEqual(setfile, result)
         self.assertEqual(result.the_file.read(), more_text)
         result.the_file.delete()
 
@@ -149,7 +191,7 @@ class FileTest(unittest.TestCase):
         GridDocument.drop_collection()
 
         with tempfile.TemporaryFile() as f:
-            f.write(b("Hello World!"))
+            f.write(six.b("Hello World!"))
             f.flush()
 
             # Test without default
@@ -166,7 +208,7 @@ class FileTest(unittest.TestCase):
             self.assertEqual(doc_b.the_file.grid_id, doc_c.the_file.grid_id)
 
             # Test with default
-            doc_d = GridDocument(the_file=b(''))
+            doc_d = GridDocument(the_file=six.b(''))
             doc_d.save()
 
             doc_e = GridDocument.objects.with_id(doc_d.id)
@@ -192,15 +234,15 @@ class FileTest(unittest.TestCase):
         # First instance
         test_file = TestFile()
         test_file.name = "Hello, World!"
-        test_file.the_file.put(b('Hello, World!'))
+        test_file.the_file.put(six.b('Hello, World!'))
         test_file.save()
 
         # Second instance
         test_file_dupe = TestFile()
         data = test_file_dupe.the_file.read()  # Should be None
 
-        self.assertTrue(test_file.name != test_file_dupe.name)
-        self.assertTrue(test_file.the_file.read() != data)
+        self.assertNotEqual(test_file.name, test_file_dupe.name)
+        self.assertNotEqual(test_file.the_file.read(), data)
 
         TestFile.drop_collection()
 
@@ -215,8 +257,8 @@ class FileTest(unittest.TestCase):
         Animal.drop_collection()
         marmot = Animal(genus='Marmota', family='Sciuridae')
 
-        marmot_photo = open(TEST_IMAGE_PATH, 'rb')  # Retrieve a photo from disk
-        marmot.photo.put(marmot_photo, content_type='image/jpeg', foo='bar')
+        marmot_photo_content = get_file(TEST_IMAGE_PATH)  # Retrieve a photo from disk
+        marmot.photo.put(marmot_photo_content, content_type='image/jpeg', foo='bar')
         marmot.photo.close()
         marmot.save()
 
@@ -229,11 +271,11 @@ class FileTest(unittest.TestCase):
             the_file = FileField()
         TestFile.drop_collection()
 
-        test_file = TestFile(the_file=open(TEST_IMAGE_PATH, 'rb')).save()
+        test_file = TestFile(the_file=get_file(TEST_IMAGE_PATH)).save()
         self.assertEqual(test_file.the_file.get().length, 8313)
 
         test_file = TestFile.objects.first()
-        test_file.the_file = open(TEST_IMAGE2_PATH, 'rb')
+        test_file.the_file = get_file(TEST_IMAGE2_PATH)
         test_file.save()
         self.assertEqual(test_file.the_file.get().length, 4971)
 
@@ -246,7 +288,7 @@ class FileTest(unittest.TestCase):
 
         test_file = TestFile()
         self.assertFalse(bool(test_file.the_file))
-        test_file.the_file.put(b('Hello, World!'), content_type='text/plain')
+        test_file.the_file.put(six.b('Hello, World!'), content_type='text/plain')
         test_file.save()
         self.assertTrue(bool(test_file.the_file))
 
@@ -259,7 +301,72 @@ class FileTest(unittest.TestCase):
             the_file = FileField()
 
         test_file = TestFile()
-        self.assertFalse(test_file.the_file in [{"test": 1}])
+        self.assertNotIn(test_file.the_file, [{"test": 1}])
+
+    def test_file_disk_space(self):
+        """ Test disk space usage when we delete/replace a file """
+        class TestFile(Document):
+            the_file = FileField()
+
+        text = six.b('Hello, World!')
+        content_type = 'text/plain'
+
+        testfile = TestFile()
+        testfile.the_file.put(text, content_type=content_type, filename="hello")
+        testfile.save()
+
+        # Now check fs.files and fs.chunks
+        db = TestFile._get_db()
+
+        files = db.fs.files.find()
+        chunks = db.fs.chunks.find()
+        self.assertEqual(len(list(files)), 1)
+        self.assertEqual(len(list(chunks)), 1)
+
+        # Deleting the docoument should delete the files
+        testfile.delete()
+
+        files = db.fs.files.find()
+        chunks = db.fs.chunks.find()
+        self.assertEqual(len(list(files)), 0)
+        self.assertEqual(len(list(chunks)), 0)
+
+        # Test case where we don't store a file in the first place
+        testfile = TestFile()
+        testfile.save()
+
+        files = db.fs.files.find()
+        chunks = db.fs.chunks.find()
+        self.assertEqual(len(list(files)), 0)
+        self.assertEqual(len(list(chunks)), 0)
+
+        testfile.delete()
+
+        files = db.fs.files.find()
+        chunks = db.fs.chunks.find()
+        self.assertEqual(len(list(files)), 0)
+        self.assertEqual(len(list(chunks)), 0)
+
+        # Test case where we overwrite the file
+        testfile = TestFile()
+        testfile.the_file.put(text, content_type=content_type, filename="hello")
+        testfile.save()
+
+        text = six.b('Bonjour, World!')
+        testfile.the_file.replace(text, content_type=content_type, filename="hello")
+        testfile.save()
+
+        files = db.fs.files.find()
+        chunks = db.fs.chunks.find()
+        self.assertEqual(len(list(files)), 1)
+        self.assertEqual(len(list(chunks)), 1)
+
+        testfile.delete()
+
+        files = db.fs.files.find()
+        chunks = db.fs.chunks.find()
+        self.assertEqual(len(list(files)), 0)
+        self.assertEqual(len(list(chunks)), 0)
 
     def test_image_field(self):
         if not HAS_PIL:
@@ -271,18 +378,18 @@ class FileTest(unittest.TestCase):
         TestImage.drop_collection()
 
         with tempfile.TemporaryFile() as f:
-            f.write(b("Hello World!"))
+            f.write(six.b("Hello World!"))
             f.flush()
 
             t = TestImage()
             try:
                 t.image.put(f)
                 self.fail("Should have raised an invalidation error")
-            except ValidationError, e:
-                self.assertEqual("%s" % e, "Invalid image: cannot identify image file")
+            except ValidationError as e:
+                self.assertEqual("%s" % e, "Invalid image: cannot identify image file %s" % f)
 
         t = TestImage()
-        t.image.put(open(TEST_IMAGE_PATH, 'rb'))
+        t.image.put(get_file(TEST_IMAGE_PATH))
         t.save()
 
         t = TestImage.objects.first()
@@ -303,11 +410,11 @@ class FileTest(unittest.TestCase):
             the_file = ImageField()
         TestFile.drop_collection()
 
-        test_file = TestFile(the_file=open(TEST_IMAGE_PATH, 'rb')).save()
+        test_file = TestFile(the_file=get_file(TEST_IMAGE_PATH)).save()
         self.assertEqual(test_file.the_file.size, (371, 76))
 
         test_file = TestFile.objects.first()
-        test_file.the_file = open(TEST_IMAGE2_PATH, 'rb')
+        test_file.the_file = get_file(TEST_IMAGE2_PATH)
         test_file.save()
         self.assertEqual(test_file.the_file.size, (45, 101))
 
@@ -321,7 +428,7 @@ class FileTest(unittest.TestCase):
         TestImage.drop_collection()
 
         t = TestImage()
-        t.image.put(open(TEST_IMAGE_PATH, 'rb'))
+        t.image.put(get_file(TEST_IMAGE_PATH))
         t.save()
 
         t = TestImage.objects.first()
@@ -344,7 +451,7 @@ class FileTest(unittest.TestCase):
         TestImage.drop_collection()
 
         t = TestImage()
-        t.image.put(open(TEST_IMAGE_PATH, 'rb'))
+        t.image.put(get_file(TEST_IMAGE_PATH))
         t.save()
 
         t = TestImage.objects.first()
@@ -367,7 +474,7 @@ class FileTest(unittest.TestCase):
         TestImage.drop_collection()
 
         t = TestImage()
-        t.image.put(open(TEST_IMAGE_PATH, 'rb'))
+        t.image.put(get_file(TEST_IMAGE_PATH))
         t.save()
 
         t = TestImage.objects.first()
@@ -395,7 +502,7 @@ class FileTest(unittest.TestCase):
         # First instance
         test_file = TestFile()
         test_file.name = "Hello, World!"
-        test_file.the_file.put(b('Hello, World!'),
+        test_file.the_file.put(six.b('Hello, World!'),
                           name="hello.txt")
         test_file.save()
 
@@ -403,16 +510,15 @@ class FileTest(unittest.TestCase):
         self.assertEqual(data.get('name'), 'hello.txt')
 
         test_file = TestFile.objects.first()
-        self.assertEqual(test_file.the_file.read(),
-                          b('Hello, World!'))
+        self.assertEqual(test_file.the_file.read(), six.b('Hello, World!'))
 
         test_file = TestFile.objects.first()
-        test_file.the_file = b('HELLO, WORLD!')
+        test_file.the_file = six.b('HELLO, WORLD!')
         test_file.save()
 
         test_file = TestFile.objects.first()
         self.assertEqual(test_file.the_file.read(),
-                          b('HELLO, WORLD!'))
+                         six.b('HELLO, WORLD!'))
 
     def test_copyable(self):
         class PutFile(Document):
@@ -420,7 +526,7 @@ class FileTest(unittest.TestCase):
 
         PutFile.drop_collection()
 
-        text = b('Hello, World!')
+        text = six.b('Hello, World!')
         content_type = 'text/plain'
 
         putfile = PutFile()
@@ -446,8 +552,8 @@ class FileTest(unittest.TestCase):
         TestImage.drop_collection()
 
         t = TestImage()
-        t.image1.put(open(TEST_IMAGE_PATH, 'rb'))
-        t.image2.put(open(TEST_IMAGE2_PATH, 'rb'))
+        t.image1.put(get_file(TEST_IMAGE_PATH))
+        t.image2.put(get_file(TEST_IMAGE2_PATH))
         t.save()
 
         test = TestImage.objects.first()
@@ -467,12 +573,10 @@ class FileTest(unittest.TestCase):
         Animal.drop_collection()
         marmot = Animal(genus='Marmota', family='Sciuridae')
 
-        marmot_photo = open(TEST_IMAGE_PATH, 'rb')  # Retrieve a photo from disk
-
-        photos_field = marmot._fields['photos'].field
-        new_proxy = photos_field.get_proxy_obj('photos', marmot)
-        new_proxy.put(marmot_photo, content_type='image/jpeg', foo='bar')
-        marmot_photo.close()
+        with open(TEST_IMAGE_PATH, 'rb') as marmot_photo:   # Retrieve a photo from disk
+            photos_field = marmot._fields['photos'].field
+            new_proxy = photos_field.get_proxy_obj('photos', marmot)
+            new_proxy.put(marmot_photo, content_type='image/jpeg', foo='bar')
 
         marmot.photos.append(new_proxy)
         marmot.save()
@@ -482,5 +586,6 @@ class FileTest(unittest.TestCase):
         self.assertEqual(marmot.photos[0].foo, 'bar')
         self.assertEqual(marmot.photos[0].get().length, 8313)
 
+
 if __name__ == '__main__':
     unittest.main()

tests/fields/geo.py

@@ -1,7 +1,4 @@
 # -*- coding: utf-8 -*-
-import sys
-sys.path[0:0] = [""]
-
 import unittest
 
 from mongoengine import *
@@ -19,8 +16,8 @@ class GeoFieldTest(unittest.TestCase):
     def _test_for_expected_error(self, Cls, loc, expected):
         try:
             Cls(loc=loc).validate()
-            self.fail()
-        except ValidationError, e:
+            self.fail('Should not validate the location {0}'.format(loc))
+        except ValidationError as e:
             self.assertEqual(expected, e.to_dict()['loc'])
 
     def test_geopoint_validation(self):
@@ -43,6 +40,11 @@ class GeoFieldTest(unittest.TestCase):
             expected = "Both values (%s) in point must be float or int" % repr(coord)
             self._test_for_expected_error(Location, coord, expected)
 
+        invalid_coords = [21, 4, 'a']
+        for coord in invalid_coords:
+            expected = "GeoPointField can only accept tuples or lists of (x, y)"
+            self._test_for_expected_error(Location, coord, expected)
+
     def test_point_validation(self):
         class Location(Document):
             loc = PointField()
@@ -115,7 +117,7 @@ class GeoFieldTest(unittest.TestCase):
             expected = "Invalid LineString:\nBoth values (%s) in point must be float or int" % repr(coord[0])
             self._test_for_expected_error(Location, coord, expected)
 
-        Location(loc=[[1, 2], [3, 4], [5, 6], [1,2]]).validate()
+        Location(loc=[[1, 2], [3, 4], [5, 6], [1, 2]]).validate()
 
     def test_polygon_validation(self):
         class Location(Document):
@@ -155,6 +157,117 @@ class GeoFieldTest(unittest.TestCase):
 
         Location(loc=[[[1, 2], [3, 4], [5, 6], [1, 2]]]).validate()
 
+    def test_multipoint_validation(self):
+        class Location(Document):
+            loc = MultiPointField()
+
+        invalid_coords = {"x": 1, "y": 2}
+        expected = 'MultiPointField can only accept a valid GeoJson dictionary or lists of (x, y)'
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = {"type": "MadeUp", "coordinates": [[]]}
+        expected = 'MultiPointField type must be "MultiPoint"'
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = {"type": "MultiPoint", "coordinates": [[1, 2, 3]]}
+        expected = "Value ([1, 2, 3]) must be a two-dimensional point"
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [[]]
+        expected = "Invalid MultiPoint must contain at least one valid point"
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [[[1]], [[1, 2, 3]]]
+        for coord in invalid_coords:
+            expected = "Value (%s) must be a two-dimensional point" % repr(coord[0])
+            self._test_for_expected_error(Location, coord, expected)
+
+        invalid_coords = [[[{}, {}]], [("a", "b")]]
+        for coord in invalid_coords:
+            expected = "Both values (%s) in point must be float or int" % repr(coord[0])
+            self._test_for_expected_error(Location, coord, expected)
+
+        Location(loc=[[1, 2]]).validate()
+        Location(loc={
+            "type": "MultiPoint",
+            "coordinates": [
+                [1, 2],
+                [81.4471435546875, 23.61432859499169]
+            ]}).validate()
+
+    def test_multilinestring_validation(self):
+        class Location(Document):
+            loc = MultiLineStringField()
+
+        invalid_coords = {"x": 1, "y": 2}
+        expected = 'MultiLineStringField can only accept a valid GeoJson dictionary or lists of (x, y)'
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = {"type": "MadeUp", "coordinates": [[]]}
+        expected = 'MultiLineStringField type must be "MultiLineString"'
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = {"type": "MultiLineString", "coordinates": [[[1, 2, 3]]]}
+        expected = "Invalid MultiLineString:\nValue ([1, 2, 3]) must be a two-dimensional point"
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [5, "a"]
+        expected = "Invalid MultiLineString must contain at least one valid linestring"
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [[[1]]]
+        expected = "Invalid MultiLineString:\nValue (%s) must be a two-dimensional point" % repr(invalid_coords[0][0])
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [[[1, 2, 3]]]
+        expected = "Invalid MultiLineString:\nValue (%s) must be a two-dimensional point" % repr(invalid_coords[0][0])
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [[[[{}, {}]]], [[("a", "b")]]]
+        for coord in invalid_coords:
+            expected = "Invalid MultiLineString:\nBoth values (%s) in point must be float or int" % repr(coord[0][0])
+            self._test_for_expected_error(Location, coord, expected)
+
+        Location(loc=[[[1, 2], [3, 4], [5, 6], [1, 2]]]).validate()
+
+    def test_multipolygon_validation(self):
+        class Location(Document):
+            loc = MultiPolygonField()
+
+        invalid_coords = {"x": 1, "y": 2}
+        expected = 'MultiPolygonField can only accept a valid GeoJson dictionary or lists of (x, y)'
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = {"type": "MadeUp", "coordinates": [[]]}
+        expected = 'MultiPolygonField type must be "MultiPolygon"'
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = {"type": "MultiPolygon", "coordinates": [[[[1, 2, 3]]]]}
+        expected = "Invalid MultiPolygon:\nValue ([1, 2, 3]) must be a two-dimensional point"
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [[[[5, "a"]]]]
+        expected = "Invalid MultiPolygon:\nBoth values ([5, 'a']) in point must be float or int"
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [[[[]]]]
+        expected = "Invalid MultiPolygon must contain at least one valid Polygon"
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [[[[1, 2, 3]]]]
+        expected = "Invalid MultiPolygon:\nValue ([1, 2, 3]) must be a two-dimensional point"
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [[[[{}, {}]]], [[("a", "b")]]]
+        expected = "Invalid MultiPolygon:\nBoth values ([{}, {}]) in point must be float or int, Both values (('a', 'b')) in point must be float or int"
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        invalid_coords = [[[[1, 2], [3, 4]]]]
+        expected = "Invalid MultiPolygon:\nLineStrings must start and end at the same point"
+        self._test_for_expected_error(Location, invalid_coords, expected)
+
+        Location(loc=[[[[1, 2], [3, 4], [5, 6], [1, 2]]]]).validate()
+
     def test_indexes_geopoint(self):
         """Ensure that indexes are created automatically for GeoPointFields.
         """
@@ -190,9 +303,9 @@ class GeoFieldTest(unittest.TestCase):
             polygon = PolygonField()
 
         geo_indicies = Event._geo_indices()
-        self.assertTrue({'fields': [('line', '2dsphere')]} in geo_indicies)
-        self.assertTrue({'fields': [('polygon', '2dsphere')]} in geo_indicies)
-        self.assertTrue({'fields': [('point', '2dsphere')]} in geo_indicies)
+        self.assertIn({'fields': [('line', '2dsphere')]}, geo_indicies)
+        self.assertIn({'fields': [('polygon', '2dsphere')]}, geo_indicies)
+        self.assertIn({'fields': [('point', '2dsphere')]}, geo_indicies)
 
     def test_indexes_2dsphere_embedded(self):
         """Ensure that indexes are created automatically for GeoPointFields.
@@ -208,9 +321,9 @@ class GeoFieldTest(unittest.TestCase):
             venue = EmbeddedDocumentField(Venue)
 
         geo_indicies = Event._geo_indices()
-        self.assertTrue({'fields': [('venue.line', '2dsphere')]} in geo_indicies)
-        self.assertTrue({'fields': [('venue.polygon', '2dsphere')]} in geo_indicies)
-        self.assertTrue({'fields': [('venue.point', '2dsphere')]} in geo_indicies)
+        self.assertIn({'fields': [('venue.line', '2dsphere')]}, geo_indicies)
+        self.assertIn({'fields': [('venue.polygon', '2dsphere')]}, geo_indicies)
+        self.assertIn({'fields': [('venue.point', '2dsphere')]}, geo_indicies)
 
     def test_geo_indexes_recursion(self):
 
@@ -225,12 +338,11 @@ class GeoFieldTest(unittest.TestCase):
         Location.drop_collection()
         Parent.drop_collection()
 
-        list(Parent.objects)
-
-        collection = Parent._get_collection()
-        info = collection.index_information()
-
-        self.assertFalse('location_2d' in info)
+        Parent(name='Berlin').save()
+        info = Parent._get_collection().index_information()
+        self.assertNotIn('location_2d', info)
+        info = Location._get_collection().index_information()
+        self.assertIn('location_2d', info)
 
         self.assertEqual(len(Parent._geo_indices()), 0)
         self.assertEqual(len(Location._geo_indices()), 1)

tests/fields/test_binary_field.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+import uuid
+
+from nose.plugins.skip import SkipTest
+import six
+
+from bson import Binary
+
+from mongoengine import *
+from tests.utils import MongoDBTestCase
+
+BIN_VALUE = six.b('\xa9\xf3\x8d(\xd7\x03\x84\xb4k[\x0f\xe3\xa2\x19\x85p[J\xa3\xd2>\xde\xe6\x87\xb1\x7f\xc6\xe6\xd9r\x18\xf5')
+
+
+class TestBinaryField(MongoDBTestCase):
+    def test_binary_fields(self):
+        """Ensure that binary fields can be stored and retrieved.
+        """
+        class Attachment(Document):
+            content_type = StringField()
+            blob = BinaryField()
+
+        BLOB = six.b('\xe6\x00\xc4\xff\x07')
+        MIME_TYPE = 'application/octet-stream'
+
+        Attachment.drop_collection()
+
+        attachment = Attachment(content_type=MIME_TYPE, blob=BLOB)
+        attachment.save()
+
+        attachment_1 = Attachment.objects().first()
+        self.assertEqual(MIME_TYPE, attachment_1.content_type)
+        self.assertEqual(BLOB, six.binary_type(attachment_1.blob))
+
+    def test_validation_succeeds(self):
+        """Ensure that valid values can be assigned to binary fields.
+        """
+        class AttachmentRequired(Document):
+            blob = BinaryField(required=True)
+
+        class AttachmentSizeLimit(Document):
+            blob = BinaryField(max_bytes=4)
+
+        attachment_required = AttachmentRequired()
+        self.assertRaises(ValidationError, attachment_required.validate)
+        attachment_required.blob = Binary(six.b('\xe6\x00\xc4\xff\x07'))
+        attachment_required.validate()
+
+        _5_BYTES = six.b('\xe6\x00\xc4\xff\x07')
+        _4_BYTES = six.b('\xe6\x00\xc4\xff')
+        self.assertRaises(ValidationError, AttachmentSizeLimit(blob=_5_BYTES).validate)
+        AttachmentSizeLimit(blob=_4_BYTES).validate()
+
+    def test_validation_fails(self):
+        """Ensure that invalid values cannot be assigned to binary fields."""
+
+        class Attachment(Document):
+            blob = BinaryField()
+
+        for invalid_data in (2, u'Im_a_unicode', ['some_str']):
+            self.assertRaises(ValidationError, Attachment(blob=invalid_data).validate)
+
+    def test__primary(self):
+        class Attachment(Document):
+            id = BinaryField(primary_key=True)
+
+        Attachment.drop_collection()
+        binary_id = uuid.uuid4().bytes
+        att = Attachment(id=binary_id).save()
+        self.assertEqual(1, Attachment.objects.count())
+        self.assertEqual(1, Attachment.objects.filter(id=att.id).count())
+        att.delete()
+        self.assertEqual(0, Attachment.objects.count())
+
+    def test_primary_filter_by_binary_pk_as_str(self):
+        raise SkipTest("Querying by id as string is not currently supported")
+
+        class Attachment(Document):
+            id = BinaryField(primary_key=True)
+
+        Attachment.drop_collection()
+        binary_id = uuid.uuid4().bytes
+        att = Attachment(id=binary_id).save()
+        self.assertEqual(1, Attachment.objects.filter(id=binary_id).count())
+        att.delete()
+        self.assertEqual(0, Attachment.objects.count())
+
+    def test_match_querying_with_bytes(self):
+        class MyDocument(Document):
+            bin_field = BinaryField()
+
+        MyDocument.drop_collection()
+
+        doc = MyDocument(bin_field=BIN_VALUE).save()
+        matched_doc = MyDocument.objects(bin_field=BIN_VALUE).first()
+        self.assertEqual(matched_doc.id, doc.id)
+
+    def test_match_querying_with_binary(self):
+        class MyDocument(Document):
+            bin_field = BinaryField()
+
+        MyDocument.drop_collection()
+
+        doc = MyDocument(bin_field=BIN_VALUE).save()
+
+        matched_doc = MyDocument.objects(bin_field=Binary(BIN_VALUE)).first()
+        self.assertEqual(matched_doc.id, doc.id)
+
+    def test_modify_operation__set(self):
+        """Ensures no regression of bug #1127"""
+        class MyDocument(Document):
+            some_field = StringField()
+            bin_field = BinaryField()
+
+        MyDocument.drop_collection()
+
+        doc = MyDocument.objects(some_field='test').modify(
+            upsert=True, new=True,
+            set__bin_field=BIN_VALUE
+        )
+        self.assertEqual(doc.some_field, 'test')
+        if six.PY3:
+            self.assertEqual(doc.bin_field, BIN_VALUE)
+        else:
+            self.assertEqual(doc.bin_field, Binary(BIN_VALUE))
+
+    def test_update_one(self):
+        """Ensures no regression of bug #1127"""
+        class MyDocument(Document):
+            bin_field = BinaryField()
+
+        MyDocument.drop_collection()
+
+        bin_data = six.b('\xe6\x00\xc4\xff\x07')
+        doc = MyDocument(bin_field=bin_data).save()
+
+        n_updated = MyDocument.objects(bin_field=bin_data).update_one(bin_field=BIN_VALUE)
+        self.assertEqual(n_updated, 1)
+        fetched = MyDocument.objects.with_id(doc.id)
+        if six.PY3:
+            self.assertEqual(fetched.bin_field, BIN_VALUE)
+        else:
+            self.assertEqual(fetched.bin_field, Binary(BIN_VALUE))

tests/fields/test_boolean_field.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+from mongoengine import *
+
+from tests.utils import MongoDBTestCase, get_as_pymongo
+
+
+class TestBooleanField(MongoDBTestCase):
+    def test_storage(self):
+        class Person(Document):
+            admin = BooleanField()
+
+        person = Person(admin=True)
+        person.save()
+        self.assertEqual(
+            get_as_pymongo(person),
+            {'_id': person.id,
+             'admin': True})
+
+    def test_validation(self):
+        """Ensure that invalid values cannot be assigned to boolean
+        fields.
+        """
+        class Person(Document):
+            admin = BooleanField()
+
+        person = Person()
+        person.admin = True
+        person.validate()
+
+        person.admin = 2
+        self.assertRaises(ValidationError, person.validate)
+        person.admin = 'Yes'
+        self.assertRaises(ValidationError, person.validate)
+        person.admin = 'False'
+        self.assertRaises(ValidationError, person.validate)
+
+    def test_weirdness_constructor(self):
+        """When attribute is set in contructor, it gets cast into a bool
+        which causes some weird behavior. We dont necessarily want to maintain this behavior
+        but its a known issue
+        """
+        class Person(Document):
+            admin = BooleanField()
+
+        new_person = Person(admin='False')
+        self.assertTrue(new_person.admin)
+
+        new_person = Person(admin='0')
+        self.assertTrue(new_person.admin)

tests/fields/test_cached_reference_field.py

@@ -0,0 +1,446 @@
+# -*- coding: utf-8 -*-
+from decimal import Decimal
+
+from mongoengine import *
+
+from tests.utils import MongoDBTestCase
+
+
+class TestCachedReferenceField(MongoDBTestCase):
+
+    def test_get_and_save(self):
+        """
+        Tests #1047: CachedReferenceField creates DBRefs on to_python,
+        but can't save them on to_mongo.
+        """
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocorrence(Document):
+            person = StringField()
+            animal = CachedReferenceField(Animal)
+
+        Animal.drop_collection()
+        Ocorrence.drop_collection()
+
+        Ocorrence(person="testte",
+                  animal=Animal(name="Leopard", tag="heavy").save()).save()
+        p = Ocorrence.objects.get()
+        p.person = 'new_testte'
+        p.save()
+
+    def test_general_things(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocorrence(Document):
+            person = StringField()
+            animal = CachedReferenceField(
+                Animal, fields=['tag'])
+
+        Animal.drop_collection()
+        Ocorrence.drop_collection()
+
+        a = Animal(name="Leopard", tag="heavy")
+        a.save()
+
+        self.assertEqual(Animal._cached_reference_fields, [Ocorrence.animal])
+        o = Ocorrence(person="teste", animal=a)
+        o.save()
+
+        p = Ocorrence(person="Wilson")
+        p.save()
+
+        self.assertEqual(Ocorrence.objects(animal=None).count(), 1)
+
+        self.assertEqual(
+            a.to_mongo(fields=['tag']), {'tag': 'heavy', "_id": a.pk})
+
+        self.assertEqual(o.to_mongo()['animal']['tag'], 'heavy')
+
+        # counts
+        Ocorrence(person="teste 2").save()
+        Ocorrence(person="teste 3").save()
+
+        count = Ocorrence.objects(animal__tag='heavy').count()
+        self.assertEqual(count, 1)
+
+        ocorrence = Ocorrence.objects(animal__tag='heavy').first()
+        self.assertEqual(ocorrence.person, "teste")
+        self.assertIsInstance(ocorrence.animal, Animal)
+
+    def test_with_decimal(self):
+        class PersonAuto(Document):
+            name = StringField()
+            salary = DecimalField()
+
+        class SocialTest(Document):
+            group = StringField()
+            person = CachedReferenceField(
+                PersonAuto,
+                fields=('salary',))
+
+        PersonAuto.drop_collection()
+        SocialTest.drop_collection()
+
+        p = PersonAuto(name="Alberto", salary=Decimal('7000.00'))
+        p.save()
+
+        s = SocialTest(group="dev", person=p)
+        s.save()
+
+        self.assertEqual(
+            SocialTest.objects._collection.find_one({'person.salary': 7000.00}), {
+                '_id': s.pk,
+                'group': s.group,
+                'person': {
+                    '_id': p.pk,
+                    'salary': 7000.00
+                }
+            })
+
+    def test_cached_reference_field_reference(self):
+        class Group(Document):
+            name = StringField()
+
+        class Person(Document):
+            name = StringField()
+            group = ReferenceField(Group)
+
+        class SocialData(Document):
+            obs = StringField()
+            tags = ListField(
+                StringField())
+            person = CachedReferenceField(
+                Person,
+                fields=('group',))
+
+        Group.drop_collection()
+        Person.drop_collection()
+        SocialData.drop_collection()
+
+        g1 = Group(name='dev')
+        g1.save()
+
+        g2 = Group(name="designers")
+        g2.save()
+
+        p1 = Person(name="Alberto", group=g1)
+        p1.save()
+
+        p2 = Person(name="Andre", group=g1)
+        p2.save()
+
+        p3 = Person(name="Afro design", group=g2)
+        p3.save()
+
+        s1 = SocialData(obs="testing 123", person=p1, tags=['tag1', 'tag2'])
+        s1.save()
+
+        s2 = SocialData(obs="testing 321", person=p3, tags=['tag3', 'tag4'])
+        s2.save()
+
+        self.assertEqual(SocialData.objects._collection.find_one(
+            {'tags': 'tag2'}), {
+                '_id': s1.pk,
+                'obs': 'testing 123',
+                'tags': ['tag1', 'tag2'],
+                'person': {
+                    '_id': p1.pk,
+                    'group': g1.pk
+                }
+        })
+
+        self.assertEqual(SocialData.objects(person__group=g2).count(), 1)
+        self.assertEqual(SocialData.objects(person__group=g2).first(), s2)
+
+    def test_cached_reference_field_push_with_fields(self):
+        class Product(Document):
+            name = StringField()
+
+        Product.drop_collection()
+
+        class Basket(Document):
+            products = ListField(CachedReferenceField(Product, fields=['name']))
+
+        Basket.drop_collection()
+        product1 = Product(name='abc').save()
+        product2 = Product(name='def').save()
+        basket = Basket(products=[product1]).save()
+        self.assertEqual(
+            Basket.objects._collection.find_one(),
+            {
+                '_id': basket.pk,
+                'products': [
+                    {
+                        '_id': product1.pk,
+                        'name': product1.name
+                    }
+                ]
+            }
+        )
+        # push to list
+        basket.update(push__products=product2)
+        basket.reload()
+        self.assertEqual(
+            Basket.objects._collection.find_one(),
+            {
+                '_id': basket.pk,
+                'products': [
+                    {
+                        '_id': product1.pk,
+                        'name': product1.name
+                    },
+                    {
+                        '_id': product2.pk,
+                        'name': product2.name
+                    }
+                ]
+            }
+        )
+
+    def test_cached_reference_field_update_all(self):
+        class Person(Document):
+            TYPES = (
+                ('pf', "PF"),
+                ('pj', "PJ")
+            )
+            name = StringField()
+            tp = StringField(choices=TYPES)
+            father = CachedReferenceField('self', fields=('tp',))
+
+        Person.drop_collection()
+
+        a1 = Person(name="Wilson Father", tp="pj")
+        a1.save()
+
+        a2 = Person(name='Wilson Junior', tp='pf', father=a1)
+        a2.save()
+
+        a2 = Person.objects.with_id(a2.id)
+        self.assertEqual(a2.father.tp, a1.tp)
+
+        self.assertEqual(dict(a2.to_mongo()), {
+            "_id": a2.pk,
+            "name": u"Wilson Junior",
+            "tp": u"pf",
+            "father": {
+                "_id": a1.pk,
+                "tp": u"pj"
+            }
+        })
+
+        self.assertEqual(Person.objects(father=a1)._query, {
+            'father._id': a1.pk
+        })
+        self.assertEqual(Person.objects(father=a1).count(), 1)
+
+        Person.objects.update(set__tp="pf")
+        Person.father.sync_all()
+
+        a2.reload()
+        self.assertEqual(dict(a2.to_mongo()), {
+            "_id": a2.pk,
+            "name": u"Wilson Junior",
+            "tp": u"pf",
+            "father": {
+                "_id": a1.pk,
+                "tp": u"pf"
+            }
+        })
+
+    def test_cached_reference_fields_on_embedded_documents(self):
+        with self.assertRaises(InvalidDocumentError):
+            class Test(Document):
+                name = StringField()
+
+            type('WrongEmbeddedDocument', (
+                EmbeddedDocument,), {
+                    'test': CachedReferenceField(Test)
+            })
+
+    def test_cached_reference_auto_sync(self):
+        class Person(Document):
+            TYPES = (
+                ('pf', "PF"),
+                ('pj', "PJ")
+            )
+            name = StringField()
+            tp = StringField(
+                choices=TYPES
+            )
+
+            father = CachedReferenceField('self', fields=('tp',))
+
+        Person.drop_collection()
+
+        a1 = Person(name="Wilson Father", tp="pj")
+        a1.save()
+
+        a2 = Person(name='Wilson Junior', tp='pf', father=a1)
+        a2.save()
+
+        a1.tp = 'pf'
+        a1.save()
+
+        a2.reload()
+        self.assertEqual(dict(a2.to_mongo()), {
+            '_id': a2.pk,
+            'name': 'Wilson Junior',
+            'tp': 'pf',
+            'father': {
+                '_id': a1.pk,
+                'tp': 'pf'
+            }
+        })
+
+    def test_cached_reference_auto_sync_disabled(self):
+        class Persone(Document):
+            TYPES = (
+                ('pf', "PF"),
+                ('pj', "PJ")
+            )
+            name = StringField()
+            tp = StringField(
+                choices=TYPES
+            )
+
+            father = CachedReferenceField(
+                'self', fields=('tp',), auto_sync=False)
+
+        Persone.drop_collection()
+
+        a1 = Persone(name="Wilson Father", tp="pj")
+        a1.save()
+
+        a2 = Persone(name='Wilson Junior', tp='pf', father=a1)
+        a2.save()
+
+        a1.tp = 'pf'
+        a1.save()
+
+        self.assertEqual(Persone.objects._collection.find_one({'_id': a2.pk}), {
+            '_id': a2.pk,
+            'name': 'Wilson Junior',
+            'tp': 'pf',
+            'father': {
+                '_id': a1.pk,
+                'tp': 'pj'
+            }
+        })
+
+    def test_cached_reference_embedded_fields(self):
+        class Owner(EmbeddedDocument):
+            TPS = (
+                ('n', "Normal"),
+                ('u', "Urgent")
+            )
+            name = StringField()
+            tp = StringField(
+                verbose_name="Type",
+                db_field="t",
+                choices=TPS)
+
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+            owner = EmbeddedDocumentField(Owner)
+
+        class Ocorrence(Document):
+            person = StringField()
+            animal = CachedReferenceField(
+                Animal, fields=['tag', 'owner.tp'])
+
+        Animal.drop_collection()
+        Ocorrence.drop_collection()
+
+        a = Animal(name="Leopard", tag="heavy",
+                   owner=Owner(tp='u', name="Wilson Júnior")
+                   )
+        a.save()
+
+        o = Ocorrence(person="teste", animal=a)
+        o.save()
+        self.assertEqual(dict(a.to_mongo(fields=['tag', 'owner.tp'])), {
+            '_id': a.pk,
+            'tag': 'heavy',
+            'owner': {
+                't': 'u'
+            }
+        })
+        self.assertEqual(o.to_mongo()['animal']['tag'], 'heavy')
+        self.assertEqual(o.to_mongo()['animal']['owner']['t'], 'u')
+
+        # Check to_mongo with fields
+        self.assertNotIn('animal', o.to_mongo(fields=['person']))
+
+        # counts
+        Ocorrence(person="teste 2").save()
+        Ocorrence(person="teste 3").save()
+
+        count = Ocorrence.objects(
+            animal__tag='heavy', animal__owner__tp='u').count()
+        self.assertEqual(count, 1)
+
+        ocorrence = Ocorrence.objects(
+            animal__tag='heavy',
+            animal__owner__tp='u').first()
+        self.assertEqual(ocorrence.person, "teste")
+        self.assertIsInstance(ocorrence.animal, Animal)
+
+    def test_cached_reference_embedded_list_fields(self):
+        class Owner(EmbeddedDocument):
+            name = StringField()
+            tags = ListField(StringField())
+
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+            owner = EmbeddedDocumentField(Owner)
+
+        class Ocorrence(Document):
+            person = StringField()
+            animal = CachedReferenceField(
+                Animal, fields=['tag', 'owner.tags'])
+
+        Animal.drop_collection()
+        Ocorrence.drop_collection()
+
+        a = Animal(name="Leopard", tag="heavy",
+                   owner=Owner(tags=['cool', 'funny'],
+                               name="Wilson Júnior")
+                   )
+        a.save()
+
+        o = Ocorrence(person="teste 2", animal=a)
+        o.save()
+        self.assertEqual(dict(a.to_mongo(fields=['tag', 'owner.tags'])), {
+            '_id': a.pk,
+            'tag': 'heavy',
+            'owner': {
+                'tags': ['cool', 'funny']
+            }
+        })
+
+        self.assertEqual(o.to_mongo()['animal']['tag'], 'heavy')
+        self.assertEqual(o.to_mongo()['animal']['owner']['tags'],
+                         ['cool', 'funny'])
+
+        # counts
+        Ocorrence(person="teste 2").save()
+        Ocorrence(person="teste 3").save()
+
+        query = Ocorrence.objects(
+            animal__tag='heavy', animal__owner__tags='cool')._query
+        self.assertEqual(
+            query, {'animal.owner.tags': 'cool', 'animal.tag': 'heavy'})
+
+        ocorrence = Ocorrence.objects(
+            animal__tag='heavy',
+            animal__owner__tags='cool').first()
+        self.assertEqual(ocorrence.person, "teste 2")
+        self.assertIsInstance(ocorrence.animal, Animal)

tests/fields/test_complex_datetime_field.py

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+import datetime
+import math
+import itertools
+import re
+
+from mongoengine import *
+
+from tests.utils import MongoDBTestCase
+
+
+class ComplexDateTimeFieldTest(MongoDBTestCase):
+    def test_complexdatetime_storage(self):
+        """Tests for complex datetime fields - which can handle
+        microseconds without rounding.
+        """
+        class LogEntry(Document):
+            date = ComplexDateTimeField()
+            date_with_dots = ComplexDateTimeField(separator='.')
+
+        LogEntry.drop_collection()
+
+        # Post UTC - microseconds are rounded (down) nearest millisecond and
+        # dropped - with default datetimefields
+        d1 = datetime.datetime(1970, 1, 1, 0, 0, 1, 999)
+        log = LogEntry()
+        log.date = d1
+        log.save()
+        log.reload()
+        self.assertEqual(log.date, d1)
+
+        # Post UTC - microseconds are rounded (down) nearest millisecond - with
+        # default datetimefields
+        d1 = datetime.datetime(1970, 1, 1, 0, 0, 1, 9999)
+        log.date = d1
+        log.save()
+        log.reload()
+        self.assertEqual(log.date, d1)
+
+        # Pre UTC dates microseconds below 1000 are dropped - with default
+        # datetimefields
+        d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999)
+        log.date = d1
+        log.save()
+        log.reload()
+        self.assertEqual(log.date, d1)
+
+        # Pre UTC microseconds above 1000 is wonky - with default datetimefields
+        # log.date has an invalid microsecond value so I can't construct
+        # a date to compare.
+        for i in range(1001, 3113, 33):
+            d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, i)
+            log.date = d1
+            log.save()
+            log.reload()
+            self.assertEqual(log.date, d1)
+            log1 = LogEntry.objects.get(date=d1)
+            self.assertEqual(log, log1)
+
+        # Test string padding
+        microsecond = map(int, [math.pow(10, x) for x in range(6)])
+        mm = dd = hh = ii = ss = [1, 10]
+
+        for values in itertools.product([2014], mm, dd, hh, ii, ss, microsecond):
+            stored = LogEntry(date=datetime.datetime(*values)).to_mongo()['date']
+            self.assertTrue(re.match('^\d{4},\d{2},\d{2},\d{2},\d{2},\d{2},\d{6}$', stored) is not None)
+
+        # Test separator
+        stored = LogEntry(date_with_dots=datetime.datetime(2014, 1, 1)).to_mongo()['date_with_dots']
+        self.assertTrue(re.match('^\d{4}.\d{2}.\d{2}.\d{2}.\d{2}.\d{2}.\d{6}$', stored) is not None)
+
+    def test_complexdatetime_usage(self):
+        """Tests for complex datetime fields - which can handle
+        microseconds without rounding.
+        """
+        class LogEntry(Document):
+            date = ComplexDateTimeField()
+
+        LogEntry.drop_collection()
+
+        d1 = datetime.datetime(1950, 1, 1, 0, 0, 1, 999)
+        log = LogEntry()
+        log.date = d1
+        log.save()
+
+        log1 = LogEntry.objects.get(date=d1)
+        self.assertEqual(log, log1)
+
+        # create extra 59 log entries for a total of 60
+        for i in range(1951, 2010):
+            d = datetime.datetime(i, 1, 1, 0, 0, 1, 999)
+            LogEntry(date=d).save()
+
+        self.assertEqual(LogEntry.objects.count(), 60)
+
+        # Test ordering
+        logs = LogEntry.objects.order_by("date")
+        i = 0
+        while i < 59:
+            self.assertTrue(logs[i].date <= logs[i + 1].date)
+            i += 1
+
+        logs = LogEntry.objects.order_by("-date")
+        i = 0
+        while i < 59:
+            self.assertTrue(logs[i].date >= logs[i + 1].date)
+            i += 1
+
+        # Test searching
+        logs = LogEntry.objects.filter(date__gte=datetime.datetime(1980, 1, 1))
+        self.assertEqual(logs.count(), 30)
+
+        logs = LogEntry.objects.filter(date__lte=datetime.datetime(1980, 1, 1))
+        self.assertEqual(logs.count(), 30)
+
+        logs = LogEntry.objects.filter(
+            date__lte=datetime.datetime(2011, 1, 1),
+            date__gte=datetime.datetime(2000, 1, 1),
+        )
+        self.assertEqual(logs.count(), 10)
+
+        LogEntry.drop_collection()
+
+        # Test microsecond-level ordering/filtering
+        for microsecond in (99, 999, 9999, 10000):
+            LogEntry(
+                date=datetime.datetime(2015, 1, 1, 0, 0, 0, microsecond)
+            ).save()
+
+        logs = list(LogEntry.objects.order_by('date'))
+        for next_idx, log in enumerate(logs[:-1], start=1):
+            next_log = logs[next_idx]
+            self.assertTrue(log.date < next_log.date)
+
+        logs = list(LogEntry.objects.order_by('-date'))
+        for next_idx, log in enumerate(logs[:-1], start=1):
+            next_log = logs[next_idx]
+            self.assertTrue(log.date > next_log.date)
+
+        logs = LogEntry.objects.filter(
+            date__lte=datetime.datetime(2015, 1, 1, 0, 0, 0, 10000))
+        self.assertEqual(logs.count(), 4)
+
+    def test_no_default_value(self):
+        class Log(Document):
+            timestamp = ComplexDateTimeField()
+
+        Log.drop_collection()
+
+        log = Log()
+        self.assertIsNone(log.timestamp)
+        log.save()
+
+        fetched_log = Log.objects.with_id(log.id)
+        self.assertIsNone(fetched_log.timestamp)
+
+    def test_default_static_value(self):
+        NOW = datetime.datetime.utcnow()
+        class Log(Document):
+            timestamp = ComplexDateTimeField(default=NOW)
+
+        Log.drop_collection()
+
+        log = Log()
+        self.assertEqual(log.timestamp, NOW)
+        log.save()
+
+        fetched_log = Log.objects.with_id(log.id)
+        self.assertEqual(fetched_log.timestamp, NOW)
+
+    def test_default_callable(self):
+        NOW = datetime.datetime.utcnow()
+
+        class Log(Document):
+            timestamp = ComplexDateTimeField(default=datetime.datetime.utcnow)
+
+        Log.drop_collection()
+
+        log = Log()
+        self.assertGreaterEqual(log.timestamp, NOW)
+        log.save()
+
+        fetched_log = Log.objects.with_id(log.id)
+        self.assertGreaterEqual(fetched_log.timestamp, NOW)

tests/fields/test_date_field.py

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+import datetime
+import six
+
+try:
+    import dateutil
+except ImportError:
+    dateutil = None
+
+from mongoengine import *
+
+from tests.utils import MongoDBTestCase
+
+
+class TestDateField(MongoDBTestCase):
+    def test_date_from_empty_string(self):
+        """
+        Ensure an exception is raised when trying to
+        cast an empty string to datetime.
+        """
+        class MyDoc(Document):
+            dt = DateField()
+
+        md = MyDoc(dt='')
+        self.assertRaises(ValidationError, md.save)
+
+    def test_date_from_whitespace_string(self):
+        """
+        Ensure an exception is raised when trying to
+        cast a whitespace-only string to datetime.
+        """
+        class MyDoc(Document):
+            dt = DateField()
+
+        md = MyDoc(dt='   ')
+        self.assertRaises(ValidationError, md.save)
+
+    def test_default_values_today(self):
+        """Ensure that default field values are used when creating
+        a document.
+        """
+        class Person(Document):
+            day = DateField(default=datetime.date.today)
+
+        person = Person()
+        person.validate()
+        self.assertEqual(person.day, person.day)
+        self.assertEqual(person.day, datetime.date.today())
+        self.assertEqual(person._data['day'], person.day)
+
+    def test_date(self):
+        """Tests showing pymongo date fields
+
+        See: http://api.mongodb.org/python/current/api/bson/son.html#dt
+        """
+        class LogEntry(Document):
+            date = DateField()
+
+        LogEntry.drop_collection()
+
+        # Test can save dates
+        log = LogEntry()
+        log.date = datetime.date.today()
+        log.save()
+        log.reload()
+        self.assertEqual(log.date, datetime.date.today())
+
+        d1 = datetime.datetime(1970, 1, 1, 0, 0, 1, 999)
+        d2 = datetime.datetime(1970, 1, 1, 0, 0, 1)
+        log = LogEntry()
+        log.date = d1
+        log.save()
+        log.reload()
+        self.assertEqual(log.date, d1.date())
+        self.assertEqual(log.date, d2.date())
+
+        d1 = datetime.datetime(1970, 1, 1, 0, 0, 1, 9999)
+        d2 = datetime.datetime(1970, 1, 1, 0, 0, 1, 9000)
+        log.date = d1
+        log.save()
+        log.reload()
+        self.assertEqual(log.date, d1.date())
+        self.assertEqual(log.date, d2.date())
+
+        if not six.PY3:
+            # Pre UTC dates microseconds below 1000 are dropped
+            # This does not seem to be true in PY3
+            d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999)
+            d2 = datetime.datetime(1969, 12, 31, 23, 59, 59)
+            log.date = d1
+            log.save()
+            log.reload()
+            self.assertEqual(log.date, d1.date())
+            self.assertEqual(log.date, d2.date())
+
+    def test_regular_usage(self):
+        """Tests for regular datetime fields"""
+        class LogEntry(Document):
+            date = DateField()
+
+        LogEntry.drop_collection()
+
+        d1 = datetime.datetime(1970, 1, 1, 0, 0, 1)
+        log = LogEntry()
+        log.date = d1
+        log.validate()
+        log.save()
+
+        for query in (d1, d1.isoformat(' ')):
+            log1 = LogEntry.objects.get(date=query)
+            self.assertEqual(log, log1)
+
+        if dateutil:
+            log1 = LogEntry.objects.get(date=d1.isoformat('T'))
+            self.assertEqual(log, log1)
+
+        # create additional 19 log entries for a total of 20
+        for i in range(1971, 1990):
+            d = datetime.datetime(i, 1, 1, 0, 0, 1)
+            LogEntry(date=d).save()
+
+        self.assertEqual(LogEntry.objects.count(), 20)
+
+        # Test ordering
+        logs = LogEntry.objects.order_by("date")
+        i = 0
+        while i < 19:
+            self.assertTrue(logs[i].date <= logs[i + 1].date)
+            i += 1
+
+        logs = LogEntry.objects.order_by("-date")
+        i = 0
+        while i < 19:
+            self.assertTrue(logs[i].date >= logs[i + 1].date)
+            i += 1
+
+        # Test searching
+        logs = LogEntry.objects.filter(date__gte=datetime.datetime(1980, 1, 1))
+        self.assertEqual(logs.count(), 10)
+
+    def test_validation(self):
+        """Ensure that invalid values cannot be assigned to datetime
+        fields.
+        """
+        class LogEntry(Document):
+            time = DateField()
+
+        log = LogEntry()
+        log.time = datetime.datetime.now()
+        log.validate()
+
+        log.time = datetime.date.today()
+        log.validate()
+
+        log.time = datetime.datetime.now().isoformat(' ')
+        log.validate()
+
+        if dateutil:
+            log.time = datetime.datetime.now().isoformat('T')
+            log.validate()
+
+        log.time = -1
+        self.assertRaises(ValidationError, log.validate)
+        log.time = 'ABC'
+        self.assertRaises(ValidationError, log.validate)

tests/fields/test_datetime_field.py

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+import datetime as dt
+import six
+
+try:
+    import dateutil
+except ImportError:
+    dateutil = None
+
+from mongoengine import *
+from mongoengine import connection
+
+from tests.utils import MongoDBTestCase
+
+
+class TestDateTimeField(MongoDBTestCase):
+    def test_datetime_from_empty_string(self):
+        """
+        Ensure an exception is raised when trying to
+        cast an empty string to datetime.
+        """
+        class MyDoc(Document):
+            dt = DateTimeField()
+
+        md = MyDoc(dt='')
+        self.assertRaises(ValidationError, md.save)
+
+    def test_datetime_from_whitespace_string(self):
+        """
+        Ensure an exception is raised when trying to
+        cast a whitespace-only string to datetime.
+        """
+        class MyDoc(Document):
+            dt = DateTimeField()
+
+        md = MyDoc(dt='   ')
+        self.assertRaises(ValidationError, md.save)
+
+    def test_default_value_utcnow(self):
+        """Ensure that default field values are used when creating
+        a document.
+        """
+        class Person(Document):
+            created = DateTimeField(default=dt.datetime.utcnow)
+
+        utcnow = dt.datetime.utcnow()
+        person = Person()
+        person.validate()
+        person_created_t0 = person.created
+        self.assertLess(person.created - utcnow, dt.timedelta(seconds=1))
+        self.assertEqual(person_created_t0, person.created)  # make sure it does not change
+        self.assertEqual(person._data['created'], person.created)
+
+    def test_handling_microseconds(self):
+        """Tests showing pymongo datetime fields handling of microseconds.
+        Microseconds are rounded to the nearest millisecond and pre UTC
+        handling is wonky.
+
+        See: http://api.mongodb.org/python/current/api/bson/son.html#dt
+        """
+        class LogEntry(Document):
+            date = DateTimeField()
+
+        LogEntry.drop_collection()
+
+        # Test can save dates
+        log = LogEntry()
+        log.date = dt.date.today()
+        log.save()
+        log.reload()
+        self.assertEqual(log.date.date(), dt.date.today())
+
+        # Post UTC - microseconds are rounded (down) nearest millisecond and
+        # dropped
+        d1 = dt.datetime(1970, 1, 1, 0, 0, 1, 999)
+        d2 = dt.datetime(1970, 1, 1, 0, 0, 1)
+        log = LogEntry()
+        log.date = d1
+        log.save()
+        log.reload()
+        self.assertNotEqual(log.date, d1)
+        self.assertEqual(log.date, d2)
+
+        # Post UTC - microseconds are rounded (down) nearest millisecond
+        d1 = dt.datetime(1970, 1, 1, 0, 0, 1, 9999)
+        d2 = dt.datetime(1970, 1, 1, 0, 0, 1, 9000)
+        log.date = d1
+        log.save()
+        log.reload()
+        self.assertNotEqual(log.date, d1)
+        self.assertEqual(log.date, d2)
+
+        if not six.PY3:
+            # Pre UTC dates microseconds below 1000 are dropped
+            # This does not seem to be true in PY3
+            d1 = dt.datetime(1969, 12, 31, 23, 59, 59, 999)
+            d2 = dt.datetime(1969, 12, 31, 23, 59, 59)
+            log.date = d1
+            log.save()
+            log.reload()
+            self.assertNotEqual(log.date, d1)
+            self.assertEqual(log.date, d2)
+
+    def test_regular_usage(self):
+        """Tests for regular datetime fields"""
+        class LogEntry(Document):
+            date = DateTimeField()
+
+        LogEntry.drop_collection()
+
+        d1 = dt.datetime(1970, 1, 1, 0, 0, 1)
+        log = LogEntry()
+        log.date = d1
+        log.validate()
+        log.save()
+
+        for query in (d1, d1.isoformat(' ')):
+            log1 = LogEntry.objects.get(date=query)
+            self.assertEqual(log, log1)
+
+        if dateutil:
+            log1 = LogEntry.objects.get(date=d1.isoformat('T'))
+            self.assertEqual(log, log1)
+
+        # create additional 19 log entries for a total of 20
+        for i in range(1971, 1990):
+            d = dt.datetime(i, 1, 1, 0, 0, 1)
+            LogEntry(date=d).save()
+
+        self.assertEqual(LogEntry.objects.count(), 20)
+
+        # Test ordering
+        logs = LogEntry.objects.order_by("date")
+        i = 0
+        while i < 19:
+            self.assertTrue(logs[i].date <= logs[i + 1].date)
+            i += 1
+
+        logs = LogEntry.objects.order_by("-date")
+        i = 0
+        while i < 19:
+            self.assertTrue(logs[i].date >= logs[i + 1].date)
+            i += 1
+
+        # Test searching
+        logs = LogEntry.objects.filter(date__gte=dt.datetime(1980, 1, 1))
+        self.assertEqual(logs.count(), 10)
+
+        logs = LogEntry.objects.filter(date__lte=dt.datetime(1980, 1, 1))
+        self.assertEqual(logs.count(), 10)
+
+        logs = LogEntry.objects.filter(
+            date__lte=dt.datetime(1980, 1, 1),
+            date__gte=dt.datetime(1975, 1, 1),
+        )
+        self.assertEqual(logs.count(), 5)
+
+    def test_datetime_validation(self):
+        """Ensure that invalid values cannot be assigned to datetime
+        fields.
+        """
+        class LogEntry(Document):
+            time = DateTimeField()
+
+        log = LogEntry()
+        log.time = dt.datetime.now()
+        log.validate()
+
+        log.time = dt.date.today()
+        log.validate()
+
+        log.time = dt.datetime.now().isoformat(' ')
+        log.validate()
+
+        log.time = '2019-05-16 21:42:57.897847'
+        log.validate()
+
+        if dateutil:
+            log.time = dt.datetime.now().isoformat('T')
+            log.validate()
+
+        log.time = -1
+        self.assertRaises(ValidationError, log.validate)
+        log.time = 'ABC'
+        self.assertRaises(ValidationError, log.validate)
+        log.time = '2019-05-16 21:GARBAGE:12'
+        self.assertRaises(ValidationError, log.validate)
+        log.time = '2019-05-16 21:42:57.GARBAGE'
+        self.assertRaises(ValidationError, log.validate)
+        log.time = '2019-05-16 21:42:57.123.456'
+        self.assertRaises(ValidationError, log.validate)
+
+    def test_parse_datetime_as_str(self):
+        class DTDoc(Document):
+            date = DateTimeField()
+
+        date_str = '2019-03-02 22:26:01'
+
+        # make sure that passing a parsable datetime works
+        dtd = DTDoc()
+        dtd.date = date_str
+        self.assertIsInstance(dtd.date, six.string_types)
+        dtd.save()
+        dtd.reload()
+
+        self.assertIsInstance(dtd.date, dt.datetime)
+        self.assertEqual(str(dtd.date), date_str)
+
+        dtd.date = 'January 1st, 9999999999'
+        self.assertRaises(ValidationError, dtd.validate)
+
+
+class TestDateTimeTzAware(MongoDBTestCase):
+    def test_datetime_tz_aware_mark_as_changed(self):
+        # Reset the connections
+        connection._connection_settings = {}
+        connection._connections = {}
+        connection._dbs = {}
+
+        connect(db='mongoenginetest', tz_aware=True)
+
+        class LogEntry(Document):
+            time = DateTimeField()
+
+        LogEntry.drop_collection()
+
+        LogEntry(time=dt.datetime(2013, 1, 1, 0, 0, 0)).save()
+
+        log = LogEntry.objects.first()
+        log.time = dt.datetime(2013, 1, 1, 0, 0, 0)
+        self.assertEqual(['time'], log._changed_fields)

tests/fields/test_decimal_field.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+from decimal import Decimal
+
+from mongoengine import *
+
+from tests.utils import MongoDBTestCase
+
+
+class TestDecimalField(MongoDBTestCase):
+
+    def test_validation(self):
+        """Ensure that invalid values cannot be assigned to decimal fields.
+        """
+        class Person(Document):
+            height = DecimalField(min_value=Decimal('0.1'),
+                                  max_value=Decimal('3.5'))
+
+        Person.drop_collection()
+
+        Person(height=Decimal('1.89')).save()
+        person = Person.objects.first()
+        self.assertEqual(person.height, Decimal('1.89'))
+
+        person.height = '2.0'
+        person.save()
+        person.height = 0.01
+        self.assertRaises(ValidationError, person.validate)
+        person.height = Decimal('0.01')
+        self.assertRaises(ValidationError, person.validate)
+        person.height = Decimal('4.0')
+        self.assertRaises(ValidationError, person.validate)
+        person.height = 'something invalid'
+        self.assertRaises(ValidationError, person.validate)
+
+        person_2 = Person(height='something invalid')
+        self.assertRaises(ValidationError, person_2.validate)
+
+    def test_comparison(self):
+        class Person(Document):
+            money = DecimalField()
+
+        Person.drop_collection()
+
+        Person(money=6).save()
+        Person(money=7).save()
+        Person(money=8).save()
+        Person(money=10).save()
+
+        self.assertEqual(2, Person.objects(money__gt=Decimal("7")).count())
+        self.assertEqual(2, Person.objects(money__gt=7).count())
+        self.assertEqual(2, Person.objects(money__gt="7").count())
+
+        self.assertEqual(3, Person.objects(money__gte="7").count())
+
+    def test_storage(self):
+        class Person(Document):
+            float_value = DecimalField(precision=4)
+            string_value = DecimalField(precision=4, force_string=True)
+
+        Person.drop_collection()
+        values_to_store = [10, 10.1, 10.11, "10.111", Decimal("10.1111"), Decimal("10.11111")]
+        for store_at_creation in [True, False]:
+            for value in values_to_store:
+                # to_python is called explicitly if values were sent in the kwargs of __init__
+                if store_at_creation:
+                    Person(float_value=value, string_value=value).save()
+                else:
+                    person = Person.objects.create()
+                    person.float_value = value
+                    person.string_value = value
+                    person.save()
+
+        # How its stored
+        expected = [
+            {'float_value': 10.0, 'string_value': '10.0000'},
+            {'float_value': 10.1, 'string_value': '10.1000'},
+            {'float_value': 10.11, 'string_value': '10.1100'},
+            {'float_value': 10.111, 'string_value': '10.1110'},
+            {'float_value': 10.1111, 'string_value': '10.1111'},
+            {'float_value': 10.1111, 'string_value': '10.1111'}]
+        expected.extend(expected)
+        actual = list(Person.objects.exclude('id').as_pymongo())
+        self.assertEqual(expected, actual)
+
+        # How it comes out locally
+        expected = [Decimal('10.0000'), Decimal('10.1000'), Decimal('10.1100'),
+                    Decimal('10.1110'), Decimal('10.1111'), Decimal('10.1111')]
+        expected.extend(expected)
+        for field_name in ['float_value', 'string_value']:
+            actual = list(Person.objects().scalar(field_name))
+            self.assertEqual(expected, actual)

tests/fields/test_dict_field.py

@@ -0,0 +1,324 @@
+# -*- coding: utf-8 -*-
+from mongoengine import *
+from mongoengine.base import BaseDict
+
+from tests.utils import MongoDBTestCase, get_as_pymongo
+
+
+class TestDictField(MongoDBTestCase):
+
+    def test_storage(self):
+        class BlogPost(Document):
+            info = DictField()
+
+        BlogPost.drop_collection()
+
+        info = {'testkey': 'testvalue'}
+        post = BlogPost(info=info).save()
+        self.assertEqual(
+            get_as_pymongo(post),
+            {
+                '_id': post.id,
+                'info': info
+            }
+        )
+
+    def test_general_things(self):
+        """Ensure that dict types work as expected."""
+        class BlogPost(Document):
+            info = DictField()
+
+        BlogPost.drop_collection()
+
+        post = BlogPost()
+        post.info = 'my post'
+        self.assertRaises(ValidationError, post.validate)
+
+        post.info = ['test', 'test']
+        self.assertRaises(ValidationError, post.validate)
+
+        post.info = {'$title': 'test'}
+        self.assertRaises(ValidationError, post.validate)
+
+        post.info = {'nested': {'$title': 'test'}}
+        self.assertRaises(ValidationError, post.validate)
+
+        post.info = {'the.title': 'test'}
+        self.assertRaises(ValidationError, post.validate)
+
+        post.info = {'nested': {'the.title': 'test'}}
+        self.assertRaises(ValidationError, post.validate)
+
+        post.info = {1: 'test'}
+        self.assertRaises(ValidationError, post.validate)
+
+        post.info = {'title': 'test'}
+        post.save()
+
+        post = BlogPost()
+        post.info = {'title': 'dollar_sign', 'details': {'te$t': 'test'}}
+        post.save()
+
+        post = BlogPost()
+        post.info = {'details': {'test': 'test'}}
+        post.save()
+
+        post = BlogPost()
+        post.info = {'details': {'test': 3}}
+        post.save()
+
+        self.assertEqual(BlogPost.objects.count(), 4)
+        self.assertEqual(
+            BlogPost.objects.filter(info__title__exact='test').count(), 1)
+        self.assertEqual(
+            BlogPost.objects.filter(info__details__test__exact='test').count(), 1)
+
+        post = BlogPost.objects.filter(info__title__exact='dollar_sign').first()
+        self.assertIn('te$t', post['info']['details'])
+
+        # Confirm handles non strings or non existing keys
+        self.assertEqual(
+            BlogPost.objects.filter(info__details__test__exact=5).count(), 0)
+        self.assertEqual(
+            BlogPost.objects.filter(info__made_up__test__exact='test').count(), 0)
+
+        post = BlogPost.objects.create(info={'title': 'original'})
+        post.info.update({'title': 'updated'})
+        post.save()
+        post.reload()
+        self.assertEqual('updated', post.info['title'])
+
+        post.info.setdefault('authors', [])
+        post.save()
+        post.reload()
+        self.assertEqual([], post.info['authors'])
+
+    def test_dictfield_dump_document(self):
+        """Ensure a DictField can handle another document's dump."""
+        class Doc(Document):
+            field = DictField()
+
+        class ToEmbed(Document):
+            id = IntField(primary_key=True, default=1)
+            recursive = DictField()
+
+        class ToEmbedParent(Document):
+            id = IntField(primary_key=True, default=1)
+            recursive = DictField()
+
+            meta = {'allow_inheritance': True}
+
+        class ToEmbedChild(ToEmbedParent):
+            pass
+
+        to_embed_recursive = ToEmbed(id=1).save()
+        to_embed = ToEmbed(
+            id=2, recursive=to_embed_recursive.to_mongo().to_dict()).save()
+        doc = Doc(field=to_embed.to_mongo().to_dict())
+        doc.save()
+        self.assertIsInstance(doc.field, dict)
+        self.assertEqual(doc.field, {'_id': 2, 'recursive': {'_id': 1, 'recursive': {}}})
+        # Same thing with a Document with a _cls field
+        to_embed_recursive = ToEmbedChild(id=1).save()
+        to_embed_child = ToEmbedChild(
+            id=2, recursive=to_embed_recursive.to_mongo().to_dict()).save()
+        doc = Doc(field=to_embed_child.to_mongo().to_dict())
+        doc.save()
+        self.assertIsInstance(doc.field, dict)
+        expected = {
+            '_id': 2, '_cls': 'ToEmbedParent.ToEmbedChild',
+            'recursive': {'_id': 1, '_cls': 'ToEmbedParent.ToEmbedChild', 'recursive': {}}
+        }
+        self.assertEqual(doc.field, expected)
+
+    def test_dictfield_strict(self):
+        """Ensure that dict field handles validation if provided a strict field type."""
+        class Simple(Document):
+            mapping = DictField(field=IntField())
+
+        Simple.drop_collection()
+
+        e = Simple()
+        e.mapping['someint'] = 1
+        e.save()
+
+        # try creating an invalid mapping
+        with self.assertRaises(ValidationError):
+            e.mapping['somestring'] = "abc"
+            e.save()
+
+    def test_dictfield_complex(self):
+        """Ensure that the dict field can handle the complex types."""
+        class SettingBase(EmbeddedDocument):
+            meta = {'allow_inheritance': True}
+
+        class StringSetting(SettingBase):
+            value = StringField()
+
+        class IntegerSetting(SettingBase):
+            value = IntField()
+
+        class Simple(Document):
+            mapping = DictField()
+
+        Simple.drop_collection()
+
+        e = Simple()
+        e.mapping['somestring'] = StringSetting(value='foo')
+        e.mapping['someint'] = IntegerSetting(value=42)
+        e.mapping['nested_dict'] = {'number': 1, 'string': 'Hi!',
+                                    'float': 1.001,
+                                    'complex': IntegerSetting(value=42),
+                                    'list': [IntegerSetting(value=42),
+                                             StringSetting(value='foo')]}
+        e.save()
+
+        e2 = Simple.objects.get(id=e.id)
+        self.assertIsInstance(e2.mapping['somestring'], StringSetting)
+        self.assertIsInstance(e2.mapping['someint'], IntegerSetting)
+
+        # Test querying
+        self.assertEqual(
+            Simple.objects.filter(mapping__someint__value=42).count(), 1)
+        self.assertEqual(
+            Simple.objects.filter(mapping__nested_dict__number=1).count(), 1)
+        self.assertEqual(
+            Simple.objects.filter(mapping__nested_dict__complex__value=42).count(), 1)
+        self.assertEqual(
+            Simple.objects.filter(mapping__nested_dict__list__0__value=42).count(), 1)
+        self.assertEqual(
+            Simple.objects.filter(mapping__nested_dict__list__1__value='foo').count(), 1)
+
+        # Confirm can update
+        Simple.objects().update(
+            set__mapping={"someint": IntegerSetting(value=10)})
+        Simple.objects().update(
+            set__mapping__nested_dict__list__1=StringSetting(value='Boo'))
+        self.assertEqual(
+            Simple.objects.filter(mapping__nested_dict__list__1__value='foo').count(), 0)
+        self.assertEqual(
+            Simple.objects.filter(mapping__nested_dict__list__1__value='Boo').count(), 1)
+
+    def test_push_dict(self):
+        class MyModel(Document):
+            events = ListField(DictField())
+
+        doc = MyModel(events=[{'a': 1}]).save()
+        raw_doc = get_as_pymongo(doc)
+        expected_raw_doc = {
+            '_id': doc.id,
+            'events': [{'a': 1}]
+        }
+        self.assertEqual(raw_doc, expected_raw_doc)
+
+        MyModel.objects(id=doc.id).update(push__events={})
+        raw_doc = get_as_pymongo(doc)
+        expected_raw_doc = {
+            '_id': doc.id,
+            'events': [{'a': 1}, {}]
+        }
+        self.assertEqual(raw_doc, expected_raw_doc)
+
+    def test_ensure_unique_default_instances(self):
+        """Ensure that every field has it's own unique default instance."""
+        class D(Document):
+            data = DictField()
+            data2 = DictField(default=lambda: {})
+
+        d1 = D()
+        d1.data['foo'] = 'bar'
+        d1.data2['foo'] = 'bar'
+        d2 = D()
+        self.assertEqual(d2.data, {})
+        self.assertEqual(d2.data2, {})
+
+    def test_dict_field_invalid_dict_value(self):
+        class DictFieldTest(Document):
+            dictionary = DictField(required=True)
+
+        DictFieldTest.drop_collection()
+
+        test = DictFieldTest(dictionary=None)
+        test.dictionary  # Just access to test getter
+        self.assertRaises(ValidationError, test.validate)
+
+        test = DictFieldTest(dictionary=False)
+        test.dictionary  # Just access to test getter
+        self.assertRaises(ValidationError, test.validate)
+
+    def test_dict_field_raises_validation_error_if_wrongly_assign_embedded_doc(self):
+        class DictFieldTest(Document):
+            dictionary = DictField(required=True)
+
+        DictFieldTest.drop_collection()
+
+        class Embedded(EmbeddedDocument):
+            name = StringField()
+
+        embed = Embedded(name='garbage')
+        doc = DictFieldTest(dictionary=embed)
+        with self.assertRaises(ValidationError) as ctx_err:
+            doc.validate()
+        self.assertIn("'dictionary'", str(ctx_err.exception))
+        self.assertIn('Only dictionaries may be used in a DictField', str(ctx_err.exception))
+
+    def test_atomic_update_dict_field(self):
+        """Ensure that the entire DictField can be atomically updated."""
+        class Simple(Document):
+            mapping = DictField(field=ListField(IntField(required=True)))
+
+        Simple.drop_collection()
+
+        e = Simple()
+        e.mapping['someints'] = [1, 2]
+        e.save()
+        e.update(set__mapping={"ints": [3, 4]})
+        e.reload()
+        self.assertEqual(BaseDict, type(e.mapping))
+        self.assertEqual({"ints": [3, 4]}, e.mapping)
+
+        # try creating an invalid mapping
+        with self.assertRaises(ValueError):
+            e.update(set__mapping={"somestrings": ["foo", "bar", ]})
+
+    def test_dictfield_with_referencefield_complex_nesting_cases(self):
+        """Ensure complex nesting inside DictField handles dereferencing of ReferenceField(dbref=True | False)"""
+        # Relates to Issue #1453
+        class Doc(Document):
+            s = StringField()
+
+        class Simple(Document):
+            mapping0 = DictField(ReferenceField(Doc, dbref=True))
+            mapping1 = DictField(ReferenceField(Doc, dbref=False))
+            mapping2 = DictField(ListField(ReferenceField(Doc, dbref=True)))
+            mapping3 = DictField(ListField(ReferenceField(Doc, dbref=False)))
+            mapping4 = DictField(DictField(field=ReferenceField(Doc, dbref=True)))
+            mapping5 = DictField(DictField(field=ReferenceField(Doc, dbref=False)))
+            mapping6 = DictField(ListField(DictField(ReferenceField(Doc, dbref=True))))
+            mapping7 = DictField(ListField(DictField(ReferenceField(Doc, dbref=False))))
+            mapping8 = DictField(ListField(DictField(ListField(ReferenceField(Doc, dbref=True)))))
+            mapping9 = DictField(ListField(DictField(ListField(ReferenceField(Doc, dbref=False)))))
+
+        Doc.drop_collection()
+        Simple.drop_collection()
+
+        d = Doc(s='aa').save()
+        e = Simple()
+        e.mapping0['someint'] = e.mapping1['someint'] = d
+        e.mapping2['someint'] = e.mapping3['someint'] = [d]
+        e.mapping4['someint'] = e.mapping5['someint'] = {'d': d}
+        e.mapping6['someint'] = e.mapping7['someint'] = [{'d': d}]
+        e.mapping8['someint'] = e.mapping9['someint'] = [{'d': [d]}]
+        e.save()
+
+        s = Simple.objects.first()
+        self.assertIsInstance(s.mapping0['someint'], Doc)
+        self.assertIsInstance(s.mapping1['someint'], Doc)
+        self.assertIsInstance(s.mapping2['someint'][0], Doc)
+        self.assertIsInstance(s.mapping3['someint'][0], Doc)
+        self.assertIsInstance(s.mapping4['someint']['d'], Doc)
+        self.assertIsInstance(s.mapping5['someint']['d'], Doc)
+        self.assertIsInstance(s.mapping6['someint'][0]['d'], Doc)
+        self.assertIsInstance(s.mapping7['someint'][0]['d'], Doc)
+        self.assertIsInstance(s.mapping8['someint'][0]['d'][0], Doc)
+        self.assertIsInstance(s.mapping9['someint'][0]['d'][0], Doc)

tests/fields/test_email_field.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+import sys
+from unittest import SkipTest
+
+from mongoengine import *
+
+from tests.utils import MongoDBTestCase
+
+
+class TestEmailField(MongoDBTestCase):
+    def test_generic_behavior(self):
+        class User(Document):
+            email = EmailField()
+
+        user = User(email='ross@example.com')
+        user.validate()
+
+        user = User(email='ross@example.co.uk')
+        user.validate()
+
+        user = User(email=('Kofq@rhom0e4klgauOhpbpNdogawnyIKvQS0wk2mjqrgGQ5S'
+                           'aJIazqqWkm7.net'))
+        user.validate()
+
+        user = User(email='new-tld@example.technology')
+        user.validate()
+
+        user = User(email='ross@example.com.')
+        self.assertRaises(ValidationError, user.validate)
+
+        # unicode domain
+        user = User(email=u'user@пример.рф')
+        user.validate()
+
+        # invalid unicode domain
+        user = User(email=u'user@пример')
+        self.assertRaises(ValidationError, user.validate)
+
+        # invalid data type
+        user = User(email=123)
+        self.assertRaises(ValidationError, user.validate)
+
+    def test_email_field_unicode_user(self):
+        # Don't run this test on pypy3, which doesn't support unicode regex:
+        # https://bitbucket.org/pypy/pypy/issues/1821/regular-expression-doesnt-find-unicode
+        if sys.version_info[:2] == (3, 2):
+            raise SkipTest('unicode email addresses are not supported on PyPy 3')
+
+        class User(Document):
+            email = EmailField()
+
+        # unicode user shouldn't validate by default...
+        user = User(email=u'Dörte@Sörensen.example.com')
+        self.assertRaises(ValidationError, user.validate)
+
+        # ...but it should be fine with allow_utf8_user set to True
+        class User(Document):
+            email = EmailField(allow_utf8_user=True)
+
+        user = User(email=u'Dörte@Sörensen.example.com')
+        user.validate()
+
+    def test_email_field_domain_whitelist(self):
+        class User(Document):
+            email = EmailField()
+
+        # localhost domain shouldn't validate by default...
+        user = User(email='me@localhost')
+        self.assertRaises(ValidationError, user.validate)
+
+        # ...but it should be fine if it's whitelisted
+        class User(Document):
+            email = EmailField(domain_whitelist=['localhost'])
+
+        user = User(email='me@localhost')
+        user.validate()
+
+    def test_email_domain_validation_fails_if_invalid_idn(self):
+        class User(Document):
+            email = EmailField()
+
+        invalid_idn = '.google.com'
+        user = User(email='me@%s' % invalid_idn)
+        with self.assertRaises(ValidationError) as ctx_err:
+            user.validate()
+        self.assertIn("domain failed IDN encoding", str(ctx_err.exception))
+
+    def test_email_field_ip_domain(self):
+        class User(Document):
+            email = EmailField()
+
+        valid_ipv4 = 'email@[127.0.0.1]'
+        valid_ipv6 = 'email@[2001:dB8::1]'
+        invalid_ip = 'email@[324.0.0.1]'
+
+        # IP address as a domain shouldn't validate by default...
+        user = User(email=valid_ipv4)
+        self.assertRaises(ValidationError, user.validate)
+
+        user = User(email=valid_ipv6)
+        self.assertRaises(ValidationError, user.validate)
+
+        user = User(email=invalid_ip)
+        self.assertRaises(ValidationError, user.validate)
+
+        # ...but it should be fine with allow_ip_domain set to True
+        class User(Document):
+            email = EmailField(allow_ip_domain=True)
+
+        user = User(email=valid_ipv4)
+        user.validate()
+
+        user = User(email=valid_ipv6)
+        user.validate()
+
+        # invalid IP should still fail validation
+        user = User(email=invalid_ip)
+        self.assertRaises(ValidationError, user.validate)
+
+    def test_email_field_honors_regex(self):
+        class User(Document):
+            email = EmailField(regex=r'\w+@example.com')
+
+        # Fails regex validation
+        user = User(email='me@foo.com')
+        self.assertRaises(ValidationError, user.validate)
+
+        # Passes regex validation
+        user = User(email='me@example.com')
+        self.assertIsNone(user.validate())

tests/fields/test_embedded_document_field.py

@@ -0,0 +1,344 @@
+# -*- coding: utf-8 -*-
+from mongoengine import Document, StringField, ValidationError, EmbeddedDocument, EmbeddedDocumentField, \
+    InvalidQueryError, LookUpError, IntField, GenericEmbeddedDocumentField, ListField, EmbeddedDocumentListField, \
+    ReferenceField
+
+from tests.utils import MongoDBTestCase
+
+
+class TestEmbeddedDocumentField(MongoDBTestCase):
+    def test___init___(self):
+        class MyDoc(EmbeddedDocument):
+            name = StringField()
+
+        field = EmbeddedDocumentField(MyDoc)
+        self.assertEqual(field.document_type_obj, MyDoc)
+
+        field2 = EmbeddedDocumentField('MyDoc')
+        self.assertEqual(field2.document_type_obj, 'MyDoc')
+
+    def test___init___throw_error_if_document_type_is_not_EmbeddedDocument(self):
+        with self.assertRaises(ValidationError):
+            EmbeddedDocumentField(dict)
+
+    def test_document_type_throw_error_if_not_EmbeddedDocument_subclass(self):
+
+        class MyDoc(Document):
+            name = StringField()
+
+        emb = EmbeddedDocumentField('MyDoc')
+        with self.assertRaises(ValidationError) as ctx:
+            emb.document_type
+        self.assertIn('Invalid embedded document class provided to an EmbeddedDocumentField', str(ctx.exception))
+
+    def test_embedded_document_field_only_allow_subclasses_of_embedded_document(self):
+        # Relates to #1661
+        class MyDoc(Document):
+            name = StringField()
+
+        with self.assertRaises(ValidationError):
+            class MyFailingDoc(Document):
+                emb = EmbeddedDocumentField(MyDoc)
+
+        with self.assertRaises(ValidationError):
+            class MyFailingdoc2(Document):
+                emb = EmbeddedDocumentField('MyDoc')
+
+    def test_query_embedded_document_attribute(self):
+        class AdminSettings(EmbeddedDocument):
+            foo1 = StringField()
+            foo2 = StringField()
+
+        class Person(Document):
+            settings = EmbeddedDocumentField(AdminSettings)
+            name = StringField()
+
+        Person.drop_collection()
+
+        p = Person(
+            settings=AdminSettings(foo1='bar1', foo2='bar2'),
+            name='John',
+        ).save()
+
+        # Test non exiting attribute
+        with self.assertRaises(InvalidQueryError) as ctx_err:
+            Person.objects(settings__notexist='bar').first()
+        self.assertEqual(unicode(ctx_err.exception), u'Cannot resolve field "notexist"')
+
+        with self.assertRaises(LookUpError):
+            Person.objects.only('settings.notexist')
+
+        # Test existing attribute
+        self.assertEqual(Person.objects(settings__foo1='bar1').first().id, p.id)
+        only_p = Person.objects.only('settings.foo1').first()
+        self.assertEqual(only_p.settings.foo1, p.settings.foo1)
+        self.assertIsNone(only_p.settings.foo2)
+        self.assertIsNone(only_p.name)
+
+        exclude_p = Person.objects.exclude('settings.foo1').first()
+        self.assertIsNone(exclude_p.settings.foo1)
+        self.assertEqual(exclude_p.settings.foo2, p.settings.foo2)
+        self.assertEqual(exclude_p.name, p.name)
+
+    def test_query_embedded_document_attribute_with_inheritance(self):
+        class BaseSettings(EmbeddedDocument):
+            meta = {'allow_inheritance': True}
+            base_foo = StringField()
+
+        class AdminSettings(BaseSettings):
+            sub_foo = StringField()
+
+        class Person(Document):
+            settings = EmbeddedDocumentField(BaseSettings)
+
+        Person.drop_collection()
+
+        p = Person(settings=AdminSettings(base_foo='basefoo', sub_foo='subfoo'))
+        p.save()
+
+        # Test non exiting attribute
+        with self.assertRaises(InvalidQueryError) as ctx_err:
+            self.assertEqual(Person.objects(settings__notexist='bar').first().id, p.id)
+        self.assertEqual(unicode(ctx_err.exception), u'Cannot resolve field "notexist"')
+
+        # Test existing attribute
+        self.assertEqual(Person.objects(settings__base_foo='basefoo').first().id, p.id)
+        self.assertEqual(Person.objects(settings__sub_foo='subfoo').first().id, p.id)
+
+        only_p = Person.objects.only('settings.base_foo', 'settings._cls').first()
+        self.assertEqual(only_p.settings.base_foo, 'basefoo')
+        self.assertIsNone(only_p.settings.sub_foo)
+
+    def test_query_list_embedded_document_with_inheritance(self):
+        class Post(EmbeddedDocument):
+            title = StringField(max_length=120, required=True)
+            meta = {'allow_inheritance': True}
+
+        class TextPost(Post):
+            content = StringField()
+
+        class MoviePost(Post):
+            author = StringField()
+
+        class Record(Document):
+            posts = ListField(EmbeddedDocumentField(Post))
+
+        record_movie = Record(posts=[MoviePost(author='John', title='foo')]).save()
+        record_text = Record(posts=[TextPost(content='a', title='foo')]).save()
+
+        records = list(Record.objects(posts__author=record_movie.posts[0].author))
+        self.assertEqual(len(records), 1)
+        self.assertEqual(records[0].id, record_movie.id)
+
+        records = list(Record.objects(posts__content=record_text.posts[0].content))
+        self.assertEqual(len(records), 1)
+        self.assertEqual(records[0].id, record_text.id)
+
+        self.assertEqual(Record.objects(posts__title='foo').count(), 2)
+
+
+class TestGenericEmbeddedDocumentField(MongoDBTestCase):
+
+    def test_generic_embedded_document(self):
+        class Car(EmbeddedDocument):
+            name = StringField()
+
+        class Dish(EmbeddedDocument):
+            food = StringField(required=True)
+            number = IntField()
+
+        class Person(Document):
+            name = StringField()
+            like = GenericEmbeddedDocumentField()
+
+        Person.drop_collection()
+
+        person = Person(name='Test User')
+        person.like = Car(name='Fiat')
+        person.save()
+
+        person = Person.objects.first()
+        self.assertIsInstance(person.like, Car)
+
+        person.like = Dish(food="arroz", number=15)
+        person.save()
+
+        person = Person.objects.first()
+        self.assertIsInstance(person.like, Dish)
+
+    def test_generic_embedded_document_choices(self):
+        """Ensure you can limit GenericEmbeddedDocument choices."""
+        class Car(EmbeddedDocument):
+            name = StringField()
+
+        class Dish(EmbeddedDocument):
+            food = StringField(required=True)
+            number = IntField()
+
+        class Person(Document):
+            name = StringField()
+            like = GenericEmbeddedDocumentField(choices=(Dish,))
+
+        Person.drop_collection()
+
+        person = Person(name='Test User')
+        person.like = Car(name='Fiat')
+        self.assertRaises(ValidationError, person.validate)
+
+        person.like = Dish(food="arroz", number=15)
+        person.save()
+
+        person = Person.objects.first()
+        self.assertIsInstance(person.like, Dish)
+
+    def test_generic_list_embedded_document_choices(self):
+        """Ensure you can limit GenericEmbeddedDocument choices inside
+        a list field.
+        """
+        class Car(EmbeddedDocument):
+            name = StringField()
+
+        class Dish(EmbeddedDocument):
+            food = StringField(required=True)
+            number = IntField()
+
+        class Person(Document):
+            name = StringField()
+            likes = ListField(GenericEmbeddedDocumentField(choices=(Dish,)))
+
+        Person.drop_collection()
+
+        person = Person(name='Test User')
+        person.likes = [Car(name='Fiat')]
+        self.assertRaises(ValidationError, person.validate)
+
+        person.likes = [Dish(food="arroz", number=15)]
+        person.save()
+
+        person = Person.objects.first()
+        self.assertIsInstance(person.likes[0], Dish)
+
+    def test_choices_validation_documents(self):
+        """
+        Ensure fields with document choices validate given a valid choice.
+        """
+        class UserComments(EmbeddedDocument):
+            author = StringField()
+            message = StringField()
+
+        class BlogPost(Document):
+            comments = ListField(
+                GenericEmbeddedDocumentField(choices=(UserComments,))
+            )
+
+        # Ensure Validation Passes
+        BlogPost(comments=[
+            UserComments(author='user2', message='message2'),
+        ]).save()
+
+    def test_choices_validation_documents_invalid(self):
+        """
+        Ensure fields with document choices validate given an invalid choice.
+        This should throw a ValidationError exception.
+        """
+        class UserComments(EmbeddedDocument):
+            author = StringField()
+            message = StringField()
+
+        class ModeratorComments(EmbeddedDocument):
+            author = StringField()
+            message = StringField()
+
+        class BlogPost(Document):
+            comments = ListField(
+                GenericEmbeddedDocumentField(choices=(UserComments,))
+            )
+
+        # Single Entry Failure
+        post = BlogPost(comments=[
+            ModeratorComments(author='mod1', message='message1'),
+        ])
+        self.assertRaises(ValidationError, post.save)
+
+        # Mixed Entry Failure
+        post = BlogPost(comments=[
+            ModeratorComments(author='mod1', message='message1'),
+            UserComments(author='user2', message='message2'),
+        ])
+        self.assertRaises(ValidationError, post.save)
+
+    def test_choices_validation_documents_inheritance(self):
+        """
+        Ensure fields with document choices validate given subclass of choice.
+        """
+        class Comments(EmbeddedDocument):
+            meta = {
+                'abstract': True
+            }
+            author = StringField()
+            message = StringField()
+
+        class UserComments(Comments):
+            pass
+
+        class BlogPost(Document):
+            comments = ListField(
+                GenericEmbeddedDocumentField(choices=(Comments,))
+            )
+
+        # Save Valid EmbeddedDocument Type
+        BlogPost(comments=[
+            UserComments(author='user2', message='message2'),
+        ]).save()
+
+    def test_query_generic_embedded_document_attribute(self):
+        class AdminSettings(EmbeddedDocument):
+            foo1 = StringField()
+
+        class NonAdminSettings(EmbeddedDocument):
+            foo2 = StringField()
+
+        class Person(Document):
+            settings = GenericEmbeddedDocumentField(choices=(AdminSettings, NonAdminSettings))
+
+        Person.drop_collection()
+
+        p1 = Person(settings=AdminSettings(foo1='bar1')).save()
+        p2 = Person(settings=NonAdminSettings(foo2='bar2')).save()
+
+        # Test non exiting attribute
+        with self.assertRaises(InvalidQueryError) as ctx_err:
+            Person.objects(settings__notexist='bar').first()
+        self.assertEqual(unicode(ctx_err.exception), u'Cannot resolve field "notexist"')
+
+        with self.assertRaises(LookUpError):
+            Person.objects.only('settings.notexist')
+
+        # Test existing attribute
+        self.assertEqual(Person.objects(settings__foo1='bar1').first().id, p1.id)
+        self.assertEqual(Person.objects(settings__foo2='bar2').first().id, p2.id)
+
+    def test_query_generic_embedded_document_attribute_with_inheritance(self):
+        class BaseSettings(EmbeddedDocument):
+            meta = {'allow_inheritance': True}
+            base_foo = StringField()
+
+        class AdminSettings(BaseSettings):
+            sub_foo = StringField()
+
+        class Person(Document):
+            settings = GenericEmbeddedDocumentField(choices=[BaseSettings])
+
+        Person.drop_collection()
+
+        p = Person(settings=AdminSettings(base_foo='basefoo', sub_foo='subfoo'))
+        p.save()
+
+        # Test non exiting attribute
+        with self.assertRaises(InvalidQueryError) as ctx_err:
+            self.assertEqual(Person.objects(settings__notexist='bar').first().id, p.id)
+        self.assertEqual(unicode(ctx_err.exception), u'Cannot resolve field "notexist"')
+
+        # Test existing attribute
+        self.assertEqual(Person.objects(settings__base_foo='basefoo').first().id, p.id)
+        self.assertEqual(Person.objects(settings__sub_foo='subfoo').first().id, p.id)

tests/fields/test_float_field.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+import six
+
+from mongoengine import *
+
+from tests.utils import MongoDBTestCase
+
+
+class TestFloatField(MongoDBTestCase):
+
+    def test_float_ne_operator(self):
+        class TestDocument(Document):
+            float_fld = FloatField()
+
+        TestDocument.drop_collection()
+
+        TestDocument(float_fld=None).save()
+        TestDocument(float_fld=1).save()
+
+        self.assertEqual(1, TestDocument.objects(float_fld__ne=None).count())
+        self.assertEqual(1, TestDocument.objects(float_fld__ne=1).count())
+
+    def test_validation(self):
+        """Ensure that invalid values cannot be assigned to float fields.
+        """
+        class Person(Document):
+            height = FloatField(min_value=0.1, max_value=3.5)
+
+        class BigPerson(Document):
+            height = FloatField()
+
+        person = Person()
+        person.height = 1.89
+        person.validate()
+
+        person.height = '2.0'
+        self.assertRaises(ValidationError, person.validate)
+
+        person.height = 0.01
+        self.assertRaises(ValidationError, person.validate)
+
+        person.height = 4.0
+        self.assertRaises(ValidationError, person.validate)
+
+        person_2 = Person(height='something invalid')
+        self.assertRaises(ValidationError, person_2.validate)
+
+        big_person = BigPerson()
+
+        for value, value_type in enumerate(six.integer_types):
+            big_person.height = value_type(value)
+            big_person.validate()
+
+        big_person.height = 2 ** 500
+        big_person.validate()
+
+        big_person.height = 2 ** 100000  # Too big for a float value
+        self.assertRaises(ValidationError, big_person.validate)

tests/fields/test_int_field.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+from mongoengine import *
+
+from tests.utils import MongoDBTestCase
+
+
+class TestIntField(MongoDBTestCase):
+
+    def test_int_validation(self):
+        """Ensure that invalid values cannot be assigned to int fields.
+        """
+        class Person(Document):
+            age = IntField(min_value=0, max_value=110)
+
+        person = Person()
+        person.age = 0
+        person.validate()
+
+        person.age = 50
+        person.validate()
+
+        person.age = 110
+        person.validate()
+
+        person.age = -1
+        self.assertRaises(ValidationError, person.validate)
+        person.age = 120
+        self.assertRaises(ValidationError, person.validate)
+        person.age = 'ten'
+        self.assertRaises(ValidationError, person.validate)
+
+    def test_ne_operator(self):
+        class TestDocument(Document):
+            int_fld = IntField()
+
+        TestDocument.drop_collection()
+
+        TestDocument(int_fld=None).save()
+        TestDocument(int_fld=1).save()
+
+        self.assertEqual(1, TestDocument.objects(int_fld__ne=None).count())
+        self.assertEqual(1, TestDocument.objects(int_fld__ne=1).count())

tests/fields/test_lazy_reference_field.py

@@ -0,0 +1,570 @@
+# -*- coding: utf-8 -*-
+from bson import DBRef, ObjectId
+
+from mongoengine import *
+from mongoengine.base import LazyReference
+
+from tests.utils import MongoDBTestCase
+
+
+class TestLazyReferenceField(MongoDBTestCase):
+    def test_lazy_reference_config(self):
+        # Make sure ReferenceField only accepts a document class or a string
+        # with a document class name.
+        self.assertRaises(ValidationError, LazyReferenceField, EmbeddedDocument)
+
+    def test___repr__(self):
+        class Animal(Document):
+            pass
+
+        class Ocurrence(Document):
+            animal = LazyReferenceField(Animal)
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        animal = Animal()
+        oc = Ocurrence(animal=animal)
+        self.assertIn('LazyReference', repr(oc.animal))
+
+    def test___getattr___unknown_attr_raises_attribute_error(self):
+        class Animal(Document):
+            pass
+
+        class Ocurrence(Document):
+            animal = LazyReferenceField(Animal)
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        animal = Animal().save()
+        oc = Ocurrence(animal=animal)
+        with self.assertRaises(AttributeError):
+            oc.animal.not_exist
+
+    def test_lazy_reference_simple(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            person = StringField()
+            animal = LazyReferenceField(Animal)
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        animal = Animal(name="Leopard", tag="heavy").save()
+        Ocurrence(person="test", animal=animal).save()
+        p = Ocurrence.objects.get()
+        self.assertIsInstance(p.animal, LazyReference)
+        fetched_animal = p.animal.fetch()
+        self.assertEqual(fetched_animal, animal)
+        # `fetch` keep cache on referenced document by default...
+        animal.tag = "not so heavy"
+        animal.save()
+        double_fetch = p.animal.fetch()
+        self.assertIs(fetched_animal, double_fetch)
+        self.assertEqual(double_fetch.tag, "heavy")
+        # ...unless specified otherwise
+        fetch_force = p.animal.fetch(force=True)
+        self.assertIsNot(fetch_force, fetched_animal)
+        self.assertEqual(fetch_force.tag, "not so heavy")
+
+    def test_lazy_reference_fetch_invalid_ref(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            person = StringField()
+            animal = LazyReferenceField(Animal)
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        animal = Animal(name="Leopard", tag="heavy").save()
+        Ocurrence(person="test", animal=animal).save()
+        animal.delete()
+        p = Ocurrence.objects.get()
+        self.assertIsInstance(p.animal, LazyReference)
+        with self.assertRaises(DoesNotExist):
+            p.animal.fetch()
+
+    def test_lazy_reference_set(self):
+        class Animal(Document):
+            meta = {'allow_inheritance': True}
+
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            person = StringField()
+            animal = LazyReferenceField(Animal)
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        class SubAnimal(Animal):
+            nick = StringField()
+
+        animal = Animal(name="Leopard", tag="heavy").save()
+        sub_animal = SubAnimal(nick='doggo', name='dog').save()
+        for ref in (
+                animal,
+                animal.pk,
+                DBRef(animal._get_collection_name(), animal.pk),
+                LazyReference(Animal, animal.pk),
+
+                sub_animal,
+                sub_animal.pk,
+                DBRef(sub_animal._get_collection_name(), sub_animal.pk),
+                LazyReference(SubAnimal, sub_animal.pk),
+                ):
+            p = Ocurrence(person="test", animal=ref).save()
+            p.reload()
+            self.assertIsInstance(p.animal, LazyReference)
+            p.animal.fetch()
+
+    def test_lazy_reference_bad_set(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            person = StringField()
+            animal = LazyReferenceField(Animal)
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        class BadDoc(Document):
+            pass
+
+        animal = Animal(name="Leopard", tag="heavy").save()
+        baddoc = BadDoc().save()
+        for bad in (
+                42,
+                'foo',
+                baddoc,
+                DBRef(baddoc._get_collection_name(), animal.pk),
+                LazyReference(BadDoc, animal.pk)
+                ):
+            with self.assertRaises(ValidationError):
+                p = Ocurrence(person="test", animal=bad).save()
+
+    def test_lazy_reference_query_conversion(self):
+        """Ensure that LazyReferenceFields can be queried using objects and values
+        of the type of the primary key of the referenced object.
+        """
+        class Member(Document):
+            user_num = IntField(primary_key=True)
+
+        class BlogPost(Document):
+            title = StringField()
+            author = LazyReferenceField(Member, dbref=False)
+
+        Member.drop_collection()
+        BlogPost.drop_collection()
+
+        m1 = Member(user_num=1)
+        m1.save()
+        m2 = Member(user_num=2)
+        m2.save()
+
+        post1 = BlogPost(title='post 1', author=m1)
+        post1.save()
+
+        post2 = BlogPost(title='post 2', author=m2)
+        post2.save()
+
+        post = BlogPost.objects(author=m1).first()
+        self.assertEqual(post.id, post1.id)
+
+        post = BlogPost.objects(author=m2).first()
+        self.assertEqual(post.id, post2.id)
+
+        # Same thing by passing a LazyReference instance
+        post = BlogPost.objects(author=LazyReference(Member, m2.pk)).first()
+        self.assertEqual(post.id, post2.id)
+
+    def test_lazy_reference_query_conversion_dbref(self):
+        """Ensure that LazyReferenceFields can be queried using objects and values
+        of the type of the primary key of the referenced object.
+        """
+        class Member(Document):
+            user_num = IntField(primary_key=True)
+
+        class BlogPost(Document):
+            title = StringField()
+            author = LazyReferenceField(Member, dbref=True)
+
+        Member.drop_collection()
+        BlogPost.drop_collection()
+
+        m1 = Member(user_num=1)
+        m1.save()
+        m2 = Member(user_num=2)
+        m2.save()
+
+        post1 = BlogPost(title='post 1', author=m1)
+        post1.save()
+
+        post2 = BlogPost(title='post 2', author=m2)
+        post2.save()
+
+        post = BlogPost.objects(author=m1).first()
+        self.assertEqual(post.id, post1.id)
+
+        post = BlogPost.objects(author=m2).first()
+        self.assertEqual(post.id, post2.id)
+
+        # Same thing by passing a LazyReference instance
+        post = BlogPost.objects(author=LazyReference(Member, m2.pk)).first()
+        self.assertEqual(post.id, post2.id)
+
+    def test_lazy_reference_passthrough(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            animal = LazyReferenceField(Animal, passthrough=False)
+            animal_passthrough = LazyReferenceField(Animal, passthrough=True)
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        animal = Animal(name="Leopard", tag="heavy").save()
+        Ocurrence(animal=animal, animal_passthrough=animal).save()
+        p = Ocurrence.objects.get()
+        self.assertIsInstance(p.animal, LazyReference)
+        with self.assertRaises(KeyError):
+            p.animal['name']
+        with self.assertRaises(AttributeError):
+            p.animal.name
+        self.assertEqual(p.animal.pk, animal.pk)
+
+        self.assertEqual(p.animal_passthrough.name, "Leopard")
+        self.assertEqual(p.animal_passthrough['name'], "Leopard")
+
+        # Should not be able to access referenced document's methods
+        with self.assertRaises(AttributeError):
+            p.animal.save
+        with self.assertRaises(KeyError):
+            p.animal['save']
+
+    def test_lazy_reference_not_set(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            person = StringField()
+            animal = LazyReferenceField(Animal)
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        Ocurrence(person='foo').save()
+        p = Ocurrence.objects.get()
+        self.assertIs(p.animal, None)
+
+    def test_lazy_reference_equality(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        Animal.drop_collection()
+
+        animal = Animal(name="Leopard", tag="heavy").save()
+        animalref = LazyReference(Animal, animal.pk)
+        self.assertEqual(animal, animalref)
+        self.assertEqual(animalref, animal)
+
+        other_animalref = LazyReference(Animal, ObjectId("54495ad94c934721ede76f90"))
+        self.assertNotEqual(animal, other_animalref)
+        self.assertNotEqual(other_animalref, animal)
+
+    def test_lazy_reference_embedded(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class EmbeddedOcurrence(EmbeddedDocument):
+            in_list = ListField(LazyReferenceField(Animal))
+            direct = LazyReferenceField(Animal)
+
+        class Ocurrence(Document):
+            in_list = ListField(LazyReferenceField(Animal))
+            in_embedded = EmbeddedDocumentField(EmbeddedOcurrence)
+            direct = LazyReferenceField(Animal)
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        animal1 = Animal('doggo').save()
+        animal2 = Animal('cheeta').save()
+
+        def check_fields_type(occ):
+            self.assertIsInstance(occ.direct, LazyReference)
+            for elem in occ.in_list:
+                self.assertIsInstance(elem, LazyReference)
+            self.assertIsInstance(occ.in_embedded.direct, LazyReference)
+            for elem in occ.in_embedded.in_list:
+                self.assertIsInstance(elem, LazyReference)
+
+        occ = Ocurrence(
+            in_list=[animal1, animal2],
+            in_embedded={'in_list': [animal1, animal2], 'direct': animal1},
+            direct=animal1
+        ).save()
+        check_fields_type(occ)
+        occ.reload()
+        check_fields_type(occ)
+        occ.direct = animal1.id
+        occ.in_list = [animal1.id, animal2.id]
+        occ.in_embedded.direct = animal1.id
+        occ.in_embedded.in_list = [animal1.id, animal2.id]
+        check_fields_type(occ)
+
+
+class TestGenericLazyReferenceField(MongoDBTestCase):
+    def test_generic_lazy_reference_simple(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            person = StringField()
+            animal = GenericLazyReferenceField()
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        animal = Animal(name="Leopard", tag="heavy").save()
+        Ocurrence(person="test", animal=animal).save()
+        p = Ocurrence.objects.get()
+        self.assertIsInstance(p.animal, LazyReference)
+        fetched_animal = p.animal.fetch()
+        self.assertEqual(fetched_animal, animal)
+        # `fetch` keep cache on referenced document by default...
+        animal.tag = "not so heavy"
+        animal.save()
+        double_fetch = p.animal.fetch()
+        self.assertIs(fetched_animal, double_fetch)
+        self.assertEqual(double_fetch.tag, "heavy")
+        # ...unless specified otherwise
+        fetch_force = p.animal.fetch(force=True)
+        self.assertIsNot(fetch_force, fetched_animal)
+        self.assertEqual(fetch_force.tag, "not so heavy")
+
+    def test_generic_lazy_reference_choices(self):
+        class Animal(Document):
+            name = StringField()
+
+        class Vegetal(Document):
+            name = StringField()
+
+        class Mineral(Document):
+            name = StringField()
+
+        class Ocurrence(Document):
+            living_thing = GenericLazyReferenceField(choices=[Animal, Vegetal])
+            thing = GenericLazyReferenceField()
+
+        Animal.drop_collection()
+        Vegetal.drop_collection()
+        Mineral.drop_collection()
+        Ocurrence.drop_collection()
+
+        animal = Animal(name="Leopard").save()
+        vegetal = Vegetal(name="Oak").save()
+        mineral = Mineral(name="Granite").save()
+
+        occ_animal = Ocurrence(living_thing=animal, thing=animal).save()
+        occ_vegetal = Ocurrence(living_thing=vegetal, thing=vegetal).save()
+        with self.assertRaises(ValidationError):
+            Ocurrence(living_thing=mineral).save()
+
+        occ = Ocurrence.objects.get(living_thing=animal)
+        self.assertEqual(occ, occ_animal)
+        self.assertIsInstance(occ.thing, LazyReference)
+        self.assertIsInstance(occ.living_thing, LazyReference)
+
+        occ.thing = vegetal
+        occ.living_thing = vegetal
+        occ.save()
+
+        occ.thing = mineral
+        occ.living_thing = mineral
+        with self.assertRaises(ValidationError):
+            occ.save()
+
+    def test_generic_lazy_reference_set(self):
+        class Animal(Document):
+            meta = {'allow_inheritance': True}
+
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            person = StringField()
+            animal = GenericLazyReferenceField()
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        class SubAnimal(Animal):
+            nick = StringField()
+
+        animal = Animal(name="Leopard", tag="heavy").save()
+        sub_animal = SubAnimal(nick='doggo', name='dog').save()
+        for ref in (
+                animal,
+                LazyReference(Animal, animal.pk),
+                {'_cls': 'Animal', '_ref': DBRef(animal._get_collection_name(), animal.pk)},
+
+                sub_animal,
+                LazyReference(SubAnimal, sub_animal.pk),
+                {'_cls': 'SubAnimal', '_ref': DBRef(sub_animal._get_collection_name(), sub_animal.pk)},
+                ):
+            p = Ocurrence(person="test", animal=ref).save()
+            p.reload()
+            self.assertIsInstance(p.animal, (LazyReference, Document))
+            p.animal.fetch()
+
+    def test_generic_lazy_reference_bad_set(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            person = StringField()
+            animal = GenericLazyReferenceField(choices=['Animal'])
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        class BadDoc(Document):
+            pass
+
+        animal = Animal(name="Leopard", tag="heavy").save()
+        baddoc = BadDoc().save()
+        for bad in (
+                42,
+                'foo',
+                baddoc,
+                LazyReference(BadDoc, animal.pk)
+                ):
+            with self.assertRaises(ValidationError):
+                p = Ocurrence(person="test", animal=bad).save()
+
+    def test_generic_lazy_reference_query_conversion(self):
+        class Member(Document):
+            user_num = IntField(primary_key=True)
+
+        class BlogPost(Document):
+            title = StringField()
+            author = GenericLazyReferenceField()
+
+        Member.drop_collection()
+        BlogPost.drop_collection()
+
+        m1 = Member(user_num=1)
+        m1.save()
+        m2 = Member(user_num=2)
+        m2.save()
+
+        post1 = BlogPost(title='post 1', author=m1)
+        post1.save()
+
+        post2 = BlogPost(title='post 2', author=m2)
+        post2.save()
+
+        post = BlogPost.objects(author=m1).first()
+        self.assertEqual(post.id, post1.id)
+
+        post = BlogPost.objects(author=m2).first()
+        self.assertEqual(post.id, post2.id)
+
+        # Same thing by passing a LazyReference instance
+        post = BlogPost.objects(author=LazyReference(Member, m2.pk)).first()
+        self.assertEqual(post.id, post2.id)
+
+    def test_generic_lazy_reference_not_set(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            person = StringField()
+            animal = GenericLazyReferenceField()
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        Ocurrence(person='foo').save()
+        p = Ocurrence.objects.get()
+        self.assertIs(p.animal, None)
+
+    def test_generic_lazy_reference_accepts_string_instead_of_class(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class Ocurrence(Document):
+            person = StringField()
+            animal = GenericLazyReferenceField('Animal')
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        animal = Animal().save()
+        Ocurrence(animal=animal).save()
+        p = Ocurrence.objects.get()
+        self.assertEqual(p.animal, animal)
+
+    def test_generic_lazy_reference_embedded(self):
+        class Animal(Document):
+            name = StringField()
+            tag = StringField()
+
+        class EmbeddedOcurrence(EmbeddedDocument):
+            in_list = ListField(GenericLazyReferenceField())
+            direct = GenericLazyReferenceField()
+
+        class Ocurrence(Document):
+            in_list = ListField(GenericLazyReferenceField())
+            in_embedded = EmbeddedDocumentField(EmbeddedOcurrence)
+            direct = GenericLazyReferenceField()
+
+        Animal.drop_collection()
+        Ocurrence.drop_collection()
+
+        animal1 = Animal('doggo').save()
+        animal2 = Animal('cheeta').save()
+
+        def check_fields_type(occ):
+            self.assertIsInstance(occ.direct, LazyReference)
+            for elem in occ.in_list:
+                self.assertIsInstance(elem, LazyReference)
+            self.assertIsInstance(occ.in_embedded.direct, LazyReference)
+            for elem in occ.in_embedded.in_list:
+                self.assertIsInstance(elem, LazyReference)
+
+        occ = Ocurrence(
+            in_list=[animal1, animal2],
+            in_embedded={'in_list': [animal1, animal2], 'direct': animal1},
+            direct=animal1
+        ).save()
+        check_fields_type(occ)
+        occ.reload()
+        check_fields_type(occ)
+        animal1_ref = {'_cls': 'Animal', '_ref': DBRef(animal1._get_collection_name(), animal1.pk)}
+        animal2_ref = {'_cls': 'Animal', '_ref': DBRef(animal2._get_collection_name(), animal2.pk)}
+        occ.direct = animal1_ref
+        occ.in_list = [animal1_ref, animal2_ref]
+        occ.in_embedded.direct = animal1_ref
+        occ.in_embedded.in_list = [animal1_ref, animal2_ref]
+        check_fields_type(occ)

tests/fields/test_long_field.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+import six
+
+try:
+    from bson.int64 import Int64
+except ImportError:
+    Int64 = long
+
+from mongoengine import *
+from mongoengine.connection import get_db
+
+from tests.utils import MongoDBTestCase
+
+
+class TestLongField(MongoDBTestCase):
+
+    def test_long_field_is_considered_as_int64(self):
+        """
+        Tests that long fields are stored as long in mongo, even if long
+        value is small enough to be an int.
+        """
+        class TestLongFieldConsideredAsInt64(Document):
+            some_long = LongField()
+
+        doc = TestLongFieldConsideredAsInt64(some_long=42).save()
+        db = get_db()
+        self.assertIsInstance(db.test_long_field_considered_as_int64.find()[0]['some_long'], Int64)
+        self.assertIsInstance(doc.some_long, six.integer_types)
+
+    def test_long_validation(self):
+        """Ensure that invalid values cannot be assigned to long fields.
+        """
+        class TestDocument(Document):
+            value = LongField(min_value=0, max_value=110)
+
+        doc = TestDocument()
+        doc.value = 50
+        doc.validate()
+
+        doc.value = -1
+        self.assertRaises(ValidationError, doc.validate)
+        doc.value = 120
+        self.assertRaises(ValidationError, doc.validate)
+        doc.value = 'ten'
+        self.assertRaises(ValidationError, doc.validate)
+
+    def test_long_ne_operator(self):
+        class TestDocument(Document):
+            long_fld = LongField()
+
+        TestDocument.drop_collection()
+
+        TestDocument(long_fld=None).save()
+        TestDocument(long_fld=1).save()
+
+        self.assertEqual(1, TestDocument.objects(long_fld__ne=None).count())

tests/fields/test_map_field.py

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+import datetime
+
+from mongoengine import *
+
+from tests.utils import MongoDBTestCase
+
+
+class TestMapField(MongoDBTestCase):
+
+    def test_mapfield(self):
+        """Ensure that the MapField handles the declared type."""
+        class Simple(Document):
+            mapping = MapField(IntField())
+
+        Simple.drop_collection()
+
+        e = Simple()
+        e.mapping['someint'] = 1
+        e.save()
+
+        with self.assertRaises(ValidationError):
+            e.mapping['somestring'] = "abc"
+            e.save()
+
+        with self.assertRaises(ValidationError):
+            class NoDeclaredType(Document):
+                mapping = MapField()
+
+    def test_complex_mapfield(self):
+        """Ensure that the MapField can handle complex declared types."""
+
+        class SettingBase(EmbeddedDocument):
+            meta = {"allow_inheritance": True}
+
+        class StringSetting(SettingBase):
+            value = StringField()
+
+        class IntegerSetting(SettingBase):
+            value = IntField()
+
+        class Extensible(Document):
+            mapping = MapField(EmbeddedDocumentField(SettingBase))
+
+        Extensible.drop_collection()
+
+        e = Extensible()
+        e.mapping['somestring'] = StringSetting(value='foo')
+        e.mapping['someint'] = IntegerSetting(value=42)
+        e.save()
+
+        e2 = Extensible.objects.get(id=e.id)
+        self.assertIsInstance(e2.mapping['somestring'], StringSetting)
+        self.assertIsInstance(e2.mapping['someint'], IntegerSetting)
+
+        with self.assertRaises(ValidationError):
+            e.mapping['someint'] = 123
+            e.save()
+
+    def test_embedded_mapfield_db_field(self):
+        class Embedded(EmbeddedDocument):
+            number = IntField(default=0, db_field='i')
+
+        class Test(Document):
+            my_map = MapField(field=EmbeddedDocumentField(Embedded),
+                              db_field='x')
+
+        Test.drop_collection()
+
+        test = Test()
+        test.my_map['DICTIONARY_KEY'] = Embedded(number=1)
+        test.save()
+
+        Test.objects.update_one(inc__my_map__DICTIONARY_KEY__number=1)
+
+        test = Test.objects.get()
+        self.assertEqual(test.my_map['DICTIONARY_KEY'].number, 2)
+        doc = self.db.test.find_one()
+        self.assertEqual(doc['x']['DICTIONARY_KEY']['i'], 2)
+
+    def test_mapfield_numerical_index(self):
+        """Ensure that MapField accept numeric strings as indexes."""
+
+        class Embedded(EmbeddedDocument):
+            name = StringField()
+
+        class Test(Document):
+            my_map = MapField(EmbeddedDocumentField(Embedded))
+
+        Test.drop_collection()
+
+        test = Test()
+        test.my_map['1'] = Embedded(name='test')
+        test.save()
+        test.my_map['1'].name = 'test updated'
+        test.save()
+
+    def test_map_field_lookup(self):
+        """Ensure MapField lookups succeed on Fields without a lookup
+        method.
+        """
+
+        class Action(EmbeddedDocument):
+            operation = StringField()
+            object = StringField()
+
+        class Log(Document):
+            name = StringField()
+            visited = MapField(DateTimeField())
+            actions = MapField(EmbeddedDocumentField(Action))
+
+        Log.drop_collection()
+        Log(name="wilson", visited={'friends': datetime.datetime.now()},
+            actions={'friends': Action(operation='drink', object='beer')}).save()
+
+        self.assertEqual(1, Log.objects(
+            visited__friends__exists=True).count())
+
+        self.assertEqual(1, Log.objects(
+            actions__friends__operation='drink',
+            actions__friends__object='beer').count())
+
+    def test_map_field_unicode(self):
+        class Info(EmbeddedDocument):
+            description = StringField()
+            value_list = ListField(field=StringField())
+
+        class BlogPost(Document):
+            info_dict = MapField(field=EmbeddedDocumentField(Info))
+
+        BlogPost.drop_collection()
+
+        tree = BlogPost(info_dict={
+            u"éééé": {
+                'description': u"VALUE: éééé"
+            }
+        })
+
+        tree.save()
+
+        self.assertEqual(
+            BlogPost.objects.get(id=tree.id).info_dict[u"éééé"].description,
+            u"VALUE: éééé"
+        )

tests/fields/test_reference_field.py

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+from bson import SON, DBRef
+
+from mongoengine import *
+
+from tests.utils import MongoDBTestCase
+
+
+class TestReferenceField(MongoDBTestCase):
+    def test_reference_validation(self):
+        """Ensure that invalid document objects cannot be assigned to
+        reference fields.
+        """
+
+        class User(Document):
+            name = StringField()
+
+        class BlogPost(Document):
+            content = StringField()
+            author = ReferenceField(User)
+
+        User.drop_collection()
+        BlogPost.drop_collection()
+
+        # Make sure ReferenceField only accepts a document class or a string
+        # with a document class name.
+        self.assertRaises(ValidationError, ReferenceField, EmbeddedDocument)
+
+        user = User(name='Test User')
+
+        # Ensure that the referenced object must have been saved
+        post1 = BlogPost(content='Chips and gravy taste good.')
+        post1.author = user
+        self.assertRaises(ValidationError, post1.save)
+
+        # Check that an invalid object type cannot be used
+        post2 = BlogPost(content='Chips and chilli taste good.')
+        post1.author = post2
+        self.assertRaises(ValidationError, post1.validate)
+
+        # Ensure ObjectID's are accepted as references
+        user_object_id = user.pk
+        post3 = BlogPost(content="Chips and curry sauce taste good.")
+        post3.author = user_object_id
+        post3.save()
+
+        # Make sure referencing a saved document of the right type works
+        user.save()
+        post1.author = user
+        post1.save()
+
+        # Make sure referencing a saved document of the *wrong* type fails
+        post2.save()
+        post1.author = post2
+        self.assertRaises(ValidationError, post1.validate)
+
+    def test_objectid_reference_fields(self):
+        """Make sure storing Object ID references works."""
+
+        class Person(Document):
+            name = StringField()
+            parent = ReferenceField('self')
+
+        Person.drop_collection()
+
+        p1 = Person(name="John").save()
+        Person(name="Ross", parent=p1.pk).save()
+
+        p = Person.objects.get(name="Ross")
+        self.assertEqual(p.parent, p1)
+
+    def test_dbref_reference_fields(self):
+        """Make sure storing references as bson.dbref.DBRef works."""
+
+        class Person(Document):
+            name = StringField()
+            parent = ReferenceField('self', dbref=True)
+
+        Person.drop_collection()
+
+        p1 = Person(name="John").save()
+        Person(name="Ross", parent=p1).save()
+
+        self.assertEqual(
+            Person._get_collection().find_one({'name': 'Ross'})['parent'],
+            DBRef('person', p1.pk)
+        )
+
+        p = Person.objects.get(name="Ross")
+        self.assertEqual(p.parent, p1)
+
+    def test_dbref_to_mongo(self):
+        """Make sure that calling to_mongo on a ReferenceField which
+        has dbref=False, but actually actually contains a DBRef returns
+        an ID of that DBRef.
+        """
+
+        class Person(Document):
+            name = StringField()
+            parent = ReferenceField('self', dbref=False)
+
+        p = Person(
+            name='Steve',
+            parent=DBRef('person', 'abcdefghijklmnop')
+        )
+        self.assertEqual(p.to_mongo(), SON([
+            ('name', u'Steve'),
+            ('parent', 'abcdefghijklmnop')
+        ]))
+
+    def test_objectid_reference_fields(self):
+        class Person(Document):
+            name = StringField()
+            parent = ReferenceField('self', dbref=False)
+
+        Person.drop_collection()
+
+        p1 = Person(name="John").save()
+        Person(name="Ross", parent=p1).save()
+
+        col = Person._get_collection()
+        data = col.find_one({'name': 'Ross'})
+        self.assertEqual(data['parent'], p1.pk)
+
+        p = Person.objects.get(name="Ross")
+        self.assertEqual(p.parent, p1)
+
+    def test_undefined_reference(self):
+        """Ensure that ReferenceFields may reference undefined Documents.
+        """
+        class Product(Document):
+            name = StringField()
+            company = ReferenceField('Company')
+
+        class Company(Document):
+            name = StringField()
+
+        Product.drop_collection()
+        Company.drop_collection()
+
+        ten_gen = Company(name='10gen')
+        ten_gen.save()
+        mongodb = Product(name='MongoDB', company=ten_gen)
+        mongodb.save()
+
+        me = Product(name='MongoEngine')
+        me.save()
+
+        obj = Product.objects(company=ten_gen).first()
+        self.assertEqual(obj, mongodb)
+        self.assertEqual(obj.company, ten_gen)
+
+        obj = Product.objects(company=None).first()
+        self.assertEqual(obj, me)
+
+        obj = Product.objects.get(company=None)
+        self.assertEqual(obj, me)
+
+    def test_reference_query_conversion(self):
+        """Ensure that ReferenceFields can be queried using objects and values
+        of the type of the primary key of the referenced object.
+        """
+        class Member(Document):
+            user_num = IntField(primary_key=True)
+
+        class BlogPost(Document):
+            title = StringField()
+            author = ReferenceField(Member, dbref=False)
+
+        Member.drop_collection()
+        BlogPost.drop_collection()
+
+        m1 = Member(user_num=1)
+        m1.save()
+        m2 = Member(user_num=2)
+        m2.save()
+
+        post1 = BlogPost(title='post 1', author=m1)
+        post1.save()
+
+        post2 = BlogPost(title='post 2', author=m2)
+        post2.save()
+
+        post = BlogPost.objects(author=m1).first()
+        self.assertEqual(post.id, post1.id)
+
+        post = BlogPost.objects(author=m2).first()
+        self.assertEqual(post.id, post2.id)
+
+    def test_reference_query_conversion_dbref(self):
+        """Ensure that ReferenceFields can be queried using objects and values
+        of the type of the primary key of the referenced object.
+        """
+        class Member(Document):
+            user_num = IntField(primary_key=True)
+
+        class BlogPost(Document):
+            title = StringField()
+            author = ReferenceField(Member, dbref=True)
+
+        Member.drop_collection()
+        BlogPost.drop_collection()
+
+        m1 = Member(user_num=1)
+        m1.save()
+        m2 = Member(user_num=2)
+        m2.save()
+
+        post1 = BlogPost(title='post 1', author=m1)
+        post1.save()
+
+        post2 = BlogPost(title='post 2', author=m2)
+        post2.save()
+
+        post = BlogPost.objects(author=m1).first()
+        self.assertEqual(post.id, post1.id)
+
+        post = BlogPost.objects(author=m2).first()
+        self.assertEqual(post.id, post2.id)