From 54d8c64ad5c643c1a3acda82e1b9f6da22e73146 Mon Sep 17 00:00:00 2001 From: Freyr Date: Thu, 25 May 2017 10:44:29 -0400 Subject: [PATCH 001/250] Fixes query operations on BinaryFields Overrides prepare_query_value in BinaryField to wrap the query value in bson.binary.Binary. This was already done in the to_mongo call when saving a document, but query operations required the user to convert the value manually. Fixes https://github.com/MongoEngine/mongoengine/issues/1127 --- mongoengine/fields.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 0d402712..c52c6786 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1393,6 +1393,12 @@ class BinaryField(BaseField): if self.max_bytes is not None and len(value) > self.max_bytes: self.error('Binary value is too long') + def prepare_query_value(self, op, value): + if value is None: + return value + return super(BinaryField, self).prepare_query_value( + op, self.to_mongo(value)) + class GridFSError(Exception): pass From b9e922c658f6275fc8446bf1ffdedf688f708f25 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 12 Jun 2017 04:50:13 +0000 Subject: [PATCH 002/250] support multiple operator #1510 --- AUTHORS | 1 + mongoengine/base/common.py | 7 ++++--- tests/queryset/queryset.py | 14 ++++++++++++++ 3 files changed, 19 insertions(+), 3 deletions(-) diff --git a/AUTHORS b/AUTHORS index 1d724718..88d4bbe1 100644 --- a/AUTHORS +++ b/AUTHORS @@ -243,3 +243,4 @@ that much better: * Victor Varvaryuk * Stanislav Kaledin (https://github.com/sallyruthstruik) * Dmitry Yantsen (https://github.com/mrTable) + * Erdenezul Batmunkh (https://github.com/erdenezul) diff --git a/mongoengine/base/common.py b/mongoengine/base/common.py index b9971ff7..f80471ef 100644 --- a/mongoengine/base/common.py +++ b/mongoengine/base/common.py @@ -3,9 +3,10 @@ from mongoengine.errors import NotRegistered __all__ = ('UPDATE_OPERATORS', 'get_document', '_document_registry') -UPDATE_OPERATORS = set(['set', 'unset', 'inc', 'dec', 'pop', 'push', - 'push_all', 'pull', 'pull_all', 'add_to_set', - 'set_on_insert', 'min', 'max', 'rename']) +UPDATE_OPERATORS = set(['set', 'unset', 'inc', 'dec', 'mul', + 'pop', 'push', 'push_all', 'pull', + 'pull_all', 'add_to_set', 'set_on_insert', + 'min', 'max', 'rename']) _document_registry = {} diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index d97b307d..7666d030 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -589,6 +589,20 @@ class QuerySetTest(unittest.TestCase): Scores.objects(id=scores.id).update(max__high_score=500) self.assertEqual(Scores.objects.get(id=scores.id).high_score, 1000) + @needs_mongodb_v26 + def test_update_multiple(self): + class Product(Document): + item = StringField() + price = FloatField() + + product = Product.objects.create(item='ABC', price=10.99) + product = Product.objects.create(item='ABC', price=10.99) + Product.objects(id=product.id).update(mul__price=1.25) + self.assertEqual(Product.objects.get(id=product.id).price, 13.7375) + unknown_product = Product.objects.create(item='Unknown') + Product.objects(id=unknown_product.id).update(mul__price=100) + self.assertEqual(Product.objects.get(id=unknown_product.id).price, 0) + def test_updates_can_have_match_operators(self): class Comment(EmbeddedDocument): From 6903eed4e770bcb605df948728121ce75149d0fa Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Thu, 15 Jun 2017 06:08:40 +0000 Subject: [PATCH 003/250] support position in 'push' #1565 --- mongoengine/queryset/transform.py | 16 +++++++++++++--- tests/queryset/queryset.py | 23 +++++++++++++++++++++++ 2 files changed, 36 insertions(+), 3 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index bb04ee37..2c1b7fdc 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -284,9 +284,11 @@ def update(_doc_cls=None, **update): if isinstance(field, GeoJsonBaseField): value = field.to_mongo(value) - if op in (None, 'set', 'push', 'pull'): + if 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', 'pull'): if field.required or value is not None: - value = field.prepare_query_value(op, value) + value = field.prepare_query_value(op, value) elif op in ('pushAll', 'pullAll'): value = [field.prepare_query_value(op, v) for v in value] elif op in ('addToSet', 'setOnInsert'): @@ -302,6 +304,10 @@ def update(_doc_cls=None, **update): value = {match: value} key = '.'.join(parts) + position = None + if parts[-1].isdigit() and isinstance(value, (list, tuple, set)): + key = parts[0] + position = int(parts[-1]) if not op: raise InvalidQueryError('Updates must supply an operation ' @@ -333,10 +339,14 @@ def update(_doc_cls=None, **update): value = {key: value} elif op == 'addToSet' and isinstance(value, list): value = {key: {'$each': value}} + elif op == 'push' and isinstance(value, list): + if position is not None: + value = {key: {'$each': value, '$position': position}} + else: + value = {key: {'$each': 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): diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index d97b307d..9341a214 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -1903,6 +1903,29 @@ class QuerySetTest(unittest.TestCase): BlogPost.drop_collection() + def test_update_push_with_position(self): + """Ensure that the 'push' update with position works properly. + """ + class BlogPost(Document): + slug = StringField() + tags = ListField(StringField()) + + BlogPost.drop_collection() + + post = BlogPost(slug="test") + post.save() + + BlogPost.objects.filter(id=post.id).update(push__tags="code") + BlogPost.objects.filter(id=post.id).update(push__tags__0=["mongodb", "python"]) + post.reload() + self.assertEqual(post.tags[0], "mongodb") + self.assertEqual(post.tags[1], "python") + self.assertEqual(post.tags[2], "code") + + BlogPost.objects.filter(id=post.id).update(set__tags__2="java") + post.reload() + self.assertEqual(post.tags[2], "java") + def test_update_push_and_pull_add_to_set(self): """Ensure that the 'pull' update operation works correctly. """ From f63ad2dd69c40d87962fe05137e618c09418ed5e Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Thu, 15 Jun 2017 07:36:14 +0000 Subject: [PATCH 004/250] dont test in mongoDB v2.4 #1565 --- tests/queryset/queryset.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 9341a214..7be3f8d7 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -1903,6 +1903,7 @@ class QuerySetTest(unittest.TestCase): BlogPost.drop_collection() + @needs_mongodb_v26 def test_update_push_with_position(self): """Ensure that the 'push' update with position works properly. """ From 1d4b1870cfb50e3b91b0fe187874c31d5373ea65 Mon Sep 17 00:00:00 2001 From: Danil Date: Mon, 19 Jun 2017 05:04:46 +0500 Subject: [PATCH 005/250] to_db_fields fix (#1553) --- mongoengine/queryset/base.py | 4 ++-- tests/queryset/field_list.py | 9 ++++++++- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index f7c32d20..41a10ace 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -1731,14 +1731,14 @@ class BaseQuerySet(object): for x in document._subclasses][1:] for field in fields: try: - field = '.'.join(f.db_field for f in + field = '.'.join(f if isinstance(f, six.string_types) else f.db_field for f in document._lookup_field(field.split('.'))) ret.append(field) except LookUpError as err: found = False for subdoc in subclasses: try: - subfield = '.'.join(f.db_field for f in + subfield = '.'.join(f if isinstance(f, six.string_types) else f.db_field for f in subdoc._lookup_field(field.split('.'))) ret.append(subfield) found = True diff --git a/tests/queryset/field_list.py b/tests/queryset/field_list.py index d1277e06..c07cec3e 100644 --- a/tests/queryset/field_list.py +++ b/tests/queryset/field_list.py @@ -197,14 +197,18 @@ class OnlyExcludeAllTest(unittest.TestCase): title = StringField() text = StringField() + class VariousData(EmbeddedDocument): + some = BooleanField() + class BlogPost(Document): content = StringField() author = EmbeddedDocumentField(User) comments = ListField(EmbeddedDocumentField(Comment)) + various = MapField(field=EmbeddedDocumentField(VariousData)) BlogPost.drop_collection() - post = BlogPost(content='Had a good coffee today...') + post = BlogPost(content='Had a good coffee today...', various={'test_dynamic':{'some': True}}) post.author = User(name='Test User') post.comments = [Comment(title='I aggree', text='Great post!'), Comment(title='Coffee', text='I hate coffee')] post.save() @@ -215,6 +219,9 @@ class OnlyExcludeAllTest(unittest.TestCase): self.assertEqual(obj.author.name, 'Test User') self.assertEqual(obj.comments, []) + obj = BlogPost.objects.only('various.test_dynamic.some').get() + self.assertEqual(obj.various["test_dynamic"].some, True) + obj = BlogPost.objects.only('content', 'comments.title',).get() self.assertEqual(obj.content, 'Had a good coffee today...') self.assertEqual(obj.author, None) From a8d6e59a7a0434edebcb52ca63e40be5466548fa Mon Sep 17 00:00:00 2001 From: Stefan Wojcik Date: Sun, 18 Jun 2017 17:25:39 -0700 Subject: [PATCH 006/250] minor tweaks to code quality in _fields_to_dbfields --- mongoengine/queryset/base.py | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 41a10ace..6f9c372c 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -1722,25 +1722,33 @@ class BaseQuerySet(object): return frequencies def _fields_to_dbfields(self, fields): - """Translate fields paths to its db equivalents""" - ret = [] + """Translate fields' paths to their db equivalents.""" subclasses = [] - document = self._document - if document._meta['allow_inheritance']: + if self._document._meta['allow_inheritance']: subclasses = [get_document(x) - for x in document._subclasses][1:] + for x in self._document._subclasses][1:] + + db_field_paths = [] for field in fields: + field_parts = field.split('.') try: - field = '.'.join(f if isinstance(f, six.string_types) else f.db_field for f in - document._lookup_field(field.split('.'))) - ret.append(field) + field = '.'.join( + f if isinstance(f, six.string_types) else f.db_field + for f in self._document._lookup_field(field_parts) + ) + db_field_paths.append(field) except LookUpError as err: found = False + + # If a field path wasn't found on the main document, go + # through its subclasses and see if it exists on any of them. for subdoc in subclasses: try: - subfield = '.'.join(f if isinstance(f, six.string_types) else f.db_field for f in - subdoc._lookup_field(field.split('.'))) - ret.append(subfield) + subfield = '.'.join( + f if isinstance(f, six.string_types) else f.db_field + for f in subdoc._lookup_field(field_parts) + ) + db_field_paths.append(subfield) found = True break except LookUpError: @@ -1748,7 +1756,8 @@ class BaseQuerySet(object): if not found: raise err - return ret + + return db_field_paths def _get_order_by(self, keys): """Given a list of MongoEngine-style sort keys, return a list From f3ee4a5dac9a6bcccdd11f9be3afc702e344e8a2 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 19 Jun 2017 02:59:17 +0000 Subject: [PATCH 007/250] add tests for push operator #1565 --- AUTHORS | 1 + tests/document/instance.py | 41 ++++++++++++++++++++++++++++++++++++++ tests/queryset/modify.py | 25 ++++++++++++++++++++++- 3 files changed, 66 insertions(+), 1 deletion(-) diff --git a/AUTHORS b/AUTHORS index 1d724718..88d4bbe1 100644 --- a/AUTHORS +++ b/AUTHORS @@ -243,3 +243,4 @@ that much better: * Victor Varvaryuk * Stanislav Kaledin (https://github.com/sallyruthstruik) * Dmitry Yantsen (https://github.com/mrTable) + * Erdenezul Batmunkh (https://github.com/erdenezul) diff --git a/tests/document/instance.py b/tests/document/instance.py index 37bbe337..1456f0a1 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -22,6 +22,8 @@ from mongoengine.queryset import NULLIFY, Q from mongoengine.context_managers import switch_db, query_counter from mongoengine import signals +from tests.utils import needs_mongodb_v26 + TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__), '../fields/mongoengine.png') @@ -775,6 +777,7 @@ class InstanceTest(unittest.TestCase): self.assertDbEqual([dict(doc.to_mongo())]) + def test_modify_invalid_query(self): doc1 = self.Person(name="bob", age=10).save() doc2 = self.Person(name="jim", age=20).save() @@ -826,6 +829,27 @@ class InstanceTest(unittest.TestCase): self.assertDbEqual([dict(other_doc.to_mongo()), dict(doc.to_mongo())]) + @needs_mongodb_v26 + def test_modity_push_position(self): + class BlogPost(Document): + slug = StringField() + tags = ListField(StringField()) + + other_blog = BlogPost(slug="ABC", tags=["code", "java", "python"]).save() + + blog = BlogPost(slug="ABC", tags=["python"]).save() + blog_copy = blog._from_son(blog.to_mongo()) + + assert blog.modify(push__tags__0=["code", "java"]) + blog_copy.tags = ["code", "java", "python"] + assert blog.to_json() == blog_copy.to_json() + assert blog._get_changed_fields() == [] + + docs = [dict(other_blog.to_mongo()), dict(blog.to_mongo())] + self.assertEqual( + list(BlogPost._get_collection().find().sort("id")), + sorted(docs, key=lambda doc: doc["_id"])) + def test_save(self): """Ensure that a document may be saved in the database.""" @@ -3149,6 +3173,23 @@ class InstanceTest(unittest.TestCase): person.update(set__height=2.0) + @needs_mongodb_v26 + def test_push_with_position(self): + """Ensure that push with position works properly for an instance.""" + class BlogPost(Document): + slug = StringField() + tags = ListField(StringField()) + + blog = BlogPost() + blog.slug = "ABC" + blog.tags = ["python"] + blog.save() + + blog.update(push__tags__0=["mongodb", "code"]) + blog.reload() + self.assertEqual(blog.tags[0], "mongodb") + self.assertEqual(blog.tags[2], "python") + if __name__ == '__main__': unittest.main() diff --git a/tests/queryset/modify.py b/tests/queryset/modify.py index 607937f6..4bda9718 100644 --- a/tests/queryset/modify.py +++ b/tests/queryset/modify.py @@ -1,6 +1,6 @@ import unittest -from mongoengine import connect, Document, IntField +from mongoengine import connect, Document, IntField, StringField, ListField __all__ = ("FindAndModifyTest",) @@ -94,6 +94,29 @@ class FindAndModifyTest(unittest.TestCase): self.assertEqual(old_doc.to_mongo(), {"_id": 1}) self.assertDbEqual([{"_id": 0, "value": 0}, {"_id": 1, "value": -1}]) + def test_modify_with_push(self): + class BlogPost(Document): + id = StringField(primary_key=True) + tags = ListField(StringField()) + + BlogPost.drop_collection() + + BlogPost(id="ABC").save() + BlogPost(id="BCD").save() + blog = BlogPost.objects(id="ABC").modify(push__tags="code") + + self.assertEqual(blog.to_mongo(), {"_id": "ABC", "tags": []}) + docs = [{"_id": "ABC", "tags":["code"]}, {"_id": "BCD", "tags":[]}] + self.assertEqual(list(BlogPost._collection.find().sort("id")), docs) + + another_blog = BlogPost.objects(id="BCD").modify(push__tags="java") + self.assertEqual(another_blog.to_mongo(), {"_id": "BCD", "tags": []}) + another_blog = BlogPost.objects(id="BCD").modify(push__tags__0=["python"]) + self.assertEqual(another_blog.to_mongo(), {"_id": "BCD", "tags": ["java"]}) + docs = [{"_id": "ABC", "tags":["code"]}, + {"_id": "BCD", "tags":["python", "java"]}] + self.assertEqual(list(BlogPost._collection.find().sort("id")), docs) + if __name__ == '__main__': unittest.main() From 7782aa7379306c8223edd33aeec6b47f2f145b83 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 19 Jun 2017 03:11:59 +0000 Subject: [PATCH 008/250] do not test position push in mongodb_v2.4 #1565 --- tests/document/instance.py | 1 - tests/queryset/modify.py | 3 +++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/document/instance.py b/tests/document/instance.py index 1456f0a1..26ab0d97 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -777,7 +777,6 @@ class InstanceTest(unittest.TestCase): self.assertDbEqual([dict(doc.to_mongo())]) - def test_modify_invalid_query(self): doc1 = self.Person(name="bob", age=10).save() doc2 = self.Person(name="jim", age=20).save() diff --git a/tests/queryset/modify.py b/tests/queryset/modify.py index 4bda9718..44bdc3ff 100644 --- a/tests/queryset/modify.py +++ b/tests/queryset/modify.py @@ -2,6 +2,8 @@ import unittest from mongoengine import connect, Document, IntField, StringField, ListField +from tests.utils import needs_mongodb_v26 + __all__ = ("FindAndModifyTest",) @@ -94,6 +96,7 @@ class FindAndModifyTest(unittest.TestCase): self.assertEqual(old_doc.to_mongo(), {"_id": 1}) self.assertDbEqual([{"_id": 0, "value": 0}, {"_id": 1, "value": -1}]) + @needs_mongodb_v26 def test_modify_with_push(self): class BlogPost(Document): id = StringField(primary_key=True) From fb00b79d1945a05c08f642aa35efbba5e92558a8 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 19 Jun 2017 03:28:34 +0000 Subject: [PATCH 009/250] add docs for positional push operator #1565 --- docs/guide/querying.rst | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/guide/querying.rst b/docs/guide/querying.rst index 0bb19658..f1594dd2 100644 --- a/docs/guide/querying.rst +++ b/docs/guide/querying.rst @@ -565,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 From 71c3c632d7efb673aad2f1e79e564537df202e7b Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 19 Jun 2017 06:00:21 +0000 Subject: [PATCH 010/250] add test case for reverse_delete_rule with pull #1519 --- tests/document/instance.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/tests/document/instance.py b/tests/document/instance.py index 37bbe337..f9f4285e 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -1866,6 +1866,25 @@ class InstanceTest(unittest.TestCase): author.delete() self.assertEqual(BlogPost.objects.count(), 0) + def test_reverse_delete_rule_pull(self): + """Ensure that a referenced document is also deleted with + pull. + """ + class Record(Document): + name = StringField() + children = ListField(ReferenceField('self', reverse_delete_rule=PULL)) + + Record.drop_collection() + + parent_record = Record(name='parent').save() + child_record = Record(name='child').save() + parent_record.children.append(child_record) + parent_record.save() + + child_record.delete() + self.assertEqual(Record.objects(name='parent').get().children, []) + + def test_reverse_delete_rule_with_custom_id_field(self): """Ensure that a referenced document with custom primary key is also deleted upon deletion. From 0bc6507df34710de0a8fb16b0b45f48d8d6aec5b Mon Sep 17 00:00:00 2001 From: Benoit Larroque Date: Tue, 27 Jun 2017 00:43:41 +0200 Subject: [PATCH 011/250] Make queryset aggregates obey read_preference --- mongoengine/queryset/base.py | 4 ++++ tests/queryset/queryset.py | 20 ++++++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 6f9c372c..090ed906 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -1182,6 +1182,10 @@ class BaseQuerySet(object): pipeline = initial_pipeline + list(pipeline) + if IS_PYMONGO_3 and self._read_preference is not None: + return self._collection.with_options(read_preference=self._read_preference) \ + .aggregate(pipeline, cursor={}, **kwargs) + return self._collection.aggregate(pipeline, cursor={}, **kwargs) # JS functionality diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index d97b307d..e0eb7d38 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4353,6 +4353,26 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(bars._cursor._Cursor__read_preference, ReadPreference.SECONDARY_PREFERRED) + @needs_mongodb_v26 + def test_read_preference_aggregation_framework(self): + class Bar(Document): + txt = StringField() + + meta = { + 'indexes': ['txt'] + } + # Aggregates with read_preference + bars = Bar.objects \ + .read_preference(ReadPreference.SECONDARY_PREFERRED) \ + .aggregate() + if IS_PYMONGO_3: + self.assertEqual(bars._CommandCursor__collection.read_preference, + ReadPreference.SECONDARY_PREFERRED) + else: + self.assertNotEqual(bars._CommandCursor__collection.read_preference, + ReadPreference.SECONDARY_PREFERRED) + + def test_json_simple(self): class Embedded(EmbeddedDocument): From e6a30f899c9bb6cdb28e2302967e6dc96ceac055 Mon Sep 17 00:00:00 2001 From: "Bo.Yi" Date: Thu, 6 Jul 2017 14:57:03 +0800 Subject: [PATCH 012/250] [fix]validation list field with multi choice values --- mongoengine/base/document.py | 6 +++++- mongoengine/base/fields.py | 6 ++++-- tests/fields/fields.py | 18 ++++++++++++++++++ 3 files changed, 27 insertions(+), 3 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 99c8af87..43158133 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -1080,5 +1080,9 @@ class BaseDocument(object): """Return the display value for a choice field""" value = getattr(self, field.name) if field.choices and isinstance(field.choices[0], (list, tuple)): - return dict(field.choices).get(value, value) + sep = getattr(field, 'display_sep', u' ') + values = value if field.__name__ == 'ListField' else [value] + return sep.join([ + dict(field.choices).get(val, val) + for val in values]) return value diff --git a/mongoengine/base/fields.py b/mongoengine/base/fields.py index e2b5d321..69034d5d 100644 --- a/mongoengine/base/fields.py +++ b/mongoengine/base/fields.py @@ -213,8 +213,10 @@ class BaseField(object): ) ) # Choices which are types other than Documents - elif value not in choice_list: - self.error('Value must be one of %s' % six.text_type(choice_list)) + 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 diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 7a0ccc25..b6628ab0 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -920,6 +920,12 @@ class FieldTest(MongoDBTestCase): def test_list_validation(self): """Ensure that a list field only accepts lists with valid elements.""" + AccessLevelChoices = ( + ('a', u'Administrator'), + ('b', u'Manager'), + ('c', u'Staff'), + ) + class User(Document): pass @@ -932,6 +938,7 @@ class FieldTest(MongoDBTestCase): tags = ListField(StringField()) authors = ListField(ReferenceField(User)) generic = ListField(GenericReferenceField()) + access_list = ListField(required=False, default=[], choices=AccessLevelChoices, display_sep=u',') User.drop_collection() BlogPost.drop_collection() @@ -949,6 +956,17 @@ class FieldTest(MongoDBTestCase): post.tags = ('fun', 'leisure') post.validate() + post.access_list = 'a,b' + self.assertRaises(ValidationError, post.validate()) + + post.access_list = ['c', 'd'] + self.assertRaises(ValidationError, post.validate()) + + post.access_list = ['a', 'b'] + post.validate() + + self.assertEqual(post.get_access_list_display(), u'Administrator,Manager') + post.comments = ['a'] self.assertRaises(ValidationError, post.validate) post.comments = 'yay' From 820b5cbb86a0cc9dff65db35b0f806fb811a512b Mon Sep 17 00:00:00 2001 From: "Bo.Yi" Date: Thu, 6 Jul 2017 16:07:51 +0800 Subject: [PATCH 013/250] [fix]pass test case and fix field type error --- mongoengine/base/document.py | 6 ++++-- tests/fields/fields.py | 4 ++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 43158133..42a8bb4b 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -1080,9 +1080,11 @@ class BaseDocument(object): """Return the display value for a choice field""" value = getattr(self, field.name) if field.choices and isinstance(field.choices[0], (list, tuple)): + if value is None: + return None sep = getattr(field, 'display_sep', u' ') - values = value if field.__name__ == 'ListField' else [value] + values = value if field.__class__.__name__ == 'ListField' else [value] return sep.join([ dict(field.choices).get(val, val) - for val in values]) + for val in values or []]) return value diff --git a/tests/fields/fields.py b/tests/fields/fields.py index b6628ab0..336e116c 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -957,10 +957,10 @@ class FieldTest(MongoDBTestCase): post.validate() post.access_list = 'a,b' - self.assertRaises(ValidationError, post.validate()) + self.assertRaises(ValidationError, post.validate) post.access_list = ['c', 'd'] - self.assertRaises(ValidationError, post.validate()) + self.assertRaises(ValidationError, post.validate) post.access_list = ['a', 'b'] post.validate() From 437b11af9ac3f2a160868265337a22eb6fcb6ff5 Mon Sep 17 00:00:00 2001 From: Alex Xu Date: Mon, 10 Jul 2017 16:43:24 -0400 Subject: [PATCH 014/250] docs: use explicit register_delete_rule example The previous example of creating bi-directional delete rules was vague since the example defined only one class and the relationship between "Foo" and "Bar" wasn't clear. I added a more explicit example where the relationship between the two classes is explicit. --- mongoengine/fields.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 0d402712..0029d68b 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -971,11 +971,13 @@ class ReferenceField(BaseField): .. code-block:: python - class Bar(Document): - content = StringField() - foo = ReferenceField('Foo') + class Org(Document): + owner = ReferenceField('User') - Foo.register_delete_rule(Bar, 'foo', NULLIFY) + class User(Document): + org = ReferenceField('Org', reverse_delete_rule=CASCADE) + + User.register_delete_rule(Org, 'owner', DENY) .. versionchanged:: 0.5 added `reverse_delete_rule` """ From a7cab513695ba1814d9316719429d63249fb97dc Mon Sep 17 00:00:00 2001 From: Davidrjx <1058960881@qq.com> Date: Thu, 13 Jul 2017 18:07:36 +0800 Subject: [PATCH 015/250] Use a set literal in _clean_settings (#1585) --- AUTHORS | 1 + mongoengine/connection.py | 11 ++++++----- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/AUTHORS b/AUTHORS index 1d724718..96a7850e 100644 --- a/AUTHORS +++ b/AUTHORS @@ -243,3 +243,4 @@ that much better: * Victor Varvaryuk * Stanislav Kaledin (https://github.com/sallyruthstruik) * Dmitry Yantsen (https://github.com/mrTable) + * Renjianxin (https://github.com/Davidrjx) diff --git a/mongoengine/connection.py b/mongoengine/connection.py index 7eae810f..34ff4dc3 100644 --- a/mongoengine/connection.py +++ b/mongoengine/connection.py @@ -146,13 +146,14 @@ def get_connection(alias=DEFAULT_CONNECTION_NAME, reconnect=False): raise MongoEngineConnectionError(msg) def _clean_settings(settings_dict): - irrelevant_fields = set([ - 'name', 'username', 'password', 'authentication_source', - 'authentication_mechanism' - ]) + # set literal more efficient than calling set function + 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 + if k not in irrelevant_fields_set } # Retrieve a copy of the connection settings associated with the requested From 3dcc9bc1433e550a3151ade5f31efef7e39f2be3 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Thu, 13 Jul 2017 22:59:21 +0800 Subject: [PATCH 016/250] use explicit tests and fix unneccessary indent #1565 --- mongoengine/queryset/transform.py | 2 +- tests/document/instance.py | 26 ++++++++++---------------- tests/queryset/queryset.py | 6 ++---- 3 files changed, 13 insertions(+), 21 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index 2c1b7fdc..b9c8b130 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -288,7 +288,7 @@ def update(_doc_cls=None, **update): value = [field.prepare_query_value(op, v) for v in value] elif op in (None, 'set', 'push', 'pull'): if field.required or value is not None: - value = field.prepare_query_value(op, value) + value = field.prepare_query_value(op, value) elif op in ('pushAll', 'pullAll'): value = [field.prepare_query_value(op, v) for v in value] elif op in ('addToSet', 'setOnInsert'): diff --git a/tests/document/instance.py b/tests/document/instance.py index 26ab0d97..609bc900 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -829,25 +829,20 @@ class InstanceTest(unittest.TestCase): self.assertDbEqual([dict(other_doc.to_mongo()), dict(doc.to_mongo())]) @needs_mongodb_v26 - def test_modity_push_position(self): + def test_modify_with_positional_push(self): class BlogPost(Document): - slug = StringField() tags = ListField(StringField()) - other_blog = BlogPost(slug="ABC", tags=["code", "java", "python"]).save() + post = BlogPost.objects.create(tags=['python']) + self.assertEqual(post.tags, ['python']) + post.modify(push__tags__0=['code', 'mongo']) + self.assertEqual(post.tags, ['code', 'mongo', 'python']) - blog = BlogPost(slug="ABC", tags=["python"]).save() - blog_copy = blog._from_son(blog.to_mongo()) - - assert blog.modify(push__tags__0=["code", "java"]) - blog_copy.tags = ["code", "java", "python"] - assert blog.to_json() == blog_copy.to_json() - assert blog._get_changed_fields() == [] - - docs = [dict(other_blog.to_mongo()), dict(blog.to_mongo())] + # Assert same order of the list items is maintained in the db self.assertEqual( - list(BlogPost._get_collection().find().sort("id")), - sorted(docs, key=lambda doc: doc["_id"])) + BlogPost._get_collection().find_one({'_id': post.pk})['tags'], + ['code', 'mongo', 'python'] + ) def test_save(self): """Ensure that a document may be saved in the database.""" @@ -3186,8 +3181,7 @@ class InstanceTest(unittest.TestCase): blog.update(push__tags__0=["mongodb", "code"]) blog.reload() - self.assertEqual(blog.tags[0], "mongodb") - self.assertEqual(blog.tags[2], "python") + self.assertEqual(blog.tags, ['mongodb', 'code', 'python']) if __name__ == '__main__': diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 7be3f8d7..f4e4670d 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -1919,13 +1919,11 @@ class QuerySetTest(unittest.TestCase): BlogPost.objects.filter(id=post.id).update(push__tags="code") BlogPost.objects.filter(id=post.id).update(push__tags__0=["mongodb", "python"]) post.reload() - self.assertEqual(post.tags[0], "mongodb") - self.assertEqual(post.tags[1], "python") - self.assertEqual(post.tags[2], "code") + self.assertEqual(post.tags, ['mongodb', 'python', 'code']) BlogPost.objects.filter(id=post.id).update(set__tags__2="java") post.reload() - self.assertEqual(post.tags[2], "java") + self.assertEqual(post.tags, ['mongodb', 'python', 'java']) def test_update_push_and_pull_add_to_set(self): """Ensure that the 'pull' update operation works correctly. From 9f02f71c52f5f9c02cbd3db797ae80aea36d0639 Mon Sep 17 00:00:00 2001 From: "Bo.Yi" Date: Sun, 16 Jul 2017 18:47:20 +0800 Subject: [PATCH 017/250] [fix]fix some personal hobby --- mongoengine/base/document.py | 4 ++-- tests/fields/fields.py | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 42a8bb4b..bb8d3a16 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -1082,8 +1082,8 @@ class BaseDocument(object): if field.choices and isinstance(field.choices[0], (list, tuple)): if value is None: return None - sep = getattr(field, 'display_sep', u' ') - values = value if field.__class__.__name__ == 'ListField' else [value] + sep = getattr(field, 'display_sep', ' ') + values = value if field.__class__.__name__ in ('ListField', 'SortedListField') else [value] return sep.join([ dict(field.choices).get(val, val) for val in values or []]) diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 336e116c..1dc25d12 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -921,7 +921,7 @@ class FieldTest(MongoDBTestCase): def test_list_validation(self): """Ensure that a list field only accepts lists with valid elements.""" AccessLevelChoices = ( - ('a', u'Administrator'), + ('a', u'Administration'), ('b', u'Manager'), ('c', u'Staff'), ) @@ -938,7 +938,7 @@ class FieldTest(MongoDBTestCase): tags = ListField(StringField()) authors = ListField(ReferenceField(User)) generic = ListField(GenericReferenceField()) - access_list = ListField(required=False, default=[], choices=AccessLevelChoices, display_sep=u',') + access_list = ListField(choices=AccessLevelChoices, display_sep=', ') User.drop_collection() BlogPost.drop_collection() @@ -965,7 +965,7 @@ class FieldTest(MongoDBTestCase): post.access_list = ['a', 'b'] post.validate() - self.assertEqual(post.get_access_list_display(), u'Administrator,Manager') + self.assertEqual(post.get_access_list_display(), u'Administration, Manager') post.comments = ['a'] self.assertRaises(ValidationError, post.validate) From 433f10ef93cbfa2d2f0a8cb704e8333704ebf362 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 31 Jul 2017 05:15:23 +0000 Subject: [PATCH 018/250] position support singular value #1565 --- mongoengine/queryset/transform.py | 17 ++++++++++------- tests/queryset/queryset.py | 5 +++++ 2 files changed, 15 insertions(+), 7 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index b9c8b130..b01d3d41 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -304,10 +304,6 @@ def update(_doc_cls=None, **update): value = {match: value} key = '.'.join(parts) - position = None - if parts[-1].isdigit() and isinstance(value, (list, tuple, set)): - key = parts[0] - position = int(parts[-1]) if not op: raise InvalidQueryError('Updates must supply an operation ' @@ -339,11 +335,18 @@ def update(_doc_cls=None, **update): value = {key: value} elif op == 'addToSet' and isinstance(value, list): value = {key: {'$each': value}} - elif op == 'push' and isinstance(value, list): - if position is not None: + elif op == 'push': + if parts[-1].isdigit() and op == 'push': + key = parts[0] + position = int(parts[-1]) + # position modifier must appear with each. + if not isinstance(value, (set, tuple, list)): + value = [value] value = {key: {'$each': value, '$position': position}} - else: + elif isinstance(value, list): value = {key: {'$each': value}} + else: + value = {key: value} else: value = {key: value} key = '$' + op diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index f4e4670d..fe97b765 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -1925,6 +1925,11 @@ class QuerySetTest(unittest.TestCase): post.reload() self.assertEqual(post.tags, ['mongodb', 'python', 'java']) + #test push with singular value + BlogPost.objects.filter(id=post.id).update(push__tags__0='scala') + post.reload() + self.assertEqual(post.tags, ['scala', 'mongodb', 'python', 'java']) + def test_update_push_and_pull_add_to_set(self): """Ensure that the 'pull' update operation works correctly. """ From 34fca9d6f5cb8ea09af7dc63a480354c8ecbc06d Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 31 Jul 2017 18:32:34 +0800 Subject: [PATCH 019/250] Add clear comment and tests for positional push #1565 --- mongoengine/queryset/transform.py | 5 +++-- tests/queryset/modify.py | 33 +++++++++++++++++++------------ tests/queryset/queryset.py | 3 +-- 3 files changed, 24 insertions(+), 17 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index b01d3d41..a9907ada 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -336,10 +336,11 @@ def update(_doc_cls=None, **update): elif op == 'addToSet' and isinstance(value, list): value = {key: {'$each': value}} elif op == 'push': - if parts[-1].isdigit() and op == 'push': + if parts[-1].isdigit(): key = parts[0] position = int(parts[-1]) - # position modifier must appear with each. + # $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}} diff --git a/tests/queryset/modify.py b/tests/queryset/modify.py index 44bdc3ff..fe410d19 100644 --- a/tests/queryset/modify.py +++ b/tests/queryset/modify.py @@ -99,26 +99,33 @@ class FindAndModifyTest(unittest.TestCase): @needs_mongodb_v26 def test_modify_with_push(self): class BlogPost(Document): - id = StringField(primary_key=True) tags = ListField(StringField()) BlogPost.drop_collection() BlogPost(id="ABC").save() - BlogPost(id="BCD").save() - blog = BlogPost.objects(id="ABC").modify(push__tags="code") - self.assertEqual(blog.to_mongo(), {"_id": "ABC", "tags": []}) - docs = [{"_id": "ABC", "tags":["code"]}, {"_id": "BCD", "tags":[]}] - self.assertEqual(list(BlogPost._collection.find().sort("id")), docs) + # Push a new tag via modify with new=False (default). + blog = BlogPost(pk='ABC').modify(push__tags='code') + self.assertEqual(blog.tags, []) + blog.reload() + self.assertEqual(blog.tags, ['code']) - another_blog = BlogPost.objects(id="BCD").modify(push__tags="java") - self.assertEqual(another_blog.to_mongo(), {"_id": "BCD", "tags": []}) - another_blog = BlogPost.objects(id="BCD").modify(push__tags__0=["python"]) - self.assertEqual(another_blog.to_mongo(), {"_id": "BCD", "tags": ["java"]}) - docs = [{"_id": "ABC", "tags":["code"]}, - {"_id": "BCD", "tags":["python", "java"]}] - self.assertEqual(list(BlogPost._collection.find().sort("id")), docs) + # Push a new tag via modify with new=True. + blog = BlogPost.objects(pk='ABC').modify(push__tags='java', new=True) + self.assertEqual(blog.tags, ['code', 'java']) + + # Push a new tag with a positional argument. + blog = BlogPost.objects(pk='ABC').modify( + push__tags__0='python', + new=True) + self.assertEqual(blog.tags, ['python', 'code', 'java']) + + # Push multiple new tags with a positional argument. + blog = BlogPost.objects(pk='ABC').modify( + push__tags__1=['go', 'rust'], + new=True) + self.assertEqual(blog.tags, ['python', 'go', 'rust', 'code', 'java']) if __name__ == '__main__': diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index fe97b765..c78ed985 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -1913,8 +1913,7 @@ class QuerySetTest(unittest.TestCase): BlogPost.drop_collection() - post = BlogPost(slug="test") - post.save() + post = BlogPost.objects.create(slug="test") BlogPost.objects.filter(id=post.id).update(push__tags="code") BlogPost.objects.filter(id=post.id).update(push__tags__0=["mongodb", "python"]) From f09256a24e83623b194792234f6a9e4c6944e2a6 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 31 Jul 2017 18:49:52 +0800 Subject: [PATCH 020/250] Fix modify tests #1565 --- tests/queryset/modify.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/queryset/modify.py b/tests/queryset/modify.py index fe410d19..b37f9b73 100644 --- a/tests/queryset/modify.py +++ b/tests/queryset/modify.py @@ -103,26 +103,26 @@ class FindAndModifyTest(unittest.TestCase): BlogPost.drop_collection() - BlogPost(id="ABC").save() + blog = BlogPost.objects.create() # Push a new tag via modify with new=False (default). - blog = BlogPost(pk='ABC').modify(push__tags='code') + BlogPost(id=blog.id).modify(push__tags='code') self.assertEqual(blog.tags, []) blog.reload() self.assertEqual(blog.tags, ['code']) # Push a new tag via modify with new=True. - blog = BlogPost.objects(pk='ABC').modify(push__tags='java', new=True) + blog = BlogPost.objects(id=blog.id).modify(push__tags='java', new=True) self.assertEqual(blog.tags, ['code', 'java']) # Push a new tag with a positional argument. - blog = BlogPost.objects(pk='ABC').modify( + blog = BlogPost.objects(id=blog.id).modify( push__tags__0='python', new=True) self.assertEqual(blog.tags, ['python', 'code', 'java']) # Push multiple new tags with a positional argument. - blog = BlogPost.objects(pk='ABC').modify( + blog = BlogPost.objects(id=blog.id).modify( push__tags__1=['go', 'rust'], new=True) self.assertEqual(blog.tags, ['python', 'go', 'rust', 'code', 'java']) From 2a795e91381053294cc9bf312f785b5ed9f1ab49 Mon Sep 17 00:00:00 2001 From: Ali Date: Fri, 4 Aug 2017 11:31:29 +0100 Subject: [PATCH 021/250] QuerySet limit function now returns all docs in cursor when 0 is passed --- docs/changelog.rst | 1 + mongoengine/queryset/base.py | 7 ++++--- tests/queryset/queryset.py | 5 +++++ 3 files changed, 10 insertions(+), 3 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index c60bbf09..aa8584a7 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -4,6 +4,7 @@ Changelog Development =========== +- QuerySet limit function behaviour: Passing 0 as parameter will return all the documents in the cursor #1611 - (Fill this out as you fix issues and develop your features). Changes in 0.14.0 diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 6f9c372c..be4b9d66 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -384,7 +384,7 @@ class BaseQuerySet(object): :meth:`skip` that has been applied to this cursor into account when getting the count """ - if self._limit == 0 and with_limit_and_skip or self._none: + if self._limit == 0 and with_limit_and_skip is False or self._none: return 0 return self._cursor.count(with_limit_and_skip=with_limit_and_skip) @@ -759,10 +759,11 @@ class BaseQuerySet(object): """Limit the number of returned documents to `n`. This may also be achieved using array-slicing syntax (e.g. ``User.objects[:5]``). - :param n: the maximum number of objects to return + :param n: the maximum number of objects to return if n is greater than 0. + When 0 is passed, returns all the documents in the cursor """ queryset = self.clone() - queryset._limit = n if n != 0 else 1 + queryset._limit = n # If a cursor object has already been created, apply the limit to it. if queryset._cursor_obj: diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index c78ed985..ac545629 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -124,6 +124,11 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(len(people2), 1) self.assertEqual(people2[0], user_a) + # Test limit with 0 as parameter + people = self.Person.objects.limit(0) + self.assertEqual(people.count(with_limit_and_skip=True), 2) + self.assertEqual(len(people), 2) + # Test chaining of only after limit person = self.Person.objects().limit(1).only('name').first() self.assertEqual(person, user_a) From ee5686e91ab9dec45c0d98d22d20c17864f02e0f Mon Sep 17 00:00:00 2001 From: Ali Turki Date: Mon, 7 Aug 2017 11:12:15 +0100 Subject: [PATCH 022/250] test case for #1602 --- tests/queryset/queryset.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index ac545629..57126ac0 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -5133,6 +5133,16 @@ class QuerySetTest(unittest.TestCase): # in a way we'd expect) should raise a TypeError, too self.assertRaises(TypeError, BlogPost.objects(authors__in=author).count) + def test_create_count(self): + self.Person.drop_collection() + self.Person.objects.create(name="Foo") + self.Person.objects.create(name="Bar") + self.Person.objects.create(name="Baz") + self.assertEqual(self.Person.objects.count(with_limit_and_skip=True), 3) + + newPerson = self.Person.objects.create(name="Foo_1") + self.assertEqual(self.Person.objects.count(with_limit_and_skip=True), 4) + if __name__ == '__main__': unittest.main() From c4de879b207e4e7087b099459ff801b8897620f1 Mon Sep 17 00:00:00 2001 From: Paulo Matos Date: Fri, 11 Aug 2017 09:09:33 +0200 Subject: [PATCH 023/250] Clarify comment in validation example --- docs/guide/document-instances.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/guide/document-instances.rst b/docs/guide/document-instances.rst index 0e9fcef6..64f17c08 100644 --- a/docs/guide/document-instances.rst +++ b/docs/guide/document-instances.rst @@ -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) From b9f3991d03fcd78ad5b81011d8420ab0287b29bd Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Fri, 18 Aug 2017 09:31:26 +0800 Subject: [PATCH 024/250] added as_pymongo test for PointField #1311 --- tests/queryset/geo.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tests/queryset/geo.py b/tests/queryset/geo.py index 51a32382..38c0377e 100644 --- a/tests/queryset/geo.py +++ b/tests/queryset/geo.py @@ -510,6 +510,24 @@ class GeoQueriesTest(MongoDBTestCase): roads = Road.objects.filter(poly__geo_intersects={"$geometry": polygon}).count() self.assertEqual(1, roads) + def test_aspymongo_with_only(self): + """Ensure as_pymongo works with only""" + class Place(Document): + location = PointField() + + Place.drop_collection() + p = Place(location=[24.946861267089844, 60.16311983618494]) + p.save() + qs = Place.objects().only('location') + self.assertDictEqual( + qs.as_pymongo()[0]['location'], + {u'type': u'Point', + u'coordinates': [ + 24.946861267089844, + 60.16311983618494] + } + ) + def test_2dsphere_point_sets_correctly(self): class Location(Document): loc = PointField() From 21d1faa7938e4585fa12325037f0695e3572ee80 Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Thu, 24 Aug 2017 18:03:08 +0200 Subject: [PATCH 025/250] Fix .install_mongodb_on_travis.sh script (all credit to @erdenezul) --- .install_mongodb_on_travis.sh | 6 +++++- .travis.yml | 2 ++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/.install_mongodb_on_travis.sh b/.install_mongodb_on_travis.sh index 8563ae74..f2018411 100644 --- a/.install_mongodb_on_travis.sh +++ b/.install_mongodb_on_travis.sh @@ -1,5 +1,6 @@ #!/bin/bash +sudo apt-get remove mongodb-org-server sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10 if [ "$MONGODB" = "2.4" ]; then @@ -13,7 +14,7 @@ elif [ "$MONGODB" = "2.6" ]; then sudo apt-get install mongodb-org-server=2.6.12 # service should be started automatically elif [ "$MONGODB" = "3.0" ]; then - echo "deb http://repo.mongodb.org/apt/ubuntu precise/mongodb-org/3.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb.list + echo "deb http://repo.mongodb.org/apt/ubuntu trusty/mongodb-org/3.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb.list sudo apt-get update sudo apt-get install mongodb-org-server=3.0.14 # service should be started automatically @@ -21,3 +22,6 @@ else echo "Invalid MongoDB version, expected 2.4, 2.6, or 3.0." exit 1 fi; + +mkdir db +1>db/logs mongod --dbpath=db & diff --git a/.travis.yml b/.travis.yml index 8f846ab1..5e90660d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -42,6 +42,8 @@ matrix: before_install: - bash .install_mongodb_on_travis.sh +- sleep 15 # https://docs.travis-ci.com/user/database-setup/#MongoDB-does-not-immediately-accept-connections +- mongo --eval 'db.version();' install: - sudo apt-get install python-dev python3-dev libopenjpeg-dev zlib1g-dev libjpeg-turbo8-dev From 4f59c7f77fdda587386ec3a03b4de9caf1b0dadf Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Tue, 25 Jul 2017 16:26:07 +0200 Subject: [PATCH 026/250] Expose to user mongoengine.base.NON_FIELD_ERRORS This variable is used to set the field containing the errors raised in a clean function. Given those function are user-defined, users should be able to get the name of the field to easily retreive their custom errors. --- mongoengine/base/document.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 99c8af87..d05c7695 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -19,7 +19,7 @@ from mongoengine.common import _import_class from mongoengine.errors import (FieldDoesNotExist, InvalidDocumentError, LookUpError, OperationError, ValidationError) -__all__ = ('BaseDocument',) +__all__ = ('BaseDocument', 'NON_FIELD_ERRORS') NON_FIELD_ERRORS = '__all__' From bce859569f924fe051441b99c36d11795b5953a9 Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Tue, 25 Jul 2017 19:37:21 +0200 Subject: [PATCH 027/250] Remove SemiStrictDict to improve perfs --- docs/changelog.rst | 2 +- mongoengine/base/datastructures.py | 39 ---------------------------- mongoengine/base/document.py | 5 ++-- tests/test_datastructures.py | 41 +----------------------------- 4 files changed, 4 insertions(+), 83 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index c60bbf09..1dcbfb51 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -4,7 +4,7 @@ Changelog Development =========== -- (Fill this out as you fix issues and develop your features). +- Improve performances by removing SemiStrictDict Changes in 0.14.0 ================= diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index b9aca8fa..cd6ac641 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -445,42 +445,3 @@ class StrictDict(object): cls._classes[allowed_keys] = SpecificStrictDict return cls._classes[allowed_keys] - - -class SemiStrictDict(StrictDict): - __slots__ = ('_extras', ) - _classes = {} - - def __getattr__(self, attr): - try: - super(SemiStrictDict, self).__getattr__(attr) - except AttributeError: - try: - return self.__getattribute__('_extras')[attr] - except KeyError as e: - raise AttributeError(e) - - def __setattr__(self, attr, value): - try: - super(SemiStrictDict, self).__setattr__(attr, value) - except AttributeError: - try: - self._extras[attr] = value - except AttributeError: - self._extras = {attr: value} - - def __delattr__(self, attr): - try: - super(SemiStrictDict, self).__delattr__(attr) - except AttributeError: - try: - del self._extras[attr] - except KeyError as e: - raise AttributeError(e) - - def __iter__(self): - try: - extras_iter = iter(self.__getattribute__('_extras')) - except AttributeError: - extras_iter = () - return itertools.chain(super(SemiStrictDict, self).__iter__(), extras_iter) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index d05c7695..f8ab73d0 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -13,7 +13,7 @@ from mongoengine import signals from mongoengine.base.common import get_document from mongoengine.base.datastructures import (BaseDict, BaseList, EmbeddedDocumentList, - SemiStrictDict, StrictDict) + StrictDict) from mongoengine.base.fields import ComplexBaseField from mongoengine.common import _import_class from mongoengine.errors import (FieldDoesNotExist, InvalidDocumentError, @@ -79,8 +79,7 @@ class BaseDocument(object): if self.STRICT and not self._dynamic: self._data = StrictDict.create(allowed_keys=self._fields_ordered)() else: - self._data = SemiStrictDict.create( - allowed_keys=self._fields_ordered)() + self._data = {} self._dynamic_fields = SON() diff --git a/tests/test_datastructures.py b/tests/test_datastructures.py index 6830a188..79381c5a 100644 --- a/tests/test_datastructures.py +++ b/tests/test_datastructures.py @@ -1,6 +1,6 @@ import unittest -from mongoengine.base.datastructures import StrictDict, SemiStrictDict +from mongoengine.base.datastructures import StrictDict class TestStrictDict(unittest.TestCase): @@ -76,44 +76,5 @@ class TestStrictDict(unittest.TestCase): assert dict(**d) == {'a': 1, 'b': 2} -class TestSemiSrictDict(TestStrictDict): - def strict_dict_class(self, *args, **kwargs): - return SemiStrictDict.create(*args, **kwargs) - - def test_init_fails_on_nonexisting_attrs(self): - # disable irrelevant test - pass - - def test_setattr_raises_on_nonexisting_attr(self): - # disable irrelevant test - pass - - def test_setattr_getattr_nonexisting_attr_succeeds(self): - d = self.dtype() - d.x = 1 - self.assertEqual(d.x, 1) - - def test_init_succeeds_with_nonexisting_attrs(self): - d = self.dtype(a=1, b=1, c=1, x=2) - self.assertEqual((d.a, d.b, d.c, d.x), (1, 1, 1, 2)) - - def test_iter_with_nonexisting_attrs(self): - d = self.dtype(a=1, b=1, c=1, x=2) - self.assertEqual(list(d), ['a', 'b', 'c', 'x']) - - def test_iteritems_with_nonexisting_attrs(self): - d = self.dtype(a=1, b=1, c=1, x=2) - self.assertEqual(list(d.iteritems()), [('a', 1), ('b', 1), ('c', 1), ('x', 2)]) - - def tets_cmp_with_strict_dicts(self): - d = self.dtype(a=1, b=1, c=1) - dd = StrictDict.create(("a", "b", "c"))(a=1, b=1, c=1) - self.assertEqual(d, dd) - - def test_cmp_with_strict_dict_with_nonexisting_attrs(self): - d = self.dtype(a=1, b=1, c=1, x=2) - dd = StrictDict.create(("a", "b", "c", "x"))(a=1, b=1, c=1, x=2) - self.assertEqual(d, dd) - if __name__ == '__main__': unittest.main() From 66429ce331822c29e69770386785dfa0412dd02b Mon Sep 17 00:00:00 2001 From: Srinivas Reddy Thatiparthy Date: Sun, 6 Aug 2017 13:35:01 +0530 Subject: [PATCH 028/250] Add python 3.6 support --- .travis.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.travis.yml b/.travis.yml index 5e90660d..9362dcc2 100644 --- a/.travis.yml +++ b/.travis.yml @@ -15,6 +15,7 @@ language: python python: - 2.7 - 3.5 +- 3.6 - pypy env: @@ -39,6 +40,10 @@ matrix: env: MONGODB=2.4 PYMONGO=3.0 - python: 3.5 env: MONGODB=3.0 PYMONGO=3.0 + - python: 3.6 + env: MONGODB=2.4 PYMONGO=3.0 + - python: 3.6 + env: MONGODB=3.0 PYMONGO=3.0 before_install: - bash .install_mongodb_on_travis.sh From 7c0cfb1da2dd4bdcd24332a3ca08d561fa1e93da Mon Sep 17 00:00:00 2001 From: Srinivas Reddy Thatiparthy Date: Sun, 6 Aug 2017 13:23:47 +0530 Subject: [PATCH 029/250] Add six.moves.range instead of xrange --- mongoengine/base/datastructures.py | 2 +- mongoengine/queryset/queryset.py | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index b9aca8fa..c727ec78 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -127,7 +127,7 @@ class BaseList(list): return value def __iter__(self): - for i in xrange(self.__len__()): + for i in six.moves.range(self.__len__()): yield self[i] def __setitem__(self, key, value, *args, **kwargs): diff --git a/mongoengine/queryset/queryset.py b/mongoengine/queryset/queryset.py index b5d2765b..cf913b01 100644 --- a/mongoengine/queryset/queryset.py +++ b/mongoengine/queryset/queryset.py @@ -1,3 +1,5 @@ +import six + from mongoengine.errors import OperationError from mongoengine.queryset.base import (BaseQuerySet, CASCADE, DENY, DO_NOTHING, NULLIFY, PULL) @@ -112,7 +114,7 @@ class QuerySet(BaseQuerySet): # Pull in ITER_CHUNK_SIZE docs from the database and store them in # the result cache. try: - for _ in xrange(ITER_CHUNK_SIZE): + for _ in six.moves.range(ITER_CHUNK_SIZE): self._result_cache.append(self.next()) except StopIteration: # Getting this exception means there are no more docs in the @@ -166,7 +168,7 @@ class QuerySetNoCache(BaseQuerySet): return '.. queryset mid-iteration ..' data = [] - for _ in xrange(REPR_OUTPUT_SIZE + 1): + for _ in six.moves.range(REPR_OUTPUT_SIZE + 1): try: data.append(self.next()) except StopIteration: From 9b3fe09508e6bd5fc7fe8ed6fff97f515841bede Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Fri, 18 Aug 2017 09:31:26 +0800 Subject: [PATCH 030/250] added as_pymongo test for PointField #1311 --- tests/queryset/geo.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tests/queryset/geo.py b/tests/queryset/geo.py index 51a32382..38c0377e 100644 --- a/tests/queryset/geo.py +++ b/tests/queryset/geo.py @@ -510,6 +510,24 @@ class GeoQueriesTest(MongoDBTestCase): roads = Road.objects.filter(poly__geo_intersects={"$geometry": polygon}).count() self.assertEqual(1, roads) + def test_aspymongo_with_only(self): + """Ensure as_pymongo works with only""" + class Place(Document): + location = PointField() + + Place.drop_collection() + p = Place(location=[24.946861267089844, 60.16311983618494]) + p.save() + qs = Place.objects().only('location') + self.assertDictEqual( + qs.as_pymongo()[0]['location'], + {u'type': u'Point', + u'coordinates': [ + 24.946861267089844, + 60.16311983618494] + } + ) + def test_2dsphere_point_sets_correctly(self): class Location(Document): loc = PointField() From dc8a64fa7d00364956560d47a7b753aee84fa561 Mon Sep 17 00:00:00 2001 From: Srinivas Reddy Thatiparthy Date: Fri, 25 Aug 2017 22:02:47 +0530 Subject: [PATCH 031/250] Add missing dunder method - __ne__ to the class GridFSProxy class --- mongoengine/fields.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 0d402712..fffba7ac 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1465,6 +1465,9 @@ class GridFSProxy(object): else: return False + def __ne__(self, other): + return not self == other + @property def fs(self): if not self._fs: From 1eae97731f2a384cb7b27404aa9b59741155f7bc Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Wed, 30 Aug 2017 12:04:04 +0800 Subject: [PATCH 032/250] Fix Document.modify fail on sharded collection #1569 --- mongoengine/document.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/mongoengine/document.py b/mongoengine/document.py index f1622934..71929cf1 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -280,6 +280,9 @@ class Document(BaseDocument): elif query[id_field] != self.pk: raise InvalidQueryError('Invalid document modify query: it must modify only this document.') + # Need to add shard key to query, or you get an error + query.update(self._object_key) + updated = self._qs(**query).modify(new=True, **update) if updated is None: return False From 44732a5dd904da5224ae1ab7ab45ca4a247d82c1 Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Sat, 2 Sep 2017 02:05:27 +0900 Subject: [PATCH 033/250] add fix for reload(fields) affect changed fields #1371 --- mongoengine/document.py | 5 +++-- tests/document/instance.py | 20 +++++++++++++++++++- 2 files changed, 22 insertions(+), 3 deletions(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index f1622934..cb901c82 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -702,7 +702,6 @@ class Document(BaseDocument): obj = obj[0] else: raise self.DoesNotExist('Document does not exist') - for field in obj._data: if not fields or field in fields: try: @@ -718,7 +717,9 @@ class Document(BaseDocument): # i.e. obj.update(unset__field=1) followed by obj.reload() delattr(self, field) - self._changed_fields = obj._changed_fields + self._changed_fields = list( + set(self._changed_fields) - set(fields) + ) if fields else obj._changed_fields self._created = False return self diff --git a/tests/document/instance.py b/tests/document/instance.py index 609bc900..2a746709 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -476,6 +476,24 @@ class InstanceTest(unittest.TestCase): doc.save() doc.reload() + def test_reload_with_changed_fields(self): + """Ensures reloading will not affect changed fields""" + class User(Document): + name = StringField() + number = IntField() + User.drop_collection() + + user = User(name="Bob", number=1).save() + user.name = "John" + user.number = 2 + + self.assertEqual(user._get_changed_fields(), ['name', 'number']) + user.reload('number') + self.assertEqual(user._get_changed_fields(), ['name']) + user.save() + user.reload() + self.assertEqual(user.name, "John") + def test_reload_referencing(self): """Ensures reloading updates weakrefs correctly.""" class Embedded(EmbeddedDocument): @@ -521,7 +539,7 @@ class InstanceTest(unittest.TestCase): doc.save() doc.dict_field['extra'] = 1 doc = doc.reload(10, 'list_field') - self.assertEqual(doc._get_changed_fields(), []) + self.assertEqual(doc._get_changed_fields(), ['dict_field.extra']) self.assertEqual(len(doc.list_field), 5) self.assertEqual(len(doc.dict_field), 3) self.assertEqual(len(doc.embedded_field.list_field), 4) From 02733e6e5849bd60cd938fc05db2f73f8a561036 Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Sat, 2 Sep 2017 12:00:57 +0900 Subject: [PATCH 034/250] fix flake8 error #1371 --- mongoengine/document.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index cb901c82..a30dd0df 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -719,7 +719,7 @@ class Document(BaseDocument): self._changed_fields = list( set(self._changed_fields) - set(fields) - ) if fields else obj._changed_fields + ) if fields else obj._changed_fields self._created = False return self From 70088704e202c38ed7265cbb1929a38d383c8a3d Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 10 Sep 2017 01:37:17 +0900 Subject: [PATCH 035/250] add tests to increase code coverage --- tests/fields/fields.py | 10 +++++++++- tests/queryset/geo.py | 4 ++++ tests/queryset/queryset.py | 6 ++++++ 3 files changed, 19 insertions(+), 1 deletion(-) diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 7a0ccc25..dbf148e1 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -334,7 +334,7 @@ class FieldTest(MongoDBTestCase): def test_string_validation(self): """Ensure that invalid values cannot be assigned to string fields.""" class Person(Document): - name = StringField(max_length=20) + name = StringField(max_length=20, min_length=5) userid = StringField(r'[0-9a-z_]+$') person = Person(name=34) @@ -352,6 +352,10 @@ class FieldTest(MongoDBTestCase): person = Person(name='Name that is more than twenty characters') self.assertRaises(ValidationError, person.validate) + # Test max length validation on name + person = Person(name='aa') + self.assertRaises(ValidationError, person.validate) + person.name = 'Shorter name' person.validate() @@ -437,6 +441,10 @@ class FieldTest(MongoDBTestCase): doc.age = 'ten' self.assertRaises(ValidationError, doc.validate) + # Test max_value validation + doc.value = 200 + self.assertRaises(ValidationError, doc.validate) + def test_float_validation(self): """Ensure that invalid values cannot be assigned to float fields. """ diff --git a/tests/queryset/geo.py b/tests/queryset/geo.py index 38c0377e..acfd9364 100644 --- a/tests/queryset/geo.py +++ b/tests/queryset/geo.py @@ -429,6 +429,10 @@ class GeoQueriesTest(MongoDBTestCase): roads = Road.objects.filter(line__geo_within=polygon).count() self.assertEqual(1, roads) + sphere = [[-1, 42,], 2] + roads = Road.objects.filter(line__geo_within_sphere=sphere).count() + self.assertEqual(0, roads) + roads = Road.objects.filter(line__geo_within={"$geometry": polygon}).count() self.assertEqual(1, roads) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index c78ed985..5fc73a54 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -1882,6 +1882,12 @@ class QuerySetTest(unittest.TestCase): post.reload() self.assertTrue('mongo' in post.tags) + # Push with arrays + BlogPost.objects.update(push__tags=['python', 'scala']) + post.reload() + self.assertTrue('python' in post.tags) + self.assertTrue('scala' in post.tags) + BlogPost.objects.update_one(push_all__tags=['db', 'nosql']) post.reload() self.assertTrue('db' in post.tags and 'nosql' in post.tags) From ba99190f535ba16ed3c9d6fe5acfc4836c64b48d Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 10 Sep 2017 13:09:20 +0900 Subject: [PATCH 036/250] add tests to increase coverage --- tests/fields/fields.py | 26 ++++++++++++++++++++++++++ tests/queryset/queryset.py | 4 ++++ 2 files changed, 30 insertions(+) diff --git a/tests/fields/fields.py b/tests/fields/fields.py index dbf148e1..d25f2e25 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -312,6 +312,27 @@ class FieldTest(MongoDBTestCase): self.assertEqual(1, TestDocument.objects(long_fld__ne=None).count()) + def test_callable_validation(self): + """Ensure that callable validation works""" + def check_even(value): + return value % 2 == 0 + + class Order(Document): + number = IntField(validation=check_even) + + Order.drop_collection() + + order = Order(number=3) + self.assertRaises(ValidationError, order.validate) + + class User(Document): + name = StringField(validation=1) + + User.drop_collection() + + user = User(name='test') + self.assertRaises(ValidationError, user.validate) + def test_object_id_validation(self): """Ensure that invalid values cannot be assigned to an ObjectIdField. @@ -527,6 +548,11 @@ class FieldTest(MongoDBTestCase): class User(Document): name = StringField(db_field='name\0') + # db field should be a string + with self.assertRaises(TypeError): + class User(Document): + name = StringField(db_field=1) + def test_decimal_comparison(self): class Person(Document): money = DecimalField() diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 5fc73a54..9c61513a 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -1861,6 +1861,10 @@ class QuerySetTest(unittest.TestCase): post = BlogPost(name="Test Post", hits=5, tags=['test']) post.save() + BlogPost.objects.update(hits=11) + post.reload() + self.assertEqual(post.hits, 11) + BlogPost.objects.update(set__hits=10) post.reload() self.assertEqual(post.hits, 10) From be8f1b9fdd522888527f871c1fbc2a0f6f0af279 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Thu, 14 Sep 2017 22:24:27 +0900 Subject: [PATCH 037/250] add failing test for generic_emdedded_document query #1651 --- tests/queryset/queryset.py | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index c78ed985..4bc5fef6 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4790,6 +4790,30 @@ class QuerySetTest(unittest.TestCase): for obj in C.objects.no_sub_classes(): self.assertEqual(obj.__class__, C) + def test_query_generic_embedded_document(self): + """Ensure that querying sub field on generic_embedded_field works + """ + class A(EmbeddedDocument): + a_name = StringField() + + class B(EmbeddedDocument): + b_name = StringField() + + class Doc(Document): + document = GenericEmbeddedDocumentField(choices=(A, B)) + + Doc.drop_collection() + Doc(document=A(a_name='A doc')).save() + Doc(document=B(b_name='B doc')).save() + + # Using raw in filter working fine + self.assertEqual(Doc.objects( + __raw__={'document.a_name': 'A doc'}).count(), 1) + self.assertEqual(Doc.objects( + __raw__={'document.b_name': 'B doc'}).count(), 1) + self.assertEqual(Doc.objects(document__a_name='A doc').count(), 1) + self.assertEqual(Doc.objects(document__b_name='B doc').count(), 1) + def test_query_reference_to_custom_pk_doc(self): class A(Document): From e90f6a2fa3766872b44edad29a21527659984ae3 Mon Sep 17 00:00:00 2001 From: Andy Yankovsky Date: Thu, 14 Sep 2017 20:28:15 +0300 Subject: [PATCH 038/250] Fix update via pull__something__in=[] --- mongoengine/queryset/transform.py | 46 +++++++++++++++++++------------ tests/queryset/transform.py | 7 +++++ 2 files changed, 36 insertions(+), 17 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index a9907ada..1f70a48b 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -101,21 +101,8 @@ def query(_doc_cls=None, **kwargs): value = value['_id'] elif op in ('in', 'nin', 'all', 'near') and not isinstance(value, dict): - # Raise an error if the in/nin/all/near param is not iterable. 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]).") - elif not hasattr(value, '__iter__'): - raise TypeError("The `in`, `nin`, `all`, or " - "`near`-operators must be applied to an " - "iterable (e.g. a list).") - else: - 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: @@ -284,9 +271,15 @@ def update(_doc_cls=None, **update): if isinstance(field, GeoJsonBaseField): value = field.to_mongo(value) - if op == 'push' and isinstance(value, (list, tuple, set)): + if op == 'pull': + if field.required or value is not None: + if match == 'in' 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', 'pull'): + 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'): @@ -439,3 +432,22 @@ def _infer_geometry(value): 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] diff --git a/tests/queryset/transform.py b/tests/queryset/transform.py index 20ab0b3f..a043a647 100644 --- a/tests/queryset/transform.py +++ b/tests/queryset/transform.py @@ -28,12 +28,16 @@ class TransformTest(unittest.TestCase): {'name': {'$exists': True}}) def test_transform_update(self): + class LisDoc(Document): + foo = ListField(StringField()) + class DicDoc(Document): dictField = DictField() class Doc(Document): pass + LisDoc.drop_collection() DicDoc.drop_collection() Doc.drop_collection() @@ -51,6 +55,9 @@ class TransformTest(unittest.TestCase): update = transform.update(DicDoc, pull__dictField__test=doc) self.assertTrue(isinstance(update["$pull"]["dictField"]["test"], dict)) + update = transform.update(LisDoc, pull__foo__in=['a']) + self.assertEqual(update, {'$pull': {'foo': {'$in': ['a']}}}) + def test_query_field_name(self): """Ensure that the correct field name is used when querying. """ From 2f4e2bde6bb1d892ac22928870e01889fa983833 Mon Sep 17 00:00:00 2001 From: Andy Yankovsky Date: Thu, 14 Sep 2017 21:02:53 +0300 Subject: [PATCH 039/250] Update AUTHORS --- AUTHORS | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/AUTHORS b/AUTHORS index 4eac5eb2..2e7b56fc 100644 --- a/AUTHORS +++ b/AUTHORS @@ -244,4 +244,5 @@ that much better: * Stanislav Kaledin (https://github.com/sallyruthstruik) * Dmitry Yantsen (https://github.com/mrTable) * Renjianxin (https://github.com/Davidrjx) - * Erdenezul Batmunkh (https://github.com/erdenezul) \ No newline at end of file + * Erdenezul Batmunkh (https://github.com/erdenezul) + * Andy Yankovsky (https://github.com/werat) From aa4996ef28bec2614cb11c055b5d184fee6b9549 Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Fri, 15 Sep 2017 11:18:24 +0800 Subject: [PATCH 040/250] fix bug query subfield in generic_embedded_document #1651 --- mongoengine/fields.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index fffba7ac..cc66008b 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -692,6 +692,14 @@ class GenericEmbeddedDocumentField(BaseField): value.validate(clean=clean) + def lookup_member(self, member_name): + if self.choices: + for choice in self.choices: + field = choice._fields.get(member_name) + if field: + return field + return None + def to_mongo(self, document, use_db_field=True, fields=None): if document is None: return None From 091a02f73737ccd028aa256e2f50cc30d84621a7 Mon Sep 17 00:00:00 2001 From: Stefan Wojcik Date: Sun, 1 Oct 2017 16:09:10 -0400 Subject: [PATCH 041/250] minor .travis.yml comment correction [ci skip] --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 9362dcc2..78a9f787 100644 --- a/.travis.yml +++ b/.travis.yml @@ -97,7 +97,7 @@ deploy: distributions: "sdist bdist_wheel" # only deploy on tagged commits (aka GitHub releases) and only for the - # parent repo's builds running Python 2.7 along with dev PyMongo (we run + # parent repo's builds running Python 2.7 along with PyMongo v3.0 (we run # Travis against many different Python and PyMongo versions and we don't # want the deploy to occur multiple times). on: From 01526a7b373b954ef053238331f84ef1193bb564 Mon Sep 17 00:00:00 2001 From: Stefan Wojcik Date: Sun, 1 Oct 2017 16:32:02 -0400 Subject: [PATCH 042/250] v0.14.1 version bump + updated changelog --- docs/changelog.rst | 10 +++++++++- mongoengine/__init__.py | 2 +- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 1dcbfb51..f04ab314 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -4,7 +4,15 @@ Changelog Development =========== -- Improve performances by removing SemiStrictDict +- (Fill this out as you fix issues and develop your features). + +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 ================= diff --git a/mongoengine/__init__.py b/mongoengine/__init__.py index b41e87e7..4b60f1b7 100644 --- a/mongoengine/__init__.py +++ b/mongoengine/__init__.py @@ -23,7 +23,7 @@ __all__ = (list(document.__all__) + list(fields.__all__) + list(signals.__all__) + list(errors.__all__)) -VERSION = (0, 14, 0) +VERSION = (0, 14, 1) def get_version(): From d79ab5ffeb421abe4c145af77633283f4d20d942 Mon Sep 17 00:00:00 2001 From: Stefan Wojcik Date: Sun, 1 Oct 2017 17:05:28 -0400 Subject: [PATCH 043/250] remove {nospam} from author_email & maintainer_email (PyPI doesnt validate those anymore) --- setup.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/setup.py b/setup.py index fa682d20..98964d19 100644 --- a/setup.py +++ b/setup.py @@ -70,9 +70,9 @@ 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", + 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', From a1494c4c93cce608d8d9450c9ef76c07559248c9 Mon Sep 17 00:00:00 2001 From: Stefan Wojcik Date: Sun, 1 Oct 2017 17:31:10 -0400 Subject: [PATCH 044/250] v0.14.3 version bump --- mongoengine/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/__init__.py b/mongoengine/__init__.py index 4b60f1b7..c7c6f707 100644 --- a/mongoengine/__init__.py +++ b/mongoengine/__init__.py @@ -23,7 +23,7 @@ __all__ = (list(document.__all__) + list(fields.__all__) + list(signals.__all__) + list(errors.__all__)) -VERSION = (0, 14, 1) +VERSION = (0, 14, 3) def get_version(): From 2f075be6f8857d297d9e939d9150417158d93d5a Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 2 Oct 2017 22:46:27 +0800 Subject: [PATCH 045/250] parse read_preference from conn_host #1665 --- mongoengine/connection.py | 11 +++++++++++ tests/test_connection.py | 5 +++++ 2 files changed, 16 insertions(+) diff --git a/mongoengine/connection.py b/mongoengine/connection.py index 34ff4dc3..ef815343 100644 --- a/mongoengine/connection.py +++ b/mongoengine/connection.py @@ -103,6 +103,17 @@ def register_connection(alias, name=None, host=None, port=None, 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) + read_pf_mode = uri_options['readpreference'] + for preference in read_preferences: + if preference.mode == read_pf_mode: + conn_settings['read_preference'] = preference + break else: resolved_hosts.append(entity) conn_settings['host'] = resolved_hosts diff --git a/tests/test_connection.py b/tests/test_connection.py index cdcf1377..f0c272e4 100644 --- a/tests/test_connection.py +++ b/tests/test_connection.py @@ -364,6 +364,11 @@ class ConnectionTest(unittest.TestCase): date_doc = DateDoc.objects.first() self.assertEqual(d, date_doc.the_date) + def test_read_preference_from_parse(self): + from pymongo import ReadPreference + conn = connect(host="mongodb://a1.vpc,a2.vpc,a3.vpc/prod?readPreference=secondaryPreferred") + self.assertEqual(conn.read_preference, ReadPreference.SECONDARY_PREFERRED) + def test_multiple_connection_settings(self): connect('mongoenginetest', alias='t1', host="localhost") From 416486c370cbe565128b04e9fadcc65e643d12d9 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 2 Oct 2017 23:13:25 +0800 Subject: [PATCH 046/250] use read_preference only pymongo3.x #1665 --- mongoengine/connection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/connection.py b/mongoengine/connection.py index ef815343..419af6bc 100644 --- a/mongoengine/connection.py +++ b/mongoengine/connection.py @@ -103,7 +103,7 @@ def register_connection(alias, name=None, host=None, port=None, conn_settings['authentication_source'] = uri_options['authsource'] if 'authmechanism' in uri_options: conn_settings['authentication_mechanism'] = uri_options['authmechanism'] - if 'readpreference' in uri_options: + if IS_PYMONGO_3 and 'readpreference' in uri_options: read_preferences = (ReadPreference.NEAREST, ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, From 5c4ce8754e29d435a621a1780ef96c3a6bb60ebf Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 2 Oct 2017 23:15:37 +0800 Subject: [PATCH 047/250] run tests only pymongo3 #1565 --- tests/test_connection.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tests/test_connection.py b/tests/test_connection.py index f0c272e4..f58b1a3e 100644 --- a/tests/test_connection.py +++ b/tests/test_connection.py @@ -365,9 +365,10 @@ class ConnectionTest(unittest.TestCase): self.assertEqual(d, date_doc.the_date) def test_read_preference_from_parse(self): - from pymongo import ReadPreference - conn = connect(host="mongodb://a1.vpc,a2.vpc,a3.vpc/prod?readPreference=secondaryPreferred") - self.assertEqual(conn.read_preference, ReadPreference.SECONDARY_PREFERRED) + if IS_PYMONGO_3: + from pymongo import ReadPreference + conn = connect(host="mongodb://a1.vpc,a2.vpc,a3.vpc/prod?readPreference=secondaryPreferred") + self.assertEqual(conn.read_preference, ReadPreference.SECONDARY_PREFERRED) def test_multiple_connection_settings(self): connect('mongoenginetest', alias='t1', host="localhost") From 6e2db1ced6a8621e35cf38f27993751fe5ea1e6b Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Tue, 3 Oct 2017 09:23:17 +0800 Subject: [PATCH 048/250] read_preference from parse_uri only PYMONGO_3 #1665 --- mongoengine/connection.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/mongoengine/connection.py b/mongoengine/connection.py index 419af6bc..feba0b58 100644 --- a/mongoengine/connection.py +++ b/mongoengine/connection.py @@ -104,14 +104,15 @@ def register_connection(alias, name=None, host=None, port=None, if 'authmechanism' in uri_options: conn_settings['authentication_mechanism'] = uri_options['authmechanism'] if IS_PYMONGO_3 and 'readpreference' in uri_options: - read_preferences = (ReadPreference.NEAREST, - ReadPreference.PRIMARY, - ReadPreference.PRIMARY_PREFERRED, - ReadPreference.SECONDARY, - ReadPreference.SECONDARY_PREFERRED) - read_pf_mode = uri_options['readpreference'] + read_preferences = ( + ReadPreference.NEAREST, + ReadPreference.PRIMARY, + ReadPreference.PRIMARY_PREFERRED, + ReadPreference.SECONDARY, + ReadPreference.SECONDARY_PREFERRED) + read_pf_mode = uri_options['readpreference'].lower() for preference in read_preferences: - if preference.mode == read_pf_mode: + if preference.name.lower() == read_pf_mode: conn_settings['read_preference'] = preference break else: From 9ab856e186b438bc28f12cae8274ea1bb2ff3614 Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Tue, 10 Oct 2017 10:34:34 +0800 Subject: [PATCH 049/250] use each modifier only with #1673 --- mongoengine/queryset/transform.py | 2 -- tests/document/instance.py | 11 +++++++++++ tests/queryset/queryset.py | 15 +++++++++++++++ 3 files changed, 26 insertions(+), 2 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index a9907ada..3eadaf64 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -344,8 +344,6 @@ def update(_doc_cls=None, **update): if not isinstance(value, (set, tuple, list)): value = [value] value = {key: {'$each': value, '$position': position}} - elif isinstance(value, list): - value = {key: {'$each': value}} else: value = {key: value} else: diff --git a/tests/document/instance.py b/tests/document/instance.py index 609bc900..721aa95f 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -3183,6 +3183,17 @@ class InstanceTest(unittest.TestCase): blog.reload() self.assertEqual(blog.tags, ['mongodb', 'code', 'python']) + def test_push_nested_list(self): + """Ensure that push update works in nested list""" + class BlogPost(Document): + slug = StringField() + tags = ListField() + + blog = BlogPost(slug="test").save() + blog.update(push__tags=["value1", 123]) + blog.reload() + self.assertEqual(blog.tags, [["value1", 123]]) + if __name__ == '__main__': unittest.main() diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index c78ed985..d633b8b2 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -1929,6 +1929,21 @@ class QuerySetTest(unittest.TestCase): post.reload() self.assertEqual(post.tags, ['scala', 'mongodb', 'python', 'java']) + def test_update_push_list_of_list(self): + """Ensure that the 'push' update operation works in the list of list + """ + class BlogPost(Document): + slug = StringField() + tags = ListField() + + BlogPost.drop_collection() + + post = BlogPost(slug="test").save() + + BlogPost.objects.filter(slug="test").update(push__tags=["value1", 123]) + post.reload() + self.assertEqual(post.tags, [["value1", 123]]) + def test_update_push_and_pull_add_to_set(self): """Ensure that the 'pull' update operation works correctly. """ From 15451ff42b7cc7b5a9a76190b60e96d062ecff81 Mon Sep 17 00:00:00 2001 From: Mandeep Singh Date: Tue, 17 Oct 2017 00:11:47 +0530 Subject: [PATCH 050/250] return instead of raising StopIteration --- mongoengine/queryset/base.py | 2 +- mongoengine/queryset/queryset.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 6f9c372c..2dcfdbea 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -1461,7 +1461,7 @@ class BaseQuerySet(object): """Wrap the result in a :class:`~mongoengine.Document` object. """ if self._limit == 0 or self._none: - raise StopIteration + return raw_doc = self._cursor.next() diff --git a/mongoengine/queryset/queryset.py b/mongoengine/queryset/queryset.py index cf913b01..1aadfb76 100644 --- a/mongoengine/queryset/queryset.py +++ b/mongoengine/queryset/queryset.py @@ -89,10 +89,10 @@ class QuerySet(BaseQuerySet): yield self._result_cache[pos] pos += 1 - # Raise StopIteration if we already established there were no more + # 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: From e6c0280b40f18074c0a6267b29f2a77f21c1c779 Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Mon, 30 Oct 2017 18:15:51 +0100 Subject: [PATCH 051/250] Add LazyReferenceField --- docs/changelog.rst | 6 +- mongoengine/base/__init__.py | 2 +- mongoengine/base/datastructures.py | 42 ++++- mongoengine/fields.py | 139 ++++++++++++++- tests/fields/fields.py | 276 ++++++++++++++++++++++++++++- 5 files changed, 456 insertions(+), 9 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index f04ab314..834fbee2 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -2,9 +2,9 @@ Changelog ========= -Development -=========== -- (Fill this out as you fix issues and develop your features). +Changes in 0.15.0 +================= +- Add LazyReferenceField to address #1230 Changes in 0.14.1 ================= diff --git a/mongoengine/base/__init__.py b/mongoengine/base/__init__.py index da31b922..e069a147 100644 --- a/mongoengine/base/__init__.py +++ b/mongoengine/base/__init__.py @@ -15,7 +15,7 @@ __all__ = ( 'UPDATE_OPERATORS', '_document_registry', 'get_document', # datastructures - 'BaseDict', 'BaseList', 'EmbeddedDocumentList', + 'BaseDict', 'BaseList', 'EmbeddedDocumentList', 'LazyReference', # document 'BaseDocument', diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index 14fe95e9..043df471 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -2,11 +2,12 @@ import itertools import weakref import six +from bson import DBRef from mongoengine.common import _import_class from mongoengine.errors import DoesNotExist, MultipleObjectsReturned -__all__ = ('BaseDict', 'BaseList', 'EmbeddedDocumentList') +__all__ = ('BaseDict', 'BaseList', 'EmbeddedDocumentList', 'LazyReference') class BaseDict(dict): @@ -445,3 +446,42 @@ class StrictDict(object): 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 "" % (self.document_type, self.pk) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index fffba7ac..73a62bc5 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -26,7 +26,8 @@ except ImportError: Int64 = long from mongoengine.base import (BaseDocument, BaseField, ComplexBaseField, - GeoJsonBaseField, ObjectIdField, get_document) + GeoJsonBaseField, ObjectIdField, get_document, + LazyReference) from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db from mongoengine.document import Document, EmbeddedDocument from mongoengine.errors import DoesNotExist, InvalidQueryError, ValidationError @@ -46,6 +47,8 @@ __all__ = ( 'GenericEmbeddedDocumentField', 'DynamicField', 'ListField', 'SortedListField', 'EmbeddedDocumentListField', 'DictField', 'MapField', 'ReferenceField', 'CachedReferenceField', + 'LazyReferenceField', + # 'GenericLazyReferenceField', 'GenericReferenceField', 'BinaryField', 'GridFSError', 'GridFSProxy', 'FileField', 'ImageGridFsProxy', 'ImproperlyConfigured', 'ImageField', 'GeoPointField', 'PointField', 'LineStringField', 'PolygonField', @@ -953,6 +956,15 @@ class ReferenceField(BaseField): """A reference to a document that will be automatically dereferenced on access (lazily). + Note this means you will get a database I/O access everytime you access + this field. This is necessary because the field returns a :class:`~mongoengine.Document` + which precise type can depend of the value of the `_cls` field present in the + document in database. + In short, using this type of field can lead to poor performances (especially + if you access this field only to retrieve it `pk` field which is already + known before dereference). To solve this you should consider using the + :class:`~mongoengine.fields.LazyReferenceField`. + Use the `reverse_delete_rule` to handle what should happen if the document the field is referencing is deleted. EmbeddedDocuments, DictFields and MapFields does not support reverse_delete_rule and an `InvalidDocumentError` @@ -1087,8 +1099,8 @@ class ReferenceField(BaseField): def validate(self, value): - if not isinstance(value, (self.document_type, DBRef, ObjectId)): - self.error('A ReferenceField only accepts DBRef, ObjectId or documents') + if not isinstance(value, (self.document_type, LazyReference, DBRef, ObjectId)): + self.error('A ReferenceField only accepts DBRef, LazyReference, ObjectId or documents') if isinstance(value, Document) and value.id is None: self.error('You can only reference documents once they have been ' @@ -2141,3 +2153,124 @@ class MultiPolygonField(GeoJsonBaseField): .. versionadded:: 0.9 """ _type = 'MultiPolygon' + + +class LazyReferenceField(BaseField): + """A really lazy reference to a document. + Unlike the :class:`~mongoengine.fields.ReferenceField` it must be manually + dereferenced using it ``fetch()`` method. + """ + + def __init__(self, document_type, passthrough=False, dbref=False, + reverse_delete_rule=DO_NOTHING, **kwargs): + """Initialises the Reference Field. + + :param dbref: Store the reference as :class:`~pymongo.dbref.DBRef` + or as the :class:`~pymongo.objectid.ObjectId`.id . + :param reverse_delete_rule: Determines what to do when the referring + object is deleted + :param passthrough: When trying to access unknown fields, the + :class:`~mongoengine.base.datastructure.LazyReference` instance will + automatically call `fetch()` and try to retrive the field on the fetched + document. Note this only work getting field (not setting or deleting). + """ + if ( + not isinstance(document_type, six.string_types) and + not issubclass(document_type, Document) + ): + self.error('Argument to LazyReferenceField constructor must be a ' + 'document class or a string') + + self.dbref = dbref + self.passthrough = passthrough + self.document_type_obj = document_type + self.reverse_delete_rule = reverse_delete_rule + super(LazyReferenceField, self).__init__(**kwargs) + + @property + def document_type(self): + if isinstance(self.document_type_obj, six.string_types): + if self.document_type_obj == RECURSIVE_REFERENCE_CONSTANT: + self.document_type_obj = self.owner_document + else: + self.document_type_obj = get_document(self.document_type_obj) + return self.document_type_obj + + def __get__(self, instance, owner): + """Descriptor to allow lazy dereferencing.""" + if instance is None: + # Document class being used rather than a document object + return self + + value = instance._data.get(self.name) + if isinstance(value, LazyReference): + if value.passthrough != self.passthrough: + instance._data[self.name] = LazyReference( + value.document_type, value.pk, passthrough=self.passthrough) + elif value is not None: + if isinstance(value, self.document_type): + value = LazyReference(self.document_type, value.pk, passthrough=self.passthrough) + elif isinstance(value, DBRef): + value = LazyReference(self.document_type, value.id, passthrough=self.passthrough) + else: + # value is the primary key of the referenced document + value = LazyReference(self.document_type, value, passthrough=self.passthrough) + instance._data[self.name] = value + + return super(LazyReferenceField, self).__get__(instance, owner) + + def to_mongo(self, value): + if isinstance(value, LazyReference): + pk = value.pk + elif isinstance(value, self.document_type): + pk = value.pk + elif isinstance(value, DBRef): + pk = value.id + else: + # value is the primary key of the referenced document + pk = value + id_field_name = self.document_type._meta['id_field'] + id_field = self.document_type._fields[id_field_name] + pk = id_field.to_mongo(pk) + if self.dbref: + return DBRef(self.document_type._get_collection_name(), pk) + else: + return pk + + def validate(self, value): + if isinstance(value, LazyReference): + if not issubclass(value.document_type, self.document_type): + self.error('Reference must be on a `%s` document.' % self.document_type) + pk = value.pk + elif isinstance(value, self.document_type): + pk = value.pk + elif isinstance(value, DBRef): + # TODO: check collection ? + collection = self.document_type._get_collection_name() + if value.collection != collection: + self.error("DBRef on bad collection (must be on `%s`)" % collection) + pk = value.id + else: + # value is the primary key of the referenced document + id_field_name = self.document_type._meta['id_field'] + id_field = getattr(self.document_type, id_field_name) + pk = value + try: + id_field.validate(pk) + except ValidationError: + self.error("value should be `{0}` document, LazyReference or DBRef on `{0}` " + "or `{0}`'s primary key (i.e. `{1}`)".format( + self.document_type.__name__, type(id_field).__name__)) + + if pk is None: + self.error('You can only reference documents once they have been ' + 'saved to the database') + + def prepare_query_value(self, op, value): + if value is None: + return None + super(LazyReferenceField, self).prepare_query_value(op, value) + return self.to_mongo(value) + + def lookup_member(self, member_name): + return self.document_type._fields.get(member_name) diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 7a0ccc25..84156622 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -26,7 +26,7 @@ except ImportError: from mongoengine import * from mongoengine.connection import get_db from mongoengine.base import (BaseDict, BaseField, EmbeddedDocumentList, - _document_registry) + _document_registry, LazyReference) from tests.utils import MongoDBTestCase @@ -931,7 +931,9 @@ class FieldTest(MongoDBTestCase): comments = ListField(EmbeddedDocumentField(Comment)) tags = ListField(StringField()) authors = ListField(ReferenceField(User)) + authors_as_lazy = ListField(LazyReferenceField(User)) generic = ListField(GenericReferenceField()) + # generic_as_lazy = ListField(LazyGenericReferenceField()) User.drop_collection() BlogPost.drop_collection() @@ -969,6 +971,15 @@ class FieldTest(MongoDBTestCase): post.authors = [user] post.validate() + post.authors_as_lazy = [Comment()] + self.assertRaises(ValidationError, post.validate) + + post.authors_as_lazy = [User()] + self.assertRaises(ValidationError, post.validate) + + post.authors_as_lazy = [user] + post.validate() + post.generic = [1, 2] self.assertRaises(ValidationError, post.validate) @@ -981,6 +992,18 @@ class FieldTest(MongoDBTestCase): post.generic = [user] post.validate() + # post.generic_as_lazy = [1, 2] + # self.assertRaises(ValidationError, post.validate) + + # post.generic_as_lazy = [User(), Comment()] + # self.assertRaises(ValidationError, post.validate) + + # post.generic_as_lazy = [Comment()] + # self.assertRaises(ValidationError, post.validate) + + # post.generic_as_lazy = [user] + # post.validate() + def test_sorted_list_sorting(self): """Ensure that a sorted list field properly sorts values. """ @@ -4598,5 +4621,256 @@ class CachedReferenceFieldTest(MongoDBTestCase): self.assertTrue(isinstance(ocorrence.animal, Animal)) +class LazyReferenceFieldTest(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_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) + + if __name__ == '__main__': unittest.main() From 35d04582280c189ce7433864686fda20ae859b02 Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Mon, 6 Nov 2017 12:17:31 +0100 Subject: [PATCH 052/250] Add GenericLazyReferenceField --- docs/changelog.rst | 2 +- mongoengine/fields.py | 73 ++++++++++++++- tests/fields/fields.py | 198 +++++++++++++++++++++++++++++++++++++++-- 3 files changed, 261 insertions(+), 12 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 834fbee2..1e9ac7fc 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -4,7 +4,7 @@ Changelog Changes in 0.15.0 ================= -- Add LazyReferenceField to address #1230 +- Add LazyReferenceField and GenericLazyReferenceField to address #1230 Changes in 0.14.1 ================= diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 73a62bc5..61e0cb69 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -47,8 +47,7 @@ __all__ = ( 'GenericEmbeddedDocumentField', 'DynamicField', 'ListField', 'SortedListField', 'EmbeddedDocumentListField', 'DictField', 'MapField', 'ReferenceField', 'CachedReferenceField', - 'LazyReferenceField', - # 'GenericLazyReferenceField', + 'LazyReferenceField', 'GenericLazyReferenceField', 'GenericReferenceField', 'BinaryField', 'GridFSError', 'GridFSProxy', 'FileField', 'ImageGridFsProxy', 'ImproperlyConfigured', 'ImageField', 'GeoPointField', 'PointField', 'LineStringField', 'PolygonField', @@ -1275,6 +1274,12 @@ class GenericReferenceField(BaseField): """A reference to *any* :class:`~mongoengine.document.Document` subclass that will be automatically dereferenced on access (lazily). + Note this field works the same way as :class:`~mongoengine.document.ReferenceField`, + doing database I/O access the first time it is accessed (even if it's to access + it ``pk`` or ``id`` field). + To solve this you should consider using the + :class:`~mongoengine.fields.GenericLazyReferenceField`. + .. note :: * Any documents used as a generic reference must be registered in the document registry. Importing the model will automatically register @@ -2159,6 +2164,8 @@ class LazyReferenceField(BaseField): """A really lazy reference to a document. Unlike the :class:`~mongoengine.fields.ReferenceField` it must be manually dereferenced using it ``fetch()`` method. + + .. versionadded:: 0.15 """ def __init__(self, document_type, passthrough=False, dbref=False, @@ -2274,3 +2281,65 @@ class LazyReferenceField(BaseField): def lookup_member(self, member_name): return self.document_type._fields.get(member_name) + + +class GenericLazyReferenceField(GenericReferenceField): + """A reference to *any* :class:`~mongoengine.document.Document` subclass + that will be automatically dereferenced on access (lazily). + Unlike the :class:`~mongoengine.fields.GenericReferenceField` it must be + manually dereferenced using it ``fetch()`` method. + + .. note :: + * Any documents used as a generic reference must be registered in the + document registry. Importing the model will automatically register + it. + + * You can use the choices param to limit the acceptable Document types + + .. versionadded:: 0.15 + """ + + def __init__(self, *args, **kwargs): + self.passthrough = kwargs.pop('passthrough', False) + super(GenericLazyReferenceField, self).__init__(*args, **kwargs) + + def _validate_choices(self, value): + if isinstance(value, LazyReference): + value = value.document_type + super(GenericLazyReferenceField, self)._validate_choices(value) + + def __get__(self, instance, owner): + if instance is None: + return self + + value = instance._data.get(self.name) + if isinstance(value, LazyReference): + if value.passthrough != self.passthrough: + instance._data[self.name] = LazyReference( + value.document_type, value.pk, passthrough=self.passthrough) + elif value is not None: + if isinstance(value, (dict, SON)): + value = LazyReference(get_document(value['_cls']), value['_ref'].id, passthrough=self.passthrough) + elif isinstance(value, Document): + value = LazyReference(type(value), value.pk, passthrough=self.passthrough) + instance._data[self.name] = value + + return super(GenericLazyReferenceField, self).__get__(instance, owner) + + def validate(self, value): + if isinstance(value, LazyReference) and value.pk is None: + self.error('You can only reference documents once they have been' + ' saved to the database') + return super(GenericLazyReferenceField, self).validate(value) + + def to_mongo(self, document): + if document is None: + return None + + if isinstance(document, LazyReference): + return SON(( + ('_cls', document.document_type._class_name), + ('_ref', document) + )) + else: + return super(GenericLazyReferenceField, self).to_mongo(document) diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 84156622..632f5404 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -933,7 +933,7 @@ class FieldTest(MongoDBTestCase): authors = ListField(ReferenceField(User)) authors_as_lazy = ListField(LazyReferenceField(User)) generic = ListField(GenericReferenceField()) - # generic_as_lazy = ListField(LazyGenericReferenceField()) + generic_as_lazy = ListField(GenericLazyReferenceField()) User.drop_collection() BlogPost.drop_collection() @@ -992,17 +992,17 @@ class FieldTest(MongoDBTestCase): post.generic = [user] post.validate() - # post.generic_as_lazy = [1, 2] - # self.assertRaises(ValidationError, post.validate) + post.generic_as_lazy = [1, 2] + self.assertRaises(ValidationError, post.validate) - # post.generic_as_lazy = [User(), Comment()] - # self.assertRaises(ValidationError, post.validate) + post.generic_as_lazy = [User(), Comment()] + self.assertRaises(ValidationError, post.validate) - # post.generic_as_lazy = [Comment()] - # self.assertRaises(ValidationError, post.validate) + post.generic_as_lazy = [Comment()] + self.assertRaises(ValidationError, post.validate) - # post.generic_as_lazy = [user] - # post.validate() + post.generic_as_lazy = [user] + post.validate() def test_sorted_list_sorting(self): """Ensure that a sorted list field properly sorts values. @@ -4872,5 +4872,185 @@ class LazyReferenceFieldTest(MongoDBTestCase): self.assertNotEqual(other_animalref, animal) +class GenericLazyReferenceFieldTest(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) + + if __name__ == '__main__': unittest.main() From da33cb54fe3e80490e55957da914fec6bbde92ba Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Mon, 6 Nov 2017 14:11:11 +0100 Subject: [PATCH 053/250] Correct style --- mongoengine/base/datastructures.py | 2 +- mongoengine/fields.py | 11 ++++++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index 043df471..43f32810 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -1,8 +1,8 @@ import itertools import weakref -import six from bson import DBRef +import six from mongoengine.common import _import_class from mongoengine.errors import DoesNotExist, MultipleObjectsReturned diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 61e0cb69..62d9b941 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -26,8 +26,8 @@ except ImportError: Int64 = long from mongoengine.base import (BaseDocument, BaseField, ComplexBaseField, - GeoJsonBaseField, ObjectIdField, get_document, - LazyReference) + GeoJsonBaseField, LazyReference, ObjectIdField, + get_document) from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db from mongoengine.document import Document, EmbeddedDocument from mongoengine.errors import DoesNotExist, InvalidQueryError, ValidationError @@ -2265,9 +2265,10 @@ class LazyReferenceField(BaseField): try: id_field.validate(pk) except ValidationError: - self.error("value should be `{0}` document, LazyReference or DBRef on `{0}` " - "or `{0}`'s primary key (i.e. `{1}`)".format( - self.document_type.__name__, type(id_field).__name__)) + self.error( + "value should be `{0}` document, LazyReference or DBRef on `{0}` " + "or `{0}`'s primary key (i.e. `{1}`)".format( + self.document_type.__name__, type(id_field).__name__)) if pk is None: self.error('You can only reference documents once they have been ' From ea25972257fd75ddf6a5cee674e1b9ed67f80ad7 Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Mon, 6 Nov 2017 14:39:10 +0100 Subject: [PATCH 054/250] Bump version to 0.15.0 --- mongoengine/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/__init__.py b/mongoengine/__init__.py index c7c6f707..a1b7d682 100644 --- a/mongoengine/__init__.py +++ b/mongoengine/__init__.py @@ -23,7 +23,7 @@ __all__ = (list(document.__all__) + list(fields.__all__) + list(signals.__all__) + list(errors.__all__)) -VERSION = (0, 14, 3) +VERSION = (0, 15, 0) def get_version(): From 4f5b0634ad944534012a7752f26dfbe541160a2c Mon Sep 17 00:00:00 2001 From: Ryan Scott Date: Tue, 7 Nov 2017 16:26:01 -0500 Subject: [PATCH 055/250] Add documentation for auto_create_index to the Indexing section of the Docs --- docs/guide/defining-documents.rst | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index d41ae7e6..5ff7a56b 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -526,8 +526,9 @@ There are a few top level defaults for all indexes that can be set:: meta = { 'index_options': {}, 'index_background': True, + 'index_cls': False, + 'auto_create_index': True, 'index_drop_dups': True, - 'index_cls': False } @@ -540,6 +541,12 @@ There are a few top level defaults for all indexes that can be set:: :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 From 6b38ef3c9f0a69420fe4305dda226a0faf9f0528 Mon Sep 17 00:00:00 2001 From: kcarretto Date: Sat, 11 Nov 2017 03:36:28 -0500 Subject: [PATCH 056/250] Fixed format string issue in mongoengine error message. --- mongoengine/fields.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 62d9b941..8692e3a7 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1108,7 +1108,7 @@ class ReferenceField(BaseField): if self.document_type._meta.get('abstract') and \ not isinstance(value, self.document_type): self.error( - '%s is not an instance of abstract reference type %s' % ( + '%s is not an instance of abstract reference type %s' % (value, self.document_type._class_name) ) From 47c7cb932741098e264dc9000e1ddf4fe3ed76fb Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Wed, 15 Nov 2017 20:44:36 +0100 Subject: [PATCH 057/250] Ignore style I202 rule (see https://github.com/PyCQA/flake8-import-order/issues/122) --- setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index eabe3271..46edff3b 100644 --- a/setup.cfg +++ b/setup.cfg @@ -5,7 +5,7 @@ tests=tests cover-package=mongoengine [flake8] -ignore=E501,F401,F403,F405,I201 +ignore=E501,F401,F403,F405,I201,I202 exclude=build,dist,docs,venv,venv3,.tox,.eggs,tests max-complexity=47 application-import-names=mongoengine,tests From c1c09fa6b4c832b99afeea83d19d290468689fe4 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Tue, 21 Nov 2017 21:56:26 +0800 Subject: [PATCH 058/250] fix validatione error for invalid embedded document instance #1067 --- mongoengine/fields.py | 6 +++++- tests/queryset/queryset.py | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 6c4a06c9..0aa51b2d 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -688,6 +688,11 @@ class GenericEmbeddedDocumentField(BaseField): return value def validate(self, value, clean=True): + if self.choices and isinstance(value, SON): + for choice in self.choices: + if value['_cls'] == choice._class_name: + return True + if not isinstance(value, EmbeddedDocument): self.error('Invalid embedded document instance provided to an ' 'GenericEmbeddedDocumentField') @@ -705,7 +710,6 @@ class GenericEmbeddedDocumentField(BaseField): def to_mongo(self, document, use_db_field=True, fields=None): if document is None: return None - data = document.to_mongo(use_db_field, fields) if '_cls' not in data: data['_cls'] = document._class_name diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 28e84af4..43800fff 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -2086,6 +2086,23 @@ class QuerySetTest(unittest.TestCase): Site.objects(id=s.id).update_one( pull_all__collaborators__helpful__user=['Ross']) + def test_pull_in_genericembedded_field(self): + + class Foo(EmbeddedDocument): + name = StringField() + + class Bar(Document): + foos = ListField(GenericEmbeddedDocumentField( + choices=[Foo, ])) + + Bar.drop_collection() + + foo = Foo(name="bar") + bar = Bar(foos=[foo]).save() + Bar.objects(id=bar.id).update(pull__foos=foo) + bar.reload() + self.assertEqual(len(bar.foos), 0) + def test_update_one_pop_generic_reference(self): class BlogTag(Document): @@ -2179,6 +2196,24 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(message.authors[1].name, "Ross") self.assertEqual(message.authors[2].name, "Adam") + def test_set_generic_embedded_documents(self): + + class Bar(EmbeddedDocument): + name = StringField() + + class User(Document): + username = StringField() + bar = GenericEmbeddedDocumentField(choices=[Bar,]) + + User.drop_collection() + + User(username='abc').save() + User.objects(username='abc').update( + set__bar=Bar(name='test'), upsert=True) + + user = User.objects(username='abc').first() + self.assertEqual(user.bar.name, "test") + def test_reload_embedded_docs_instance(self): class SubDoc(EmbeddedDocument): From e74f65901565f64b39a51edc22a1564d8f9fed9a Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Wed, 8 Nov 2017 18:05:30 +0100 Subject: [PATCH 059/250] Improve LazyReferenceField and GenericLazyReferenceField with nested fields --- mongoengine/base/document.py | 3 +- mongoengine/dereference.py | 9 +++- mongoengine/fields.py | 56 +++++++++++++++-------- setup.cfg | 2 +- tests/fields/fields.py | 86 ++++++++++++++++++++++++++++++++++++ 5 files changed, 134 insertions(+), 22 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index f8ab73d0..658d0c79 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -13,6 +13,7 @@ from mongoengine import signals from mongoengine.base.common import get_document from mongoengine.base.datastructures import (BaseDict, BaseList, EmbeddedDocumentList, + LazyReference, StrictDict) from mongoengine.base.fields import ComplexBaseField from mongoengine.common import _import_class @@ -488,7 +489,7 @@ class BaseDocument(object): else: data = getattr(data, part, None) - if hasattr(data, '_changed_fields'): + if not isinstance(data, LazyReference) and hasattr(data, '_changed_fields'): if getattr(data, '_is_document', False): continue diff --git a/mongoengine/dereference.py b/mongoengine/dereference.py index 59204d4d..7fe34e43 100644 --- a/mongoengine/dereference.py +++ b/mongoengine/dereference.py @@ -3,6 +3,7 @@ import six 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 @@ -99,7 +100,10 @@ class DeReference(object): if isinstance(item, (Document, EmbeddedDocument)): for field_name, field in item._fields.iteritems(): v = item._data.get(field_name, None) - if isinstance(v, DBRef): + 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']), set()).add(v['_ref'].id) @@ -110,6 +114,9 @@ class DeReference(object): if isinstance(field_cls, (Document, TopLevelDocumentMetaclass)): key = field_cls 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: diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 6c4a06c9..8ca2b17f 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -28,6 +28,7 @@ except ImportError: from mongoengine.base import (BaseDocument, BaseField, ComplexBaseField, GeoJsonBaseField, LazyReference, ObjectIdField, get_document) +from mongoengine.common import _import_class from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db from mongoengine.document import Document, EmbeddedDocument from mongoengine.errors import DoesNotExist, InvalidQueryError, ValidationError @@ -789,6 +790,17 @@ class ListField(ComplexBaseField): kwargs.setdefault('default', lambda: []) super(ListField, self).__init__(**kwargs) + def __get__(self, instance, owner): + if instance is None: + # Document class being used rather than a document object + return self + value = instance._data.get(self.name) + LazyReferenceField = _import_class('LazyReferenceField') + GenericLazyReferenceField = _import_class('GenericLazyReferenceField') + if isinstance(self.field, (LazyReferenceField, GenericLazyReferenceField)) and value: + instance._data[self.name] = [self.field.build_lazyref(x) for x in value] + return super(ListField, self).__get__(instance, owner) + def validate(self, value): """Make sure that a list of valid fields is being used.""" if (not isinstance(value, (list, tuple, QuerySet)) or @@ -2211,17 +2223,10 @@ class LazyReferenceField(BaseField): self.document_type_obj = get_document(self.document_type_obj) return self.document_type_obj - def __get__(self, instance, owner): - """Descriptor to allow lazy dereferencing.""" - if instance is None: - # Document class being used rather than a document object - return self - - value = instance._data.get(self.name) + def build_lazyref(self, value): if isinstance(value, LazyReference): if value.passthrough != self.passthrough: - instance._data[self.name] = LazyReference( - value.document_type, value.pk, passthrough=self.passthrough) + value = LazyReference(value.document_type, value.pk, passthrough=self.passthrough) elif value is not None: if isinstance(value, self.document_type): value = LazyReference(self.document_type, value.pk, passthrough=self.passthrough) @@ -2230,6 +2235,16 @@ class LazyReferenceField(BaseField): else: # value is the primary key of the referenced document value = LazyReference(self.document_type, value, passthrough=self.passthrough) + return value + + def __get__(self, instance, owner): + """Descriptor to allow lazy dereferencing.""" + if instance is None: + # Document class being used rather than a document object + return self + + value = self.build_lazyref(instance._data.get(self.name)) + if value: instance._data[self.name] = value return super(LazyReferenceField, self).__get__(instance, owner) @@ -2254,7 +2269,7 @@ class LazyReferenceField(BaseField): def validate(self, value): if isinstance(value, LazyReference): - if not issubclass(value.document_type, self.document_type): + if value.collection != self.document_type._get_collection_name(): self.error('Reference must be on a `%s` document.' % self.document_type) pk = value.pk elif isinstance(value, self.document_type): @@ -2314,23 +2329,26 @@ class GenericLazyReferenceField(GenericReferenceField): def _validate_choices(self, value): if isinstance(value, LazyReference): - value = value.document_type + value = value.document_type._class_name super(GenericLazyReferenceField, self)._validate_choices(value) - def __get__(self, instance, owner): - if instance is None: - return self - - value = instance._data.get(self.name) + def build_lazyref(self, value): if isinstance(value, LazyReference): if value.passthrough != self.passthrough: - instance._data[self.name] = LazyReference( - value.document_type, value.pk, passthrough=self.passthrough) + value = LazyReference(value.document_type, value.pk, passthrough=self.passthrough) elif value is not None: if isinstance(value, (dict, SON)): value = LazyReference(get_document(value['_cls']), value['_ref'].id, passthrough=self.passthrough) elif isinstance(value, Document): value = LazyReference(type(value), value.pk, passthrough=self.passthrough) + return value + + def __get__(self, instance, owner): + if instance is None: + return self + + value = self.build_lazyref(instance._data.get(self.name)) + if value: instance._data[self.name] = value return super(GenericLazyReferenceField, self).__get__(instance, owner) @@ -2348,7 +2366,7 @@ class GenericLazyReferenceField(GenericReferenceField): if isinstance(document, LazyReference): return SON(( ('_cls', document.document_type._class_name), - ('_ref', document) + ('_ref', DBRef(document.document_type._get_collection_name(), document.pk)) )) else: return super(GenericLazyReferenceField, self).to_mongo(document) diff --git a/setup.cfg b/setup.cfg index 46edff3b..fd6192b8 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,7 +1,7 @@ [nosetests] verbosity=2 detailed-errors=1 -tests=tests +#tests=tests cover-package=mongoengine [flake8] diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 632f5404..ffee25e6 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -4871,6 +4871,48 @@ class LazyReferenceFieldTest(MongoDBTestCase): 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 GenericLazyReferenceFieldTest(MongoDBTestCase): def test_generic_lazy_reference_simple(self): @@ -5051,6 +5093,50 @@ class GenericLazyReferenceFieldTest(MongoDBTestCase): p = Ocurrence.objects.get() self.assertIs(p.animal, None) + 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) + if __name__ == '__main__': unittest.main() From 60758dd76b4ae1831e4f3f389c71b95b0e77abd2 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Wed, 22 Nov 2017 18:56:12 +0800 Subject: [PATCH 060/250] add changelog --- docs/changelog.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index 1e9ac7fc..b4852178 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -5,6 +5,7 @@ Changelog Changes in 0.15.0 ================= - Add LazyReferenceField and GenericLazyReferenceField to address #1230 +- Fix validation error for invalid embedded document instance #1067 Changes in 0.14.1 ================= From 79486e33936d6302e1cb898c38a9535648563343 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Wed, 22 Nov 2017 19:27:35 +0800 Subject: [PATCH 061/250] change description in changelog --- docs/changelog.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index b4852178..249d4659 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -5,7 +5,7 @@ Changelog Changes in 0.15.0 ================= - Add LazyReferenceField and GenericLazyReferenceField to address #1230 -- Fix validation error for invalid embedded document instance #1067 +- Fix validation error instance in GenericEmbeddedDocumentField #1067 Changes in 0.14.1 ================= From 0ce081323fd66ad00b00eb4bc9edc6b888a5fa2d Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Wed, 22 Nov 2017 22:19:50 +0800 Subject: [PATCH 062/250] move changes to development --- docs/changelog.rst | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 249d4659..f96fc11b 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -2,10 +2,13 @@ Changelog ========= +Development +=========== +- Fix validation error instance in GenericEmbeddedDocumentField #1067 + Changes in 0.15.0 ================= - Add LazyReferenceField and GenericLazyReferenceField to address #1230 -- Fix validation error instance in GenericEmbeddedDocumentField #1067 Changes in 0.14.1 ================= From c45dfacb411a062dc75acd27e784693fb6c0898a Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Wed, 29 Nov 2017 16:41:42 +0100 Subject: [PATCH 063/250] Update changelog --- docs/changelog.rst | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index 1e9ac7fc..151fdd08 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -2,6 +2,13 @@ Changelog ========= +dev +=== +- 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 + + Changes in 0.15.0 ================= - Add LazyReferenceField and GenericLazyReferenceField to address #1230 From b35efb9f7205ab9b07d5b21c5cdb26d4c6d07201 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Tue, 21 Nov 2017 21:56:26 +0800 Subject: [PATCH 064/250] fix validatione error for invalid embedded document instance #1067 --- mongoengine/fields.py | 6 +++++- tests/queryset/queryset.py | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 8ca2b17f..4e941c4e 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -689,6 +689,11 @@ class GenericEmbeddedDocumentField(BaseField): return value def validate(self, value, clean=True): + if self.choices and isinstance(value, SON): + for choice in self.choices: + if value['_cls'] == choice._class_name: + return True + if not isinstance(value, EmbeddedDocument): self.error('Invalid embedded document instance provided to an ' 'GenericEmbeddedDocumentField') @@ -706,7 +711,6 @@ class GenericEmbeddedDocumentField(BaseField): def to_mongo(self, document, use_db_field=True, fields=None): if document is None: return None - data = document.to_mongo(use_db_field, fields) if '_cls' not in data: data['_cls'] = document._class_name diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 28e84af4..43800fff 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -2086,6 +2086,23 @@ class QuerySetTest(unittest.TestCase): Site.objects(id=s.id).update_one( pull_all__collaborators__helpful__user=['Ross']) + def test_pull_in_genericembedded_field(self): + + class Foo(EmbeddedDocument): + name = StringField() + + class Bar(Document): + foos = ListField(GenericEmbeddedDocumentField( + choices=[Foo, ])) + + Bar.drop_collection() + + foo = Foo(name="bar") + bar = Bar(foos=[foo]).save() + Bar.objects(id=bar.id).update(pull__foos=foo) + bar.reload() + self.assertEqual(len(bar.foos), 0) + def test_update_one_pop_generic_reference(self): class BlogTag(Document): @@ -2179,6 +2196,24 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(message.authors[1].name, "Ross") self.assertEqual(message.authors[2].name, "Adam") + def test_set_generic_embedded_documents(self): + + class Bar(EmbeddedDocument): + name = StringField() + + class User(Document): + username = StringField() + bar = GenericEmbeddedDocumentField(choices=[Bar,]) + + User.drop_collection() + + User(username='abc').save() + User.objects(username='abc').update( + set__bar=Bar(name='test'), upsert=True) + + user = User.objects(username='abc').first() + self.assertEqual(user.bar.name, "test") + def test_reload_embedded_docs_instance(self): class SubDoc(EmbeddedDocument): From ce9ea7baad2870145203a51e069f6a6f57526518 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Wed, 22 Nov 2017 18:56:12 +0800 Subject: [PATCH 065/250] add changelog --- docs/changelog.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index 151fdd08..69e57e0b 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -12,6 +12,7 @@ dev Changes in 0.15.0 ================= - Add LazyReferenceField and GenericLazyReferenceField to address #1230 +- Fix validation error for invalid embedded document instance #1067 Changes in 0.14.1 ================= From 08a4deca17b511974125e26a7151e165231b58de Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Wed, 22 Nov 2017 19:27:35 +0800 Subject: [PATCH 066/250] change description in changelog --- docs/changelog.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 69e57e0b..c44f8432 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -12,7 +12,7 @@ dev Changes in 0.15.0 ================= - Add LazyReferenceField and GenericLazyReferenceField to address #1230 -- Fix validation error for invalid embedded document instance #1067 +- Fix validation error instance in GenericEmbeddedDocumentField #1067 Changes in 0.14.1 ================= From 2cbebf9c99dd5ebd368ca775b60fc25149ea5634 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Wed, 22 Nov 2017 22:19:50 +0800 Subject: [PATCH 067/250] move changes to development --- docs/changelog.rst | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index c44f8432..efd2e0f6 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -7,12 +7,11 @@ dev - 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 Changes in 0.15.0 ================= - Add LazyReferenceField and GenericLazyReferenceField to address #1230 -- Fix validation error instance in GenericEmbeddedDocumentField #1067 Changes in 0.14.1 ================= From 9e0ca51c2f47618b539c2724ecfe656e454eb062 Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Fri, 1 Dec 2017 08:40:51 +0800 Subject: [PATCH 068/250] remove merge conflict after rebase #1067 --- docs/changelog.rst | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 1bd932d6..efd2e0f6 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -2,7 +2,6 @@ Changelog ========= -<<<<<<< HEAD dev === - Subfield resolve error in generic_emdedded_document query #1651 #1652 From 7674dc9b344f99e47a6df3b1c44d72faf57ff137 Mon Sep 17 00:00:00 2001 From: Esmail Date: Tue, 5 Dec 2017 15:14:15 -0500 Subject: [PATCH 069/250] One-character typo fix ("that" -> "than") --- docs/tutorial.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorial.rst b/docs/tutorial.rst index cc5b647d..ea1a04c1 100644 --- a/docs/tutorial.rst +++ b/docs/tutorial.rst @@ -153,7 +153,7 @@ 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:: From 22a8ad2fde14b0c5eb2cf3cbc0fd4e0de98d67c5 Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Wed, 20 Dec 2017 15:17:54 +0800 Subject: [PATCH 070/250] update fields argument when given #1172 --- mongoengine/fields.py | 6 +++++- tests/fields/fields.py | 45 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+), 1 deletion(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 8ca2b17f..17003974 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1256,7 +1256,11 @@ class CachedReferenceField(BaseField): if value.pk is None: self.error('You can only reference documents once they have' ' been saved to the database') - return {'_id': value.pk} + value_dict = {'_id': value.pk} + for field in self.fields: + value_dict.update({field: value[field]}) + + return value_dict raise NotImplementedError diff --git a/tests/fields/fields.py b/tests/fields/fields.py index ffee25e6..f86ffdb4 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -4379,6 +4379,51 @@ class CachedReferenceFieldTest(MongoDBTestCase): 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 = ( From 6621c318db9fc5d3395d9ceb9d0900cc0fef0e68 Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Wed, 20 Dec 2017 15:28:33 +0800 Subject: [PATCH 071/250] add changelog #1712 --- docs/changelog.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index 151fdd08..7b937822 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -7,6 +7,7 @@ dev - 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 +- Update cached fields when fields argument is given #1712 Changes in 0.15.0 From 18a5fba42b2af5e0835293b1e7201747100014c9 Mon Sep 17 00:00:00 2001 From: erdenezul Date: Fri, 22 Dec 2017 20:19:21 +0800 Subject: [PATCH 072/250] Revert "add tests to increase code coverage" --- tests/fields/fields.py | 36 +----------------------------------- tests/queryset/geo.py | 4 ---- tests/queryset/queryset.py | 10 ---------- 3 files changed, 1 insertion(+), 49 deletions(-) diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 4360f298..ffee25e6 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -312,27 +312,6 @@ class FieldTest(MongoDBTestCase): self.assertEqual(1, TestDocument.objects(long_fld__ne=None).count()) - def test_callable_validation(self): - """Ensure that callable validation works""" - def check_even(value): - return value % 2 == 0 - - class Order(Document): - number = IntField(validation=check_even) - - Order.drop_collection() - - order = Order(number=3) - self.assertRaises(ValidationError, order.validate) - - class User(Document): - name = StringField(validation=1) - - User.drop_collection() - - user = User(name='test') - self.assertRaises(ValidationError, user.validate) - def test_object_id_validation(self): """Ensure that invalid values cannot be assigned to an ObjectIdField. @@ -355,7 +334,7 @@ class FieldTest(MongoDBTestCase): def test_string_validation(self): """Ensure that invalid values cannot be assigned to string fields.""" class Person(Document): - name = StringField(max_length=20, min_length=5) + name = StringField(max_length=20) userid = StringField(r'[0-9a-z_]+$') person = Person(name=34) @@ -373,10 +352,6 @@ class FieldTest(MongoDBTestCase): person = Person(name='Name that is more than twenty characters') self.assertRaises(ValidationError, person.validate) - # Test max length validation on name - person = Person(name='aa') - self.assertRaises(ValidationError, person.validate) - person.name = 'Shorter name' person.validate() @@ -462,10 +437,6 @@ class FieldTest(MongoDBTestCase): doc.age = 'ten' self.assertRaises(ValidationError, doc.validate) - # Test max_value validation - doc.value = 200 - self.assertRaises(ValidationError, doc.validate) - def test_float_validation(self): """Ensure that invalid values cannot be assigned to float fields. """ @@ -548,11 +519,6 @@ class FieldTest(MongoDBTestCase): class User(Document): name = StringField(db_field='name\0') - # db field should be a string - with self.assertRaises(TypeError): - class User(Document): - name = StringField(db_field=1) - def test_decimal_comparison(self): class Person(Document): money = DecimalField() diff --git a/tests/queryset/geo.py b/tests/queryset/geo.py index acfd9364..38c0377e 100644 --- a/tests/queryset/geo.py +++ b/tests/queryset/geo.py @@ -429,10 +429,6 @@ class GeoQueriesTest(MongoDBTestCase): roads = Road.objects.filter(line__geo_within=polygon).count() self.assertEqual(1, roads) - sphere = [[-1, 42,], 2] - roads = Road.objects.filter(line__geo_within_sphere=sphere).count() - self.assertEqual(0, roads) - roads = Road.objects.filter(line__geo_within={"$geometry": polygon}).count() self.assertEqual(1, roads) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 984314ed..43800fff 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -1861,10 +1861,6 @@ class QuerySetTest(unittest.TestCase): post = BlogPost(name="Test Post", hits=5, tags=['test']) post.save() - BlogPost.objects.update(hits=11) - post.reload() - self.assertEqual(post.hits, 11) - BlogPost.objects.update(set__hits=10) post.reload() self.assertEqual(post.hits, 10) @@ -1886,12 +1882,6 @@ class QuerySetTest(unittest.TestCase): post.reload() self.assertTrue('mongo' in post.tags) - # Push with arrays - BlogPost.objects.update(push__tags=['python', 'scala']) - post.reload() - self.assertTrue('python' in post.tags) - self.assertTrue('scala' in post.tags) - BlogPost.objects.update_one(push_all__tags=['db', 'nosql']) post.reload() self.assertTrue('db' in post.tags and 'nosql' in post.tags) From 12b846586c4e72d712920d32e595146911c4f9e2 Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Fri, 22 Dec 2017 13:23:03 +0100 Subject: [PATCH 073/250] Fix travis tests with mongodb 2.4 & pymongo 3 --- .travis.yml | 14 +++++++------- tox.ini | 5 +++-- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/.travis.yml b/.travis.yml index 78a9f787..a70c711e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -21,7 +21,7 @@ python: env: - MONGODB=2.6 PYMONGO=2.7 - MONGODB=2.6 PYMONGO=2.8 -- MONGODB=2.6 PYMONGO=3.0 +- MONGODB=2.6 PYMONGO=3.x matrix: # Finish the build as soon as one job fails @@ -31,19 +31,19 @@ matrix: - python: 2.7 env: MONGODB=2.4 PYMONGO=2.7 - python: 2.7 - env: MONGODB=2.4 PYMONGO=3.0 + env: MONGODB=2.4 PYMONGO=3.5 - python: 2.7 - env: MONGODB=3.0 PYMONGO=3.0 + env: MONGODB=3.0 PYMONGO=3.x - python: 3.5 env: MONGODB=2.4 PYMONGO=2.7 - python: 3.5 - env: MONGODB=2.4 PYMONGO=3.0 + env: MONGODB=2.4 PYMONGO=3.5 - python: 3.5 - env: MONGODB=3.0 PYMONGO=3.0 + env: MONGODB=3.0 PYMONGO=3.x - python: 3.6 - env: MONGODB=2.4 PYMONGO=3.0 + env: MONGODB=2.4 PYMONGO=3.5 - python: 3.6 - env: MONGODB=3.0 PYMONGO=3.0 + env: MONGODB=3.0 PYMONGO=3.x before_install: - bash .install_mongodb_on_travis.sh diff --git a/tox.ini b/tox.ini index 7f0d36e4..9bb0c5ec 100644 --- a/tox.ini +++ b/tox.ini @@ -1,5 +1,5 @@ [tox] -envlist = {py27,py35,pypy,pypy3}-{mg27,mg28,mg30} +envlist = {py27,py35,pypy,pypy3}-{mg27,mg28,mg35,mg3x} [testenv] commands = @@ -8,6 +8,7 @@ deps = nose mg27: PyMongo<2.8 mg28: PyMongo>=2.8,<2.9 - mg30: PyMongo>=3.0 + mg35: PyMongo==3.5 + mg3x: PyMongo>=3.0 setenv = PYTHON_EGG_CACHE = {envdir}/python-eggs From aa5510531df9eed361e34c5130bc19ce15b1185e Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Wed, 20 Dec 2017 15:17:54 +0800 Subject: [PATCH 074/250] update fields argument when given #1172 --- mongoengine/fields.py | 6 +++++- tests/fields/fields.py | 45 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+), 1 deletion(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 4e941c4e..7932f73a 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1260,7 +1260,11 @@ class CachedReferenceField(BaseField): if value.pk is None: self.error('You can only reference documents once they have' ' been saved to the database') - return {'_id': value.pk} + value_dict = {'_id': value.pk} + for field in self.fields: + value_dict.update({field: value[field]}) + + return value_dict raise NotImplementedError diff --git a/tests/fields/fields.py b/tests/fields/fields.py index ffee25e6..f86ffdb4 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -4379,6 +4379,51 @@ class CachedReferenceFieldTest(MongoDBTestCase): 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 = ( From b66621f9c648d6fffbfd770688d918559bc6b7fb Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Wed, 20 Dec 2017 15:28:33 +0800 Subject: [PATCH 075/250] add changelog #1712 --- docs/changelog.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index efd2e0f6..219d60df 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -8,6 +8,7 @@ dev - 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 Changes in 0.15.0 ================= From 101947da8bec04b532b55c7a252dfff5921b3f0f Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Wed, 20 Dec 2017 15:17:54 +0800 Subject: [PATCH 076/250] update fields argument when given #1172 --- mongoengine/fields.py | 6 +++++- tests/fields/fields.py | 45 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+), 1 deletion(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 4e941c4e..7932f73a 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1260,7 +1260,11 @@ class CachedReferenceField(BaseField): if value.pk is None: self.error('You can only reference documents once they have' ' been saved to the database') - return {'_id': value.pk} + value_dict = {'_id': value.pk} + for field in self.fields: + value_dict.update({field: value[field]}) + + return value_dict raise NotImplementedError diff --git a/tests/fields/fields.py b/tests/fields/fields.py index ffee25e6..f86ffdb4 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -4379,6 +4379,51 @@ class CachedReferenceFieldTest(MongoDBTestCase): 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 = ( From 19b18d3d0ab8be238d16a2c41734b6d5dba4adb6 Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Wed, 20 Dec 2017 15:28:33 +0800 Subject: [PATCH 077/250] add changelog #1712 --- docs/changelog.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index efd2e0f6..219d60df 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -8,6 +8,7 @@ dev - 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 Changes in 0.15.0 ================= From 919f221be9738dc278f08c31c7421267bfd4f2de Mon Sep 17 00:00:00 2001 From: Chuan-Heng Hsiao Date: Thu, 11 Jan 2018 07:28:25 -0500 Subject: [PATCH 078/250] defensive programming for v as an instance of DBRef when accessing v.collection in dereference --- mongoengine/dereference.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/dereference.py b/mongoengine/dereference.py index 7fe34e43..18b365cc 100644 --- a/mongoengine/dereference.py +++ b/mongoengine/dereference.py @@ -237,7 +237,7 @@ class DeReference(object): elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth: item_name = '%s.%s' % (name, k) if name else name data[k] = self._attach_objects(v, depth - 1, instance=instance, name=item_name) - elif hasattr(v, 'id'): + elif isinstance(v, DBRef) and hasattr(v, 'id'): data[k] = self.object_map.get((v.collection, v.id), v) if instance and name: From 22e75c1691e67a487d90166c37f3cf08531226ac Mon Sep 17 00:00:00 2001 From: Ivan Pogrebkov Date: Fri, 26 Jan 2018 10:55:44 +0300 Subject: [PATCH 079/250] Insert null values fix https://stackoverflow.com/questions/42601950/how-to-store-a-null-value-in-mongodb-via-mongoengine --- mongoengine/base/document.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 658d0c79..956e9b0e 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -337,11 +337,10 @@ class BaseDocument(object): value = field.generate() self._data[field_name] = value - if value is not None: - if use_db_field: - data[field.db_field] = value - else: - data[field.name] = value + if use_db_field: + data[field.db_field] = value + else: + data[field.name] = value # Only add _cls if allow_inheritance is True if not self._meta.get('allow_inheritance'): From fb213f6e7432e2b9aca4eb4ce619a9db0c521f28 Mon Sep 17 00:00:00 2001 From: Ivan Pogrebkov Date: Fri, 26 Jan 2018 11:12:02 +0300 Subject: [PATCH 080/250] Update document.py --- mongoengine/base/document.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 956e9b0e..2115a252 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -147,6 +147,7 @@ class BaseDocument(object): if not hasattr(self, name) and not name.startswith('_'): DynamicField = _import_class('DynamicField') + field = DynamicField(db_field=name,null=True) field = DynamicField(db_field=name) field.name = name self._dynamic_fields[name] = field @@ -337,10 +338,11 @@ class BaseDocument(object): value = field.generate() self._data[field_name] = value - if use_db_field: - data[field.db_field] = value - else: - data[field.name] = value + if (value is not None) or (field.null): + if use_db_field: + data[field.db_field] = value + else: + data[field.name] = value # Only add _cls if allow_inheritance is True if not self._meta.get('allow_inheritance'): From 7e8c62104a31bc7168d24e6030437338664340cd Mon Sep 17 00:00:00 2001 From: Ivan Pogrebkov Date: Fri, 26 Jan 2018 11:15:12 +0300 Subject: [PATCH 081/250] null=True now usefull --- mongoengine/document.py | 1 + 1 file changed, 1 insertion(+) diff --git a/mongoengine/document.py b/mongoengine/document.py index f1622934..d635d62e 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -1010,6 +1010,7 @@ class DynamicDocument(Document): field_name = args[0] if field_name in self._dynamic_fields: setattr(self, field_name, None) + self._dynamic_fields[field_name].null = False else: super(DynamicDocument, self).__delattr__(*args, **kwargs) From fdda27abd1ce957d0bb0e3053027ff0a5ce7b9de Mon Sep 17 00:00:00 2001 From: Esmail Date: Thu, 1 Feb 2018 12:58:10 -0500 Subject: [PATCH 082/250] Update `post_save` signal documentation to reflect #594 --- docs/guide/signals.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/guide/signals.rst b/docs/guide/signals.rst index 30277966..eed382c4 100644 --- a/docs/guide/signals.rst +++ b/docs/guide/signals.rst @@ -43,10 +43,10 @@ Available signals include: has taken place but before saving. `post_save` - Called within :meth:`~mongoengine.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.delete` prior to From 8f6c0796e3c66de67110b9f6cf6ac7e4e92e8915 Mon Sep 17 00:00:00 2001 From: Arto Jantunen Date: Fri, 2 Feb 2018 08:20:53 +0200 Subject: [PATCH 083/250] Add db parameter to register_connection This is done to make it compatible with the connect function. --- docs/changelog.rst | 1 + mongoengine/connection.py | 5 +++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 219d60df..29471463 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -9,6 +9,7 @@ dev - 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 Changes in 0.15.0 ================= diff --git a/mongoengine/connection.py b/mongoengine/connection.py index 34ff4dc3..705dc25b 100644 --- a/mongoengine/connection.py +++ b/mongoengine/connection.py @@ -28,7 +28,7 @@ _connections = {} _dbs = {} -def register_connection(alias, name=None, host=None, port=None, +def register_connection(alias, db=None, name=None, host=None, port=None, read_preference=READ_PREFERENCE, username=None, password=None, authentication_source=None, @@ -39,6 +39,7 @@ def register_connection(alias, name=None, host=None, port=None, :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 @@ -58,7 +59,7 @@ def register_connection(alias, name=None, host=None, port=None, .. versionchanged:: 0.10.6 - added mongomock support """ conn_settings = { - 'name': name or 'test', + 'name': name or db or 'test', 'host': host or 'localhost', 'port': port or 27017, 'read_preference': read_preference, From 9e80da705a8dae9336be7df02169f36607769fb8 Mon Sep 17 00:00:00 2001 From: Calgary Michael Date: Fri, 2 Feb 2018 21:47:04 -0600 Subject: [PATCH 084/250] removed usage of 'pushAll' operator --- mongoengine/queryset/transform.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index 3eadaf64..a9874ddf 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -335,7 +335,7 @@ def update(_doc_cls=None, **update): value = {key: value} elif op == 'addToSet' and isinstance(value, list): value = {key: {'$each': value}} - elif op == 'push': + elif op in ('push', 'pushAll'): if parts[-1].isdigit(): key = parts[0] position = int(parts[-1]) @@ -345,7 +345,13 @@ def update(_doc_cls=None, **update): value = [value] value = {key: {'$each': value, '$position': position}} else: - value = {key: value} + 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 From 4d5c6d11ab8665f77aef8ac6e9b2e58843188b75 Mon Sep 17 00:00:00 2001 From: Calgary Michael Date: Fri, 2 Feb 2018 22:04:30 -0600 Subject: [PATCH 085/250] removed deprecated warning for 'update' method --- mongoengine/context_managers.py | 11 ++++++++++- mongoengine/queryset/base.py | 17 ++++++++++------- tests/queryset/queryset.py | 11 ++++++----- 3 files changed, 26 insertions(+), 13 deletions(-) diff --git a/mongoengine/context_managers.py b/mongoengine/context_managers.py index c477575e..e6295570 100644 --- a/mongoengine/context_managers.py +++ b/mongoengine/context_managers.py @@ -1,9 +1,11 @@ from mongoengine.common import _import_class from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db +from pymongo.write_concern import WriteConcern +from contextlib import contextmanager __all__ = ('switch_db', 'switch_collection', 'no_dereference', - 'no_sub_classes', 'query_counter') + 'no_sub_classes', 'query_counter', 'set_write_concern') class switch_db(object): @@ -215,3 +217,10 @@ class query_counter(object): count = self.db.system.profile.find(ignore_query).count() - self.counter self.counter += 1 return count + + +@contextmanager +def set_write_concern(collection, write_concerns): + yield collection.with_options(write_concern=WriteConcern( + **dict(collection.write_concern.document.items()), + **write_concerns)) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 6f9c372c..c6e2137c 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -18,7 +18,7 @@ from mongoengine import signals from mongoengine.base import get_document from mongoengine.common import _import_class from mongoengine.connection import get_db -from mongoengine.context_managers import switch_db +from mongoengine.context_managers import switch_db, set_write_concern from mongoengine.errors import (InvalidQueryError, LookUpError, NotUniqueError, OperationError) from mongoengine.python_support import IS_PYMONGO_3 @@ -510,12 +510,15 @@ class BaseQuerySet(object): else: update['$set'] = {'_cls': queryset._document._class_name} try: - result = queryset._collection.update(query, update, multi=multi, - upsert=upsert, **write_concern) + with set_write_concern(queryset._collection, write_concern) as collection: + update_func = collection.update_one + if multi: + update_func = collection.update_many + result = update_func(query, update, upsert=upsert) if full_result: return result - elif result: - return result['n'] + elif result.raw_result: + return result.raw_result['n'] except pymongo.errors.DuplicateKeyError as err: raise NotUniqueError(u'Update failed (%s)' % six.text_type(err)) except pymongo.errors.OperationFailure as err: @@ -544,10 +547,10 @@ class BaseQuerySet(object): write_concern=write_concern, full_result=True, **update) - if atomic_update['updatedExisting']: + if atomic_update.raw_result['updatedExisting']: document = self.get() else: - document = self._document.objects.with_id(atomic_update['upserted']) + document = self._document.objects.with_id(atomic_update.upserted_id) return document def update_one(self, upsert=False, write_concern=None, **update): diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 43800fff..848fe35d 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -9,6 +9,7 @@ from nose.plugins.skip import SkipTest import pymongo from pymongo.errors import ConfigurationError from pymongo.read_preferences import ReadPreference +from pymongo.results import UpdateResult import six from mongoengine import * @@ -656,14 +657,14 @@ class QuerySetTest(unittest.TestCase): result = self.Person(name="Bob", age=25).update( upsert=True, full_result=True) - self.assertTrue(isinstance(result, dict)) - self.assertTrue("upserted" in result) - self.assertFalse(result["updatedExisting"]) + self.assertTrue(isinstance(result, UpdateResult)) + self.assertTrue("upserted" in result.raw_result) + self.assertFalse(result.raw_result["updatedExisting"]) bob = self.Person.objects.first() result = bob.update(set__age=30, full_result=True) - self.assertTrue(isinstance(result, dict)) - self.assertTrue(result["updatedExisting"]) + self.assertTrue(isinstance(result, UpdateResult)) + self.assertTrue(result.raw_result["updatedExisting"]) self.Person(name="Bob", age=20).save() result = self.Person.objects(name="Bob").update( From fa38bfd4e8884fe2d6c641fa185c90641c5a24c8 Mon Sep 17 00:00:00 2001 From: Calgary Michael Date: Fri, 2 Feb 2018 22:30:06 -0600 Subject: [PATCH 086/250] made set_write_concern python2.7 compatible --- mongoengine/context_managers.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/mongoengine/context_managers.py b/mongoengine/context_managers.py index e6295570..cc35cdd7 100644 --- a/mongoengine/context_managers.py +++ b/mongoengine/context_managers.py @@ -221,6 +221,6 @@ class query_counter(object): @contextmanager def set_write_concern(collection, write_concerns): - yield collection.with_options(write_concern=WriteConcern( - **dict(collection.write_concern.document.items()), - **write_concerns)) + old_concerns = dict(collection.write_concern.document.items()) + combined_concerns = old_concerns.update(write_concerns) + yield collection.with_options(write_concern=WriteConcern(**combined_concerns)) From 6835c15d9b0a0379036417e642516f7cdef76840 Mon Sep 17 00:00:00 2001 From: Calgary Michael Date: Fri, 2 Feb 2018 22:41:07 -0600 Subject: [PATCH 087/250] fixing bug in previous commit --- mongoengine/context_managers.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mongoengine/context_managers.py b/mongoengine/context_managers.py index cc35cdd7..c6d0d40f 100644 --- a/mongoengine/context_managers.py +++ b/mongoengine/context_managers.py @@ -221,6 +221,6 @@ class query_counter(object): @contextmanager def set_write_concern(collection, write_concerns): - old_concerns = dict(collection.write_concern.document.items()) - combined_concerns = old_concerns.update(write_concerns) + combined_concerns = dict(collection.write_concern.document.items()) + combined_concerns.update(write_concerns) yield collection.with_options(write_concern=WriteConcern(**combined_concerns)) From 38fdf264051430babc8e324f878dc265471b4dea Mon Sep 17 00:00:00 2001 From: Calgary Michael Date: Sun, 4 Feb 2018 10:23:50 -0600 Subject: [PATCH 088/250] added tests for push and push_all --- tests/queryset/transform.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/tests/queryset/transform.py b/tests/queryset/transform.py index 20ab0b3f..20a0c278 100644 --- a/tests/queryset/transform.py +++ b/tests/queryset/transform.py @@ -51,6 +51,17 @@ class TransformTest(unittest.TestCase): update = transform.update(DicDoc, pull__dictField__test=doc) self.assertTrue(isinstance(update["$pull"]["dictField"]["test"], dict)) + def test_transform_update_push(self): + """Ensure the differences in behvaior between 'push' and 'push_all'""" + class BlogPost(Document): + tags = ListField(StringField()) + + update = transform.update(BlogPost, push__tags=['mongo', 'db']) + self.assertEqual(update, {'$push': {'tags': ['mongo', 'db']}}) + + update = transform.update(BlogPost, push_all__tags=['mongo', 'db']) + self.assertEqual(update, {'$push': {'tags': {'$each': ['mongo', 'db']}}}) + def test_query_field_name(self): """Ensure that the correct field name is used when querying. """ From 0d854ce906abf87d99ec0a102540570cf800237a Mon Sep 17 00:00:00 2001 From: Ivan Pogrebkov Date: Mon, 5 Feb 2018 03:24:53 +0300 Subject: [PATCH 089/250] style fix --- mongoengine/base/document.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 2115a252..172e052f 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -147,7 +147,7 @@ class BaseDocument(object): if not hasattr(self, name) and not name.startswith('_'): DynamicField = _import_class('DynamicField') - field = DynamicField(db_field=name,null=True) + field = DynamicField(db_field=name, null=True) field = DynamicField(db_field=name) field.name = name self._dynamic_fields[name] = field From 6b04ddfad1b2b6574c03ed842e8020feb361d9ce Mon Sep 17 00:00:00 2001 From: Ivan Pogrebkov Date: Mon, 5 Feb 2018 04:24:03 +0300 Subject: [PATCH 090/250] >< --- mongoengine/base/document.py | 1 - 1 file changed, 1 deletion(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 172e052f..f31c22ce 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -147,7 +147,6 @@ class BaseDocument(object): if not hasattr(self, name) and not name.startswith('_'): DynamicField = _import_class('DynamicField') - field = DynamicField(db_field=name, null=True) field = DynamicField(db_field=name) field.name = name self._dynamic_fields[name] = field From de360c61dd239ef44e2d2abd9c4ce835f1144cf8 Mon Sep 17 00:00:00 2001 From: Ivan Pogrebkov Date: Mon, 5 Feb 2018 04:26:25 +0300 Subject: [PATCH 091/250] removed useless lines --- mongoengine/document.py | 1 - 1 file changed, 1 deletion(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index d635d62e..f1622934 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -1010,7 +1010,6 @@ class DynamicDocument(Document): field_name = args[0] if field_name in self._dynamic_fields: setattr(self, field_name, None) - self._dynamic_fields[field_name].null = False else: super(DynamicDocument, self).__delattr__(*args, **kwargs) From d69808c20414d316fcc6f5a1a6e0d8f751b04a9b Mon Sep 17 00:00:00 2001 From: Ivan Pogrebkov Date: Mon, 5 Feb 2018 12:33:58 +0300 Subject: [PATCH 092/250] oh, ok... --- mongoengine/base/document.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index f31c22ce..348ee977 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -147,7 +147,7 @@ class BaseDocument(object): if not hasattr(self, name) and not name.startswith('_'): DynamicField = _import_class('DynamicField') - field = DynamicField(db_field=name) + field = DynamicField(db_field=name, null=True) field.name = name self._dynamic_fields[name] = field self._fields_ordered += (name,) From 7efa67e7e6a6bf32d208c6628b3b43a4c0d89bab Mon Sep 17 00:00:00 2001 From: Ivan Pogrebkov Date: Mon, 5 Feb 2018 12:35:06 +0300 Subject: [PATCH 093/250] reverse to 'style fix' --- mongoengine/document.py | 1 + 1 file changed, 1 insertion(+) diff --git a/mongoengine/document.py b/mongoengine/document.py index f1622934..d635d62e 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -1010,6 +1010,7 @@ class DynamicDocument(Document): field_name = args[0] if field_name in self._dynamic_fields: setattr(self, field_name, None) + self._dynamic_fields[field_name].null = False else: super(DynamicDocument, self).__delattr__(*args, **kwargs) From 8b5df3ca1733a6fb6d6fcc03273f0545f617732b Mon Sep 17 00:00:00 2001 From: swathi Date: Mon, 22 Jan 2018 17:21:28 -0800 Subject: [PATCH 094/250] fix - allow url with underscore in domain --- mongoengine/fields.py | 2 +- tests/fields/fields.py | 10 ++++++++++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index d812a762..eec31829 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -121,7 +121,7 @@ class URLField(StringField): _URL_REGEX = re.compile( r'^(?:[a-z0-9\.\-]*)://' # scheme is validated separately - r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}(? Date: Sun, 11 Feb 2018 00:59:47 +0900 Subject: [PATCH 095/250] fix case inconsistent casing of "MongoDB" (#1744) --- docs/tutorial.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorial.rst b/docs/tutorial.rst index ea1a04c1..bcd0d17f 100644 --- a/docs/tutorial.rst +++ b/docs/tutorial.rst @@ -86,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 From 0bd2103a8cb10c63371b2d4cefc8809a5d0adc55 Mon Sep 17 00:00:00 2001 From: Andy Yankovsky Date: Tue, 20 Feb 2018 00:02:12 +0300 Subject: [PATCH 096/250] Add test for document update --- tests/document/instance.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/tests/document/instance.py b/tests/document/instance.py index 609bc900..22c44ffa 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -1341,6 +1341,23 @@ class InstanceTest(unittest.TestCase): site = Site.objects.first() self.assertEqual(site.page.log_message, "Error: Dummy message") + def test_update_list_field(self): + """Test update on `ListField` with $pull + $in. + """ + class Doc(Document): + foo = ListField(StringField()) + + Doc.drop_collection() + doc = Doc(foo=['a', 'b', 'c']) + doc.save() + + # Update + doc = Doc.objects.first() + doc.update(pull__foo__in=['a', 'c']) + + doc = Doc.objects.first() + self.assertEqual(doc.foo, ['b']) + def test_embedded_update_db_field(self): """Test update on `EmbeddedDocumentField` fields when db_field is other than default. From 2d76aebb8e9d1ee995eb8945968ca13a2b1b2777 Mon Sep 17 00:00:00 2001 From: KCarretto Date: Wed, 21 Feb 2018 05:02:35 -0500 Subject: [PATCH 097/250] Fixed formatting issue --- mongoengine/fields.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 8692e3a7..d75286f0 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1108,8 +1108,8 @@ class ReferenceField(BaseField): if self.document_type._meta.get('abstract') and \ not isinstance(value, self.document_type): self.error( - '%s is not an instance of abstract reference type %s' % (value, - self.document_type._class_name) + '%s is not an instance of abstract reference type %s' % ( + value, self.document_type._class_name) ) def lookup_member(self, member_name): From aa683226416dac3fa4d5fd757091e2c795cf2ff7 Mon Sep 17 00:00:00 2001 From: estein-de Date: Tue, 27 Feb 2018 08:43:09 -0600 Subject: [PATCH 098/250] MongoDB wants dates stored in UTC, but the functions used in this documentation to generate datetime objects would use server's local timezone - fix it! (#1662) --- docs/guide/defining-documents.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index d41ae7e6..33b5292f 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -22,7 +22,7 @@ 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. @@ -224,7 +224,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() @@ -618,7 +618,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} From a34fd9ac89c3ebd294f57d4b471fb6f5b31e1e91 Mon Sep 17 00:00:00 2001 From: Thomas Erker <35792856+th-erker@users.noreply.github.com> Date: Thu, 8 Mar 2018 11:25:36 +0000 Subject: [PATCH 099/250] Add testcase for #1751 --- tests/document/class_methods.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tests/document/class_methods.py b/tests/document/class_methods.py index dd3addb7..8701b4b2 100644 --- a/tests/document/class_methods.py +++ b/tests/document/class_methods.py @@ -187,6 +187,19 @@ class ClassMethodsTest(unittest.TestCase): 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() + meta = { 'indexes': ['$a']} + + 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- or sub-class that we call it from From a0947d0c544a58516650a48b73b84d171e693ffc Mon Sep 17 00:00:00 2001 From: John Dupuy Date: Sat, 10 Mar 2018 23:24:04 -0600 Subject: [PATCH 100/250] Edit EmbeddedDocumentListField update() doc --- mongoengine/base/datastructures.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index 43f32810..fddd945a 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -351,7 +351,8 @@ class EmbeddedDocumentList(BaseList): def update(self, **update): """ - Updates the embedded documents with the given update values. + 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 From dabe8c1bb7e189d0dc8bdceb54eb1ca982a1f6b5 Mon Sep 17 00:00:00 2001 From: Stefan Wojcik Date: Wed, 14 Mar 2018 14:26:06 -0400 Subject: [PATCH 101/250] highlight places where ValidationError is raised outside of validate() method --- mongoengine/fields.py | 27 +++++++++++++++++++++------ 1 file changed, 21 insertions(+), 6 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 7932f73a..f169f0f1 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -614,6 +614,7 @@ class EmbeddedDocumentField(BaseField): """ def __init__(self, document_type, **kwargs): + # XXX ValidationError raised outside of the "validate" method. if not ( isinstance(document_type, six.string_types) or issubclass(document_type, EmbeddedDocument) @@ -919,8 +920,11 @@ class DictField(ComplexBaseField): self.field = field self._auto_dereference = False self.basecls = basecls or BaseField + + # XXX ValidationError raised outside of the "validate" method. if not issubclass(self.basecls, BaseField): self.error('DictField only accepts dict values') + kwargs.setdefault('default', lambda: {}) super(DictField, self).__init__(*args, **kwargs) @@ -969,6 +973,7 @@ class MapField(DictField): """ def __init__(self, field=None, *args, **kwargs): + # XXX ValidationError raised outside of the "validate" method. if not isinstance(field, BaseField): self.error('Argument to MapField constructor must be a valid ' 'field') @@ -1028,6 +1033,7 @@ class ReferenceField(BaseField): A reference to an abstract document type is always stored as a :class:`~pymongo.dbref.DBRef`, regardless of the value of `dbref`. """ + # XXX ValidationError raised outside of the "validate" method. if ( not isinstance(document_type, six.string_types) and not issubclass(document_type, Document) @@ -1082,6 +1088,8 @@ class ReferenceField(BaseField): if isinstance(document, Document): # We need the id from the saved object to create the DBRef id_ = document.pk + + # XXX ValidationError raised outside of the "validate" method. if id_ is None: self.error('You can only reference documents once they have' ' been saved to the database') @@ -1121,7 +1129,6 @@ class ReferenceField(BaseField): return self.to_mongo(value) def validate(self, value): - if not isinstance(value, (self.document_type, LazyReference, DBRef, ObjectId)): self.error('A ReferenceField only accepts DBRef, LazyReference, ObjectId or documents') @@ -1129,11 +1136,14 @@ class ReferenceField(BaseField): self.error('You can only reference documents once they have been ' 'saved to the database') - if self.document_type._meta.get('abstract') and \ - not isinstance(value, self.document_type): + if ( + self.document_type._meta.get('abstract') and + not isinstance(value, self.document_type) + ): self.error( '%s is not an instance of abstract reference type %s' % ( - self.document_type._class_name) + self.document_type._class_name + ) ) def lookup_member(self, member_name): @@ -1156,6 +1166,7 @@ class CachedReferenceField(BaseField): if fields is None: fields = [] + # XXX ValidationError raised outside of the "validate" method. if ( not isinstance(document_type, six.string_types) and not issubclass(document_type, Document) @@ -1230,6 +1241,7 @@ class CachedReferenceField(BaseField): id_field_name = self.document_type._meta['id_field'] id_field = self.document_type._fields[id_field_name] + # XXX ValidationError raised outside of the "validate" method. if isinstance(document, Document): # We need the id from the saved object to create the DBRef id_ = document.pk @@ -1238,7 +1250,6 @@ class CachedReferenceField(BaseField): ' been saved to the database') else: self.error('Only accept a document object') - # TODO: should raise here or will fail next statement value = SON(( ('_id', id_field.to_mongo(id_)), @@ -1256,6 +1267,7 @@ class CachedReferenceField(BaseField): if value is None: return None + # XXX ValidationError raised outside of the "validate" method. if isinstance(value, Document): if value.pk is None: self.error('You can only reference documents once they have' @@ -1269,7 +1281,6 @@ class CachedReferenceField(BaseField): raise NotImplementedError def validate(self, value): - if not isinstance(value, self.document_type): self.error('A CachedReferenceField only accepts documents') @@ -1330,6 +1341,8 @@ class GenericReferenceField(BaseField): elif isinstance(choice, type) and issubclass(choice, Document): self.choices.append(choice._class_name) else: + # XXX ValidationError raised outside of the "validate" + # method. self.error('Invalid choices provided: must be a list of' 'Document subclasses and/or six.string_typess') @@ -1393,6 +1406,7 @@ class GenericReferenceField(BaseField): # We need the id from the saved object to create the DBRef id_ = document.id if id_ is None: + # XXX ValidationError raised outside of the "validate" method. self.error('You can only reference documents once they have' ' been saved to the database') else: @@ -2209,6 +2223,7 @@ class LazyReferenceField(BaseField): automatically call `fetch()` and try to retrive the field on the fetched document. Note this only work getting field (not setting or deleting). """ + # XXX ValidationError raised outside of the "validate" method. if ( not isinstance(document_type, six.string_types) and not issubclass(document_type, Document) From e46779f87b8c6cc154d90939f10d35ffd06469ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Malthe=20J=C3=B8rgensen?= Date: Tue, 27 Mar 2018 14:14:08 +0200 Subject: [PATCH 102/250] Docs, queryset.update: `full_result`-arg not clearly described The documentation for the `full_result`-argument to `queryset.update()` can be read as returning the update documents/objects, whereas it's really returning just the full "PyMongo result dictionary". This commit adds some wording and an example dictionary, to make it clear what the behavior is. --- mongoengine/queryset/base.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 6f9c372c..bf8a5b55 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -486,8 +486,9 @@ class BaseQuerySet(object): ``save(..., write_concern={w: 2, fsync: True}, ...)`` will wait until at least two servers have recorded the write and will force an fsync on the primary server. - :param full_result: Return the full result rather than just the number - updated. + :param full_result: Return the full result dictionary rather than just the number + updated, e.g. return + `{u'n': 2, u'nModified': 2, u'ok': 1.0, 'updatedExisting': True}`. :param update: Django-style update keyword arguments .. versionadded:: 0.2 From 727778b7305cd01c81e3b198fd20079fcb66b0f1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Malthe=20J=C3=B8rgensen?= Date: Fri, 30 Mar 2018 20:41:39 +0200 Subject: [PATCH 103/250] Docs, queryset.update(): Fix backtick mistake Code should be marked with double backticks --- mongoengine/queryset/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index bf8a5b55..e5611226 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -488,7 +488,7 @@ class BaseQuerySet(object): will force an fsync on the primary server. :param full_result: Return the full result dictionary rather than just the number updated, e.g. return - `{u'n': 2, u'nModified': 2, u'ok': 1.0, 'updatedExisting': True}`. + ``{'n': 2, 'nModified': 2, 'ok': 1.0, 'updatedExisting': True}``. :param update: Django-style update keyword arguments .. versionadded:: 0.2 From c6f0d5e4785571980cd8a53c71c27172cb63c7d0 Mon Sep 17 00:00:00 2001 From: Kushal Mitruka Date: Sun, 1 Apr 2018 20:11:22 +0530 Subject: [PATCH 104/250] fixed pull queries for embeddeddocumentlistfields Updated mongoengine.queryset.transform.update method to handle EmbeddedDocuementListField during pull operations in DB using mongoegning ORM fixed : .udpate(pull__emb_doc__emb_doc_list=doc) --- mongoengine/queryset/transform.py | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index 05721850..f96f993c 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -314,11 +314,17 @@ def update(_doc_cls=None, **update): 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 + if ListField in field_classes: + _check_field = ListField + else: + _check_field = EmbeddedDocumentListField + last_listField = len( - cleaned_fields) - field_classes.index(ListField) + cleaned_fields) - field_classes.index(_check_field) key = '.'.join(parts[:last_listField]) parts = parts[last_listField:] parts.insert(0, key) From 806a80cef16ea08b5a33b4ae663b573e7f9a20c4 Mon Sep 17 00:00:00 2001 From: Victor Date: Thu, 14 Sep 2017 20:31:50 +0300 Subject: [PATCH 105/250] Fixes #1641 There's no need to explicitly raise StopIteration as that's what a bare return statement does for a generator function - so yes they're the same. As of late 2014 return is correct and raise StopIteration for ending a generator is on a depreciation schedule. See PEP 479 for full details. https://stackoverflow.com/q/14183803/248296 https://www.python.org/dev/peps/pep-0479/ --- mongoengine/queryset/queryset.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/queryset/queryset.py b/mongoengine/queryset/queryset.py index cf913b01..60de19a2 100644 --- a/mongoengine/queryset/queryset.py +++ b/mongoengine/queryset/queryset.py @@ -92,7 +92,7 @@ class QuerySet(BaseQuerySet): # Raise StopIteration 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: From 49bff5d544c30ba0a8433b07cda8f7d4e50c9d73 Mon Sep 17 00:00:00 2001 From: Benjamin Chrobot Date: Thu, 12 Apr 2018 10:47:52 -0400 Subject: [PATCH 106/250] Add documentation for LazyReference and GenericLazyReference fields. --- docs/apireference.rst | 2 ++ docs/guide/defining-documents.rst | 2 ++ mongoengine/fields.py | 17 +++++++++++------ 3 files changed, 15 insertions(+), 6 deletions(-) diff --git a/docs/apireference.rst b/docs/apireference.rst index 625d4a8b..05ba3f73 100644 --- a/docs/apireference.rst +++ b/docs/apireference.rst @@ -87,7 +87,9 @@ Fields .. 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 diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index 33b5292f..3ced284e 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -80,6 +80,7 @@ are as follows: * :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` @@ -87,6 +88,7 @@ are as follows: * :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` diff --git a/mongoengine/fields.py b/mongoengine/fields.py index f169f0f1..a661874a 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -2204,8 +2204,11 @@ class MultiPolygonField(GeoJsonBaseField): class LazyReferenceField(BaseField): """A really lazy reference to a document. - Unlike the :class:`~mongoengine.fields.ReferenceField` it must be manually - dereferenced using it ``fetch()`` method. + Unlike the :class:`~mongoengine.fields.ReferenceField` it will + **not** be automatically (lazily) dereferenced on access. + Instead, access will return a :class:`~mongoengine.base.LazyReference` class + instance, allowing access to `pk` or manual dereference by using + ``fetch()`` method. .. versionadded:: 0.15 """ @@ -2331,10 +2334,12 @@ class LazyReferenceField(BaseField): class GenericLazyReferenceField(GenericReferenceField): - """A reference to *any* :class:`~mongoengine.document.Document` subclass - that will be automatically dereferenced on access (lazily). - Unlike the :class:`~mongoengine.fields.GenericReferenceField` it must be - manually dereferenced using it ``fetch()`` method. + """A reference to *any* :class:`~mongoengine.document.Document` subclass. + Unlike the :class:`~mongoengine.fields.GenericReferenceField` it will + **not** be automatically (lazily) dereferenced on access. + Instead, access will return a :class:`~mongoengine.base.LazyReference` class + instance, allowing access to `pk` or manual dereference by using + ``fetch()`` method. .. note :: * Any documents used as a generic reference must be registered in the From faca8512c53102c201cc9b13519ca2ef3c5eb0c5 Mon Sep 17 00:00:00 2001 From: Emmanuel Nosa Evbuomwan Date: Sun, 29 Apr 2018 17:32:03 +0100 Subject: [PATCH 107/250] Updated text-indexes.rst The search statement under the `Ordering by text score` section uses `search` on the QuerySet object instead of `search_text` and thus raised an `AttributeError` AttributeError: 'QuerySet' object has no attribute 'search' --- docs/guide/text-indexes.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/guide/text-indexes.rst b/docs/guide/text-indexes.rst index 725ad369..92a4471a 100644 --- a/docs/guide/text-indexes.rst +++ b/docs/guide/text-indexes.rst @@ -48,4 +48,4 @@ Ordering by text score :: - objects = News.objects.search('mongo').order_by('$text_score') + objects = News.objects.search_text('mongo').order_by('$text_score') From 65e4fea4efbb2f888bcf15850777457aafbd5720 Mon Sep 17 00:00:00 2001 From: Kushal Mitruka Date: Tue, 1 May 2018 20:32:38 +0530 Subject: [PATCH 108/250] added test cases for update pull queries --- tests/queryset/transform.py | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/tests/queryset/transform.py b/tests/queryset/transform.py index a043a647..a2636122 100644 --- a/tests/queryset/transform.py +++ b/tests/queryset/transform.py @@ -247,7 +247,31 @@ class TransformTest(unittest.TestCase): events = Event.objects(location__within=box) with self.assertRaises(InvalidQueryError): events.count() + + def test_update_pull_for_list_fields(self): + """ + Test added to check pull operation in update for + EmbeddedDocumentListField which is inside a EmbeddedDocumentField + """ + class Word(EmbeddedDocument): + word = StringField() + index = IntField() + + class SubDoc(EmbeddedDocument): + heading = ListField(StringField()) + text = EmbeddedDocumentListField(Word) + + class MainDoc(Document): + title = StringField() + content = EmbeddedDocumentField(SubDoc) + + word = Word(word='abc', index=1) + update = transform.update(MainDoc, pull__content__text=word) + self.assertEqual(update, {'$pull': {'content.text': SON([('word', u'abc'), ('index', 1)])}}) - + update = transform.update(MainDoc, pull__content__heading='xyz') + self.assertEqual(update, {'$pull': {'content.heading': 'xyz'}}) + + if __name__ == '__main__': unittest.main() From b1f62a27353a1c2bd8d69b4697dab16caa8056cf Mon Sep 17 00:00:00 2001 From: Kushal Mitruka Date: Tue, 1 May 2018 21:08:43 +0530 Subject: [PATCH 109/250] added import in tests/queryset/transform.py for SON object --- tests/queryset/transform.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/queryset/transform.py b/tests/queryset/transform.py index a2636122..a1f060d5 100644 --- a/tests/queryset/transform.py +++ b/tests/queryset/transform.py @@ -1,5 +1,7 @@ import unittest +from bson.son import SON + from mongoengine import * from mongoengine.queryset import Q, transform From 5a6d4387ea7cbc6eea6176d7c3d67cdcc64c2b31 Mon Sep 17 00:00:00 2001 From: Andy Yankovsky Date: Mon, 7 May 2018 23:17:12 +0300 Subject: [PATCH 110/250] Restore comment from cached value after cursor copy --- mongoengine/queryset/base.py | 3 +++ tests/queryset/queryset.py | 15 ++++++++++----- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index e5611226..b1d3342b 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -1579,6 +1579,9 @@ class BaseQuerySet(object): if self._batch_size is not None: self._cursor_obj.batch_size(self._batch_size) + if self._comment is not None: + self._cursor_obj.comment(self._comment) + return self._cursor_obj def __deepcopy__(self, memo): diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 43800fff..c9b87eeb 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -2383,14 +2383,19 @@ class QuerySetTest(unittest.TestCase): age = IntField() with db_ops_tracker() as q: - adult = (User.objects.filter(age__gte=18) + adult1 = (User.objects.filter(age__gte=18) .comment('looking for an adult') .first()) + + adult2 = (User.objects.comment('looking for an adult') + .filter(age__gte=18) + .first()) + ops = q.get_ops() - self.assertEqual(len(ops), 1) - op = ops[0] - self.assertEqual(op['query']['$query'], {'age': {'$gte': 18}}) - self.assertEqual(op['query']['$comment'], 'looking for an adult') + self.assertEqual(len(ops), 2) + for op in ops: + self.assertEqual(op['query']['$query'], {'age': {'$gte': 18}}) + self.assertEqual(op['query']['$comment'], 'looking for an adult') def test_map_reduce(self): """Ensure map/reduce is both mapping and reducing. From 85d621846d521e2662d420983393b49737a22ae3 Mon Sep 17 00:00:00 2001 From: Benjamin Jiang Date: Wed, 16 May 2018 11:37:32 +0800 Subject: [PATCH 111/250] Fix typo --- mongoengine/document.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index c948dac2..a8061749 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -579,7 +579,7 @@ class Document(BaseDocument): """Delete the :class:`~mongoengine.Document` from the database. This will only take effect if the document has been previously saved. - :parm signal_kwargs: (optional) kwargs dictionary to be passed to + :param signal_kwargs: (optional) kwargs dictionary to be passed to the signal calls. :param write_concern: Extra keyword arguments are passed down which will be used as options for the resultant From 08b64338439a33a1b869ef0c77f09fd9b50bae2c Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 11:03:13 +0800 Subject: [PATCH 112/250] fix compare_indexes for text indexes #1751 --- mongoengine/document.py | 12 ++++++++++-- tests/document/class_methods.py | 8 +++++++- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index c948dac2..18c52d9d 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -967,8 +967,16 @@ class Document(BaseDocument): """ required = cls.list_indexes() - existing = [info['key'] - for info in cls._get_collection().index_information().values()] + + existing = [] + for info in cls._get_collection().index_information().values(): + if '_fts' in info['key'][0]: + index_type = info['key'][0][1] + text_index_fields = info.get('weights').keys() + existing.append( + [(key, index_type) for key in text_index_fields]) + else: + existing.append(info['key']) missing = [index for index in required if index not in existing] extra = [index for index in existing if index not in required] diff --git a/tests/document/class_methods.py b/tests/document/class_methods.py index 8701b4b2..3f052d45 100644 --- a/tests/document/class_methods.py +++ b/tests/document/class_methods.py @@ -192,7 +192,13 @@ class ClassMethodsTest(unittest.TestCase): class Doc(Document): a = StringField() - meta = { 'indexes': ['$a']} + b = StringField() + meta = {'indexes': [ + {'fields': ['$a', "$b"], + 'default_language': 'english', + 'weights': {'a': 10, 'b': 2} + } + ]} Doc.drop_collection() Doc.ensure_indexes() From e50d66b3032df29331f72f6ce238b3813ae35b50 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 11:26:30 +0800 Subject: [PATCH 113/250] skip mongodb 2.4 --- tests/document/class_methods.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/document/class_methods.py b/tests/document/class_methods.py index 3f052d45..2fab1f72 100644 --- a/tests/document/class_methods.py +++ b/tests/document/class_methods.py @@ -5,6 +5,7 @@ from mongoengine import * from mongoengine.queryset import NULLIFY, PULL from mongoengine.connection import get_db +from tests.utils import needs_mongodb_v26 __all__ = ("ClassMethodsTest", ) @@ -187,6 +188,7 @@ class ClassMethodsTest(unittest.TestCase): self.assertEqual(BlogPostWithTags.compare_indexes(), { 'missing': [], 'extra': [] }) self.assertEqual(BlogPostWithCustomField.compare_indexes(), { 'missing': [], 'extra': [] }) + @needs_mongodb_v26 def test_compare_indexes_for_text_indexes(self): """ Ensure that compare_indexes behaves correctly for text indexes """ From 257a43298b93785d9280d3942745aab7149bf627 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 12:31:27 +0800 Subject: [PATCH 114/250] use MongoClient.is_mongos in ensure indexes #1759 --- mongoengine/document.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index 2de0b1a3..865bb063 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -854,7 +854,7 @@ class Document(BaseDocument): collection = cls._get_collection() # 746: when connection is via mongos, the read preference is not necessarily an indication that # this code runs on a secondary - if not collection.is_mongos and collection.read_preference > 1: + if not collection.database.client.is_mongos and collection.read_preference > 1: return # determine if an index which we are creating includes From fd02d77c59aa6c427581c9903d158c1d77cbfa26 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 12:43:24 +0800 Subject: [PATCH 115/250] drop pymongo 2.x support in update --- .travis.yml | 6 ------ 1 file changed, 6 deletions(-) diff --git a/.travis.yml b/.travis.yml index a70c711e..29a72d1c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -19,8 +19,6 @@ python: - pypy env: -- MONGODB=2.6 PYMONGO=2.7 -- MONGODB=2.6 PYMONGO=2.8 - MONGODB=2.6 PYMONGO=3.x matrix: @@ -28,14 +26,10 @@ matrix: fast_finish: true include: - - python: 2.7 - env: MONGODB=2.4 PYMONGO=2.7 - python: 2.7 env: MONGODB=2.4 PYMONGO=3.5 - python: 2.7 env: MONGODB=3.0 PYMONGO=3.x - - python: 3.5 - env: MONGODB=2.4 PYMONGO=2.7 - python: 3.5 env: MONGODB=2.4 PYMONGO=3.5 - python: 3.5 From f605eb14e8b9e4c02d8279a54035f1c00791cf22 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 12:54:24 +0800 Subject: [PATCH 116/250] fix style --- mongoengine/context_managers.py | 4 ++-- mongoengine/document.py | 2 +- tox.ini | 4 +--- 3 files changed, 4 insertions(+), 6 deletions(-) diff --git a/mongoengine/context_managers.py b/mongoengine/context_managers.py index c6d0d40f..150f9657 100644 --- a/mongoengine/context_managers.py +++ b/mongoengine/context_managers.py @@ -1,7 +1,7 @@ from mongoengine.common import _import_class -from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db -from pymongo.write_concern import WriteConcern from contextlib import contextmanager +from pymongo.write_concern import WriteConcern +from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db __all__ = ('switch_db', 'switch_collection', 'no_dereference', diff --git a/mongoengine/document.py b/mongoengine/document.py index 865bb063..2de0b1a3 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -854,7 +854,7 @@ class Document(BaseDocument): collection = cls._get_collection() # 746: when connection is via mongos, the read preference is not necessarily an indication that # this code runs on a secondary - if not collection.database.client.is_mongos and collection.read_preference > 1: + if not collection.is_mongos and collection.read_preference > 1: return # determine if an index which we are creating includes diff --git a/tox.ini b/tox.ini index 9bb0c5ec..2f2b1757 100644 --- a/tox.ini +++ b/tox.ini @@ -1,13 +1,11 @@ [tox] -envlist = {py27,py35,pypy,pypy3}-{mg27,mg28,mg35,mg3x} +envlist = {py27,py35,pypy,pypy3}-{mg35,mg3x} [testenv] commands = python setup.py nosetests {posargs} deps = nose - mg27: PyMongo<2.8 - mg28: PyMongo>=2.8,<2.9 mg35: PyMongo==3.5 mg3x: PyMongo>=3.0 setenv = From c83c6350676af155a8c204a0593e74ee8b674e6b Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 13:04:51 +0800 Subject: [PATCH 117/250] fix import order --- mongoengine/context_managers.py | 2 +- mongoengine/queryset/base.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/mongoengine/context_managers.py b/mongoengine/context_managers.py index 150f9657..ec2e9e8b 100644 --- a/mongoengine/context_managers.py +++ b/mongoengine/context_managers.py @@ -1,6 +1,6 @@ -from mongoengine.common import _import_class from contextlib import contextmanager from pymongo.write_concern import WriteConcern +from mongoengine.common import _import_class from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 2a1bf3ad..f78ee882 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -18,7 +18,7 @@ from mongoengine import signals from mongoengine.base import get_document from mongoengine.common import _import_class from mongoengine.connection import get_db -from mongoengine.context_managers import switch_db, set_write_concern +from mongoengine.context_managers import set_write_concern, switch_db from mongoengine.errors import (InvalidQueryError, LookUpError, NotUniqueError, OperationError) from mongoengine.python_support import IS_PYMONGO_3 From 843fc03bf490b6c6346a22f8599046f718631beb Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 13:16:25 +0800 Subject: [PATCH 118/250] add changelog for update_one,update_many --- docs/changelog.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index 29471463..cb31da21 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -10,6 +10,7 @@ dev - 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 new update_one, update_many on document/queryset update #1491 Changes in 0.15.0 ================= From 3e0d84383e4a0f9c52d6840ff1d4a882e7eeb6cb Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 13:41:20 +0800 Subject: [PATCH 119/250] use insert_one, insert_many and remove deprecated one #1491 --- docs/changelog.rst | 1 + mongoengine/queryset/base.py | 8 +++++++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 29471463..4dec42ce 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -10,6 +10,7 @@ dev - 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 Changes in 0.15.0 ================= diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index b1d3342b..95b25d06 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -350,8 +350,14 @@ class BaseQuerySet(object): documents=docs, **signal_kwargs) raw = [doc.to_mongo() for doc in docs] + insert_func = self._collection.insert_many + if return_one: + raw = raw[0] + insert_func = self._collection.insert_one + try: - ids = self._collection.insert(raw, **write_concern) + inserted_result = insert_func(raw, **write_concern) + ids = inserted_result.inserted_id if return_one else inserted_result.inserted_ids except pymongo.errors.DuplicateKeyError as err: message = 'Could not save document (%s)' raise NotUniqueError(message % six.text_type(err)) From f9a887c8c6665a77dda33ca785acf2ece8158337 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 14:33:12 +0800 Subject: [PATCH 120/250] fix inserted_ids --- mongoengine/queryset/base.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 95b25d06..eec7df18 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -357,7 +357,8 @@ class BaseQuerySet(object): try: inserted_result = insert_func(raw, **write_concern) - ids = inserted_result.inserted_id if return_one else inserted_result.inserted_ids + ids = return_one and inserted_result.inserted_id or\ + inserted_result.inserted_ids except pymongo.errors.DuplicateKeyError as err: message = 'Could not save document (%s)' raise NotUniqueError(message % six.text_type(err)) @@ -374,7 +375,6 @@ class BaseQuerySet(object): signals.post_bulk_insert.send( self._document, documents=docs, loaded=False, **signal_kwargs) return return_one and ids[0] or ids - documents = self.in_bulk(ids) results = [] for obj_id in ids: From 1d3f20b666bfe0ef8dcdea06a2341e460d13c486 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 14:41:25 +0800 Subject: [PATCH 121/250] fix style and ids need to be an array --- mongoengine/queryset/base.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 2f2d38dd..0634dceb 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -357,8 +357,7 @@ class BaseQuerySet(object): try: inserted_result = insert_func(raw, **write_concern) - ids = return_one and inserted_result.inserted_id or\ - inserted_result.inserted_ids + ids = return_one and [inserted_result.inserted_id] or inserted_result.inserted_ids except pymongo.errors.DuplicateKeyError as err: message = 'Could not save document (%s)' raise NotUniqueError(message % six.text_type(err)) From 1aebc9514564a9ba1c58cb52fa4552ace6d2066a Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 13:41:20 +0800 Subject: [PATCH 122/250] use insert_one, insert_many and remove deprecated one #1491 --- docs/changelog.rst | 1 + mongoengine/queryset/base.py | 8 +++++++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index cb31da21..e3d366b3 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -11,6 +11,7 @@ dev - Update cached fields when fields argument is given #1712 - Add a db parameter to register_connection for compatibility with connect - Use new update_one, update_many on document/queryset update #1491 +- Use insert_one, insert_many in Document.insert #1491 Changes in 0.15.0 ================= diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index f78ee882..ff7afa96 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -350,8 +350,14 @@ class BaseQuerySet(object): documents=docs, **signal_kwargs) raw = [doc.to_mongo() for doc in docs] + insert_func = self._collection.insert_many + if return_one: + raw = raw[0] + insert_func = self._collection.insert_one + try: - ids = self._collection.insert(raw, **write_concern) + inserted_result = insert_func(raw, **write_concern) + ids = inserted_result.inserted_id if return_one else inserted_result.inserted_ids except pymongo.errors.DuplicateKeyError as err: message = 'Could not save document (%s)' raise NotUniqueError(message % six.text_type(err)) From 5c0bd8a81090aa39a74b347adb7afde9edb202b6 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 14:33:12 +0800 Subject: [PATCH 123/250] fix inserted_ids --- mongoengine/queryset/base.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index ff7afa96..2f2d38dd 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -357,7 +357,8 @@ class BaseQuerySet(object): try: inserted_result = insert_func(raw, **write_concern) - ids = inserted_result.inserted_id if return_one else inserted_result.inserted_ids + ids = return_one and inserted_result.inserted_id or\ + inserted_result.inserted_ids except pymongo.errors.DuplicateKeyError as err: message = 'Could not save document (%s)' raise NotUniqueError(message % six.text_type(err)) @@ -374,7 +375,6 @@ class BaseQuerySet(object): signals.post_bulk_insert.send( self._document, documents=docs, loaded=False, **signal_kwargs) return return_one and ids[0] or ids - documents = self.in_bulk(ids) results = [] for obj_id in ids: From 0fc55451c2aaad6a612d28ead0b58898a2236e40 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 14:41:25 +0800 Subject: [PATCH 124/250] fix style and ids need to be an array --- mongoengine/queryset/base.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 2f2d38dd..0634dceb 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -357,8 +357,7 @@ class BaseQuerySet(object): try: inserted_result = insert_func(raw, **write_concern) - ids = return_one and inserted_result.inserted_id or\ - inserted_result.inserted_ids + ids = return_one and [inserted_result.inserted_id] or inserted_result.inserted_ids except pymongo.errors.DuplicateKeyError as err: message = 'Could not save document (%s)' raise NotUniqueError(message % six.text_type(err)) From acba86993dd92b04fff289a151cb8882913bbf20 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 15:43:19 +0800 Subject: [PATCH 125/250] set_write_concern pymongo3 --- mongoengine/queryset/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 0634dceb..0a3f65fb 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -356,7 +356,7 @@ class BaseQuerySet(object): insert_func = self._collection.insert_one try: - inserted_result = insert_func(raw, **write_concern) + inserted_result = insert_func(raw, set_write_concern(write_concern)) ids = return_one and [inserted_result.inserted_id] or inserted_result.inserted_ids except pymongo.errors.DuplicateKeyError as err: message = 'Could not save document (%s)' From fa4ac95ecc245c59040664905c935d3c85b49429 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 17:49:49 +0800 Subject: [PATCH 126/250] catch bulkwriteerror --- mongoengine/queryset/base.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 008e7f15..391cc819 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -371,6 +371,11 @@ class BaseQuerySet(object): message = u'Tried to save duplicate unique keys (%s)' raise NotUniqueError(message % six.text_type(err)) raise OperationError(message % six.text_type(err)) + except pymongo.error.BulkWriteError as err: + # inserting documents that already have an _id field will + # give huge performance debt or raise + message = u'Document must not have _id value before bulk write (%s)' + raise NotUniqueError(message % sx.text_type(err)) if not load_bulk: signals.post_bulk_insert.send( From 78601d90c9fd13b20d1e6cfe2342ddb23a520e33 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 17:54:13 +0800 Subject: [PATCH 127/250] fix typo --- mongoengine/queryset/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 391cc819..4c8309a7 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -375,7 +375,7 @@ class BaseQuerySet(object): # inserting documents that already have an _id field will # give huge performance debt or raise message = u'Document must not have _id value before bulk write (%s)' - raise NotUniqueError(message % sx.text_type(err)) + raise NotUniqueError(message % six.text_type(err)) if not load_bulk: signals.post_bulk_insert.send( From 94cda90a6ead7a64059328c58dafa6154436c951 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 17:56:19 +0800 Subject: [PATCH 128/250] fix syntax --- mongoengine/queryset/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 4c8309a7..bba63da0 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -371,7 +371,7 @@ class BaseQuerySet(object): message = u'Tried to save duplicate unique keys (%s)' raise NotUniqueError(message % six.text_type(err)) raise OperationError(message % six.text_type(err)) - except pymongo.error.BulkWriteError as err: + except pymongo.errors.BulkWriteError as err: # inserting documents that already have an _id field will # give huge performance debt or raise message = u'Document must not have _id value before bulk write (%s)' From 088fd6334bfe8316c2df2466ad93ee568e3013c6 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 18:06:59 +0800 Subject: [PATCH 129/250] bulkwriteerror does not trigger --- mongoengine/queryset/base.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index bba63da0..647eafc6 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -363,6 +363,11 @@ class BaseQuerySet(object): except pymongo.errors.DuplicateKeyError as err: message = 'Could not save document (%s)' raise NotUniqueError(message % six.text_type(err)) + except pymongo.errors.BulkWriteError as err: + # inserting documents that already have an _id field will + # give huge performance debt or raise + message = u'Document must not have _id value before bulk write (%s)' + raise NotUniqueError(message % six.text_type(err)) except pymongo.errors.OperationFailure as err: message = 'Could not save document (%s)' if re.match('^E1100[01] duplicate key', six.text_type(err)): @@ -371,11 +376,6 @@ class BaseQuerySet(object): message = u'Tried to save duplicate unique keys (%s)' raise NotUniqueError(message % six.text_type(err)) raise OperationError(message % six.text_type(err)) - except pymongo.errors.BulkWriteError as err: - # inserting documents that already have an _id field will - # give huge performance debt or raise - message = u'Document must not have _id value before bulk write (%s)' - raise NotUniqueError(message % six.text_type(err)) if not load_bulk: signals.post_bulk_insert.send( From 506168ab83a11dc22c706dd308f77f6233543d57 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 18:25:50 +0800 Subject: [PATCH 130/250] use write_concern class --- tests/queryset/queryset.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 5c3f179f..4c0085d0 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -927,8 +927,7 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(Blog.objects.count(), 2) - Blog.objects.insert([blog2, blog3], - write_concern={"w": 0, 'continue_on_error': True}) + Blog.objects.insert([blog2, blog3], write_concern={"w": 0}) self.assertEqual(Blog.objects.count(), 3) def test_get_changed_fields_query_count(self): From fc5d9ae10033e7e083931d9a64b7137feadc6eb6 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Sun, 20 May 2018 18:39:22 +0800 Subject: [PATCH 131/250] pymongo3 does not support continue_on_error --- tests/queryset/queryset.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 4c0085d0..3fa86a58 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -927,9 +927,6 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(Blog.objects.count(), 2) - Blog.objects.insert([blog2, blog3], write_concern={"w": 0}) - self.assertEqual(Blog.objects.count(), 3) - def test_get_changed_fields_query_count(self): """Make sure we don't perform unnecessary db operations when none of document's fields were updated. From 2adb640821123439c9b611375d01aba1d86b3b26 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 21 May 2018 09:19:03 +0800 Subject: [PATCH 132/250] modify bulk_insert test for pymongo3 --- tests/queryset/queryset.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 3fa86a58..50825e5c 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -846,10 +846,10 @@ class QuerySetTest(unittest.TestCase): Blog.objects.insert(blogs, load_bulk=False) if mongodb_version < (2, 6): - self.assertEqual(q, 1) + self.assertEqual(q, 99) else: # profiling logs each doc now in the bulk op - self.assertEqual(q, 99) + self.assertEqual(q, 1) Blog.drop_collection() Blog.ensure_indexes() @@ -859,7 +859,7 @@ class QuerySetTest(unittest.TestCase): Blog.objects.insert(blogs) if mongodb_version < (2, 6): - self.assertEqual(q, 2) # 1 for insert, and 1 for in bulk fetch + self.assertEqual(q, 101) # 100 for insert, and 1 for in bulk fetch else: # 99 for insert, and 1 for in bulk fetch self.assertEqual(q, 100) From e4451ccaf8616e27c3479e97bcb75daf76396488 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 21 May 2018 09:22:33 +0800 Subject: [PATCH 133/250] insert_many uses only one insert --- tests/queryset/queryset.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 50825e5c..8e91feae 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -845,11 +845,8 @@ class QuerySetTest(unittest.TestCase): blogs.append(Blog(title="post %s" % i, posts=[post1, post2])) Blog.objects.insert(blogs, load_bulk=False) - if mongodb_version < (2, 6): - self.assertEqual(q, 99) - else: - # profiling logs each doc now in the bulk op - self.assertEqual(q, 1) + # profiling logs each doc now in the bulk op + self.assertEqual(q, 99) Blog.drop_collection() Blog.ensure_indexes() @@ -861,8 +858,8 @@ class QuerySetTest(unittest.TestCase): if mongodb_version < (2, 6): self.assertEqual(q, 101) # 100 for insert, and 1 for in bulk fetch else: - # 99 for insert, and 1 for in bulk fetch - self.assertEqual(q, 100) + # 1 for insert, and 1 for in bulk fetch + self.assertEqual(q, 2) Blog.drop_collection() From f7a3acfaf45673ee379fc09de86f4fa484e907bc Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 21 May 2018 09:34:44 +0800 Subject: [PATCH 134/250] query profiler test fix --- tests/queryset/queryset.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 8e91feae..9c7ac0e4 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -855,11 +855,7 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(q, 0) Blog.objects.insert(blogs) - if mongodb_version < (2, 6): - self.assertEqual(q, 101) # 100 for insert, and 1 for in bulk fetch - else: - # 1 for insert, and 1 for in bulk fetch - self.assertEqual(q, 2) + self.assertEqual(q, 100) # 99 for insert 1 for fetch Blog.drop_collection() From 3f9ff7254f206e0926c6ab31cc3a1a1efe39ad2d Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 21 May 2018 09:46:23 +0800 Subject: [PATCH 135/250] fix queryset tests --- tests/queryset/queryset.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 9c7ac0e4..dea5b110 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -970,7 +970,10 @@ class QuerySetTest(unittest.TestCase): org = Organization.objects.get(id=o1.id) with query_counter() as q: org.save(cascade=False) - self.assertEqual(q, 0) + if mongodb_version >= (3, 0): + self.assertEqual(q, 1) + else: + self.assertEqual(q, 0) # Saving a doc after you append a reference to it should result in # two db operations (a query for the reference and an update). From 6fb5c312c3a8d753c4a49a6e65bbc9db3d84f5bb Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 21 May 2018 09:54:19 +0800 Subject: [PATCH 136/250] fix test error --- tests/queryset/queryset.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index dea5b110..2b12d261 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -967,6 +967,11 @@ class QuerySetTest(unittest.TestCase): org.save() self.assertEqual(q, 0) + # get MongoDB version info + connection = get_connection() + info = connection.test.command('buildInfo') + mongodb_version = tuple([int(i) for i in info['version'].split('.')]) + org = Organization.objects.get(id=o1.id) with query_counter() as q: org.save(cascade=False) From 9bd328e147122133a64f00a71c5829c8803217ed Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 21 May 2018 10:04:59 +0800 Subject: [PATCH 137/250] query_counter fix --- tests/queryset/queryset.py | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 2b12d261..9c7ac0e4 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -967,18 +967,10 @@ class QuerySetTest(unittest.TestCase): org.save() self.assertEqual(q, 0) - # get MongoDB version info - connection = get_connection() - info = connection.test.command('buildInfo') - mongodb_version = tuple([int(i) for i in info['version'].split('.')]) - org = Organization.objects.get(id=o1.id) with query_counter() as q: org.save(cascade=False) - if mongodb_version >= (3, 0): - self.assertEqual(q, 1) - else: - self.assertEqual(q, 0) + self.assertEqual(q, 0) # Saving a doc after you append a reference to it should result in # two db operations (a query for the reference and an update). From 290b821a3ae2e130192a90bb62ad5ae8d5461005 Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Sat, 2 Sep 2017 02:05:27 +0900 Subject: [PATCH 138/250] add fix for reload(fields) affect changed fields #1371 --- mongoengine/document.py | 5 +++-- tests/document/instance.py | 20 +++++++++++++++++++- 2 files changed, 22 insertions(+), 3 deletions(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index 2de0b1a3..182733c7 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -705,7 +705,6 @@ class Document(BaseDocument): obj = obj[0] else: raise self.DoesNotExist('Document does not exist') - for field in obj._data: if not fields or field in fields: try: @@ -721,7 +720,9 @@ class Document(BaseDocument): # i.e. obj.update(unset__field=1) followed by obj.reload() delattr(self, field) - self._changed_fields = obj._changed_fields + self._changed_fields = list( + set(self._changed_fields) - set(fields) + ) if fields else obj._changed_fields self._created = False return self diff --git a/tests/document/instance.py b/tests/document/instance.py index 38c7fcaf..b255e8a6 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -476,6 +476,24 @@ class InstanceTest(unittest.TestCase): doc.save() doc.reload() + def test_reload_with_changed_fields(self): + """Ensures reloading will not affect changed fields""" + class User(Document): + name = StringField() + number = IntField() + User.drop_collection() + + user = User(name="Bob", number=1).save() + user.name = "John" + user.number = 2 + + self.assertEqual(user._get_changed_fields(), ['name', 'number']) + user.reload('number') + self.assertEqual(user._get_changed_fields(), ['name']) + user.save() + user.reload() + self.assertEqual(user.name, "John") + def test_reload_referencing(self): """Ensures reloading updates weakrefs correctly.""" class Embedded(EmbeddedDocument): @@ -521,7 +539,7 @@ class InstanceTest(unittest.TestCase): doc.save() doc.dict_field['extra'] = 1 doc = doc.reload(10, 'list_field') - self.assertEqual(doc._get_changed_fields(), []) + self.assertEqual(doc._get_changed_fields(), ['dict_field.extra']) self.assertEqual(len(doc.list_field), 5) self.assertEqual(len(doc.dict_field), 3) self.assertEqual(len(doc.embedded_field.list_field), 4) From d424583cbf26de5c9b4f3ac47ec9b4cb52549fd5 Mon Sep 17 00:00:00 2001 From: Erdenezul Date: Sat, 2 Sep 2017 12:00:57 +0900 Subject: [PATCH 139/250] fix flake8 error #1371 --- mongoengine/document.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index 182733c7..109f8f82 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -722,7 +722,7 @@ class Document(BaseDocument): self._changed_fields = list( set(self._changed_fields) - set(fields) - ) if fields else obj._changed_fields + ) if fields else obj._changed_fields self._created = False return self From 784386fddcc3d171791fb710e332d72d29c009a5 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 21 May 2018 16:07:08 +0800 Subject: [PATCH 140/250] add changelog #1371 --- docs/changelog.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index d8765d17..08e5a490 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -13,6 +13,7 @@ dev - 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 Changes in 0.15.0 ================= From 446c1010185bd7ca836e686d6513f8d7c07828c5 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Wed, 23 May 2018 15:53:30 +0800 Subject: [PATCH 141/250] dont call ensure_indexes on slave #1338 --- mongoengine/document.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index 109f8f82..7d03bd60 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -195,7 +195,9 @@ class Document(BaseDocument): # Ensure indexes on the collection unless auto_create_index was # set to False. - if cls._meta.get('auto_create_index', True): + # Also there is no need to ensure indexes on slave. + if cls._meta.get('auto_create_index', True) and\ + db.client.is_primary: cls.ensure_indexes() return cls._collection From e8e47c39d78b25a6af9e6c77da1c2ce6fb5b88f7 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Wed, 23 May 2018 15:54:44 +0800 Subject: [PATCH 142/250] add changelog #1338 --- docs/changelog.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index 08e5a490..d5ee2b23 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -14,6 +14,7 @@ dev - 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 ================= From 8739ab9c66e2cf84c3c206b95a5468263967b9d9 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Wed, 23 May 2018 15:59:18 +0800 Subject: [PATCH 143/250] fix syntax #1338 --- mongoengine/document.py | 1 + 1 file changed, 1 insertion(+) diff --git a/mongoengine/document.py b/mongoengine/document.py index 7d03bd60..0d471c3a 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -196,6 +196,7 @@ class Document(BaseDocument): # Ensure indexes on the collection unless auto_create_index was # set to False. # Also there is no need to ensure indexes on slave. + db = cls._get_db() if cls._meta.get('auto_create_index', True) and\ db.client.is_primary: cls.ensure_indexes() From 080226dd7289bb3973c46b76eba15174dd8c6977 Mon Sep 17 00:00:00 2001 From: Tal Yalon Date: Fri, 22 Jun 2018 14:16:17 +0300 Subject: [PATCH 144/250] Fix issue #1286 and #844.: when building a query set from filters that reference the same field several times, do not assume each value is a dict --- mongoengine/queryset/transform.py | 2 +- tests/queryset/queryset.py | 8 ++++++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index 5f777f41..f450c8a3 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -147,7 +147,7 @@ def query(_doc_cls=None, **kwargs): if op is None or key not in mongo_query: mongo_query[key] = value elif key in mongo_query: - if isinstance(mongo_query[key], dict): + if isinstance(mongo_query[key], dict) and isinstance(value, dict): mongo_query[key].update(value) # $max/minDistance needs to come last - convert to SON value_dict = mongo_query[key] diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 497a0d23..9b1b3256 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -1202,6 +1202,14 @@ class QuerySetTest(unittest.TestCase): BlogPost.drop_collection() Blog.drop_collection() + def test_filter_chaining_with_regex(self): + person = self.Person(name='Guido van Rossum') + person.save() + + people = self.Person.objects + people = people.filter(name__startswith='Gui').filter(name__not__endswith='tum') + self.assertEqual(people.count(), 1) + def assertSequence(self, qs, expected): qs = list(qs) expected = list(expected) From d0741946c7f982286cb709c23850f95769414ec6 Mon Sep 17 00:00:00 2001 From: Tony Narlock Date: Thu, 28 Jun 2018 10:19:48 -0500 Subject: [PATCH 145/250] Fix a typo (#1813) an -> a --- mongoengine/document.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index 0d471c3a..c8532e5b 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -715,7 +715,7 @@ class Document(BaseDocument): except (KeyError, AttributeError): try: # If field is a special field, e.g. items is stored as _reserved_items, - # an KeyError is thrown. So try to retrieve the field from _data + # a KeyError is thrown. So try to retrieve the field from _data setattr(self, field, self._reload(field, obj._data.get(field))) except KeyError: # If field is removed from the database while the object From b070e7de0765f5d364474c832fb28d91e04a884e Mon Sep 17 00:00:00 2001 From: Emmanuel Leblond Date: Fri, 29 Jun 2018 15:47:28 +0200 Subject: [PATCH 146/250] Fix travis's pypi release trigger --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 29a72d1c..381f7385 100644 --- a/.travis.yml +++ b/.travis.yml @@ -91,11 +91,11 @@ deploy: distributions: "sdist bdist_wheel" # only deploy on tagged commits (aka GitHub releases) and only for the - # parent repo's builds running Python 2.7 along with PyMongo v3.0 (we run + # parent repo's builds running Python 2.7 along with PyMongo v3.x (we run # Travis against many different Python and PyMongo versions and we don't # want the deploy to occur multiple times). on: tags: true repo: MongoEngine/mongoengine - condition: "$PYMONGO = 3.0" + condition: "$PYMONGO = 3.x" python: 2.7 From fdba648afb4141a7dbd768435a3847c265713cbe Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 16 Jul 2018 09:19:50 +0800 Subject: [PATCH 147/250] fix pypi trigger --- mongoengine/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/__init__.py b/mongoengine/__init__.py index a1b7d682..e6dc6b9d 100644 --- a/mongoengine/__init__.py +++ b/mongoengine/__init__.py @@ -23,7 +23,7 @@ __all__ = (list(document.__all__) + list(fields.__all__) + list(signals.__all__) + list(errors.__all__)) -VERSION = (0, 15, 0) +VERSION = (0, 15, 3) def get_version(): From 1241a902e3a0d5b1fac919d77dc191fd47a4d966 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 16 Jul 2018 09:49:16 +0800 Subject: [PATCH 148/250] fix changelog --- docs/changelog.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index d5ee2b23..7eaed75a 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -2,8 +2,8 @@ Changelog ========= -dev -=== +Changes in 0.15.3 +================= - 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 From ae783d4f45bc65daeae9f2fbbf1364ac4161e0e6 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 16 Jul 2018 17:25:29 +0800 Subject: [PATCH 149/250] tweak tox.ini to pass tests --- tox.ini | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index 2f2b1757..815d2acc 100644 --- a/tox.ini +++ b/tox.ini @@ -7,6 +7,6 @@ commands = deps = nose mg35: PyMongo==3.5 - mg3x: PyMongo>=3.0 + mg3x: PyMongo>=3.0,<3.7 setenv = PYTHON_EGG_CACHE = {envdir}/python-eggs From 62eadbc17468b079b2da40ef151b190202e98b1d Mon Sep 17 00:00:00 2001 From: Gram Date: Fri, 20 Jul 2018 17:21:57 +0300 Subject: [PATCH 150/250] +date field --- mongoengine/fields.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index a661874a..d631e882 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -525,6 +525,22 @@ class DateTimeField(BaseField): return super(DateTimeField, self).prepare_query_value(op, self.to_mongo(value)) +class DateField(DateTimeField): + def to_mongo(self, value): + value = super(DateField, self).to_mongo(value) + # drop hours, minutes, seconds + if isinstance(value, datetime.datetime): + value = datetime.datetime(value.year, value.month, value.day) + return value + + def to_python(self, value): + value = super(DateField, self).to_python(value) + # convert datetime to date + if isinstance(value, datetime.datetime): + value = datetime.date(value.year, value.month, value.day) + return value + + class ComplexDateTimeField(StringField): """ ComplexDateTimeField handles microseconds exactly instead of rounding From 19a6e324c45a2bb4307802d7b40e3805084b567d Mon Sep 17 00:00:00 2001 From: Gram Date: Fri, 20 Jul 2018 17:37:23 +0300 Subject: [PATCH 151/250] +tests for date field --- mongoengine/fields.py | 2 +- tests/fields/fields.py | 145 ++++++++++++++++++++++++++++++++++++++++- 2 files changed, 144 insertions(+), 3 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index d631e882..f9622b31 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -43,7 +43,7 @@ except ImportError: __all__ = ( 'StringField', 'URLField', 'EmailField', 'IntField', 'LongField', - 'FloatField', 'DecimalField', 'BooleanField', 'DateTimeField', + 'FloatField', 'DecimalField', 'BooleanField', 'DateTimeField', 'DateField', 'ComplexDateTimeField', 'EmbeddedDocumentField', 'ObjectIdField', 'GenericEmbeddedDocumentField', 'DynamicField', 'ListField', 'SortedListField', 'EmbeddedDocumentListField', 'DictField', diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 0b9710c3..7352d242 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -46,6 +46,17 @@ class FieldTest(MongoDBTestCase): md = MyDoc(dt='') self.assertRaises(ValidationError, md.save) + 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_datetime_from_whitespace_string(self): """ Ensure an exception is raised when trying to @@ -57,6 +68,17 @@ class FieldTest(MongoDBTestCase): 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_nothing_set(self): """Ensure that default field values are used when creating a document. @@ -66,13 +88,14 @@ class FieldTest(MongoDBTestCase): age = IntField(default=30, required=False) userid = StringField(default=lambda: 'test', required=True) created = DateTimeField(default=datetime.datetime.utcnow) + day = DateField(default=datetime.date.today) person = Person(name="Ross") # Confirm saving now would store values data_to_be_saved = sorted(person.to_mongo().keys()) self.assertEqual(data_to_be_saved, - ['age', 'created', 'name', 'userid'] + ['age', 'created', 'day', 'name', 'userid'] ) self.assertTrue(person.validate() is None) @@ -81,16 +104,18 @@ class FieldTest(MongoDBTestCase): self.assertEqual(person.age, person.age) self.assertEqual(person.userid, person.userid) self.assertEqual(person.created, person.created) + self.assertEqual(person.day, person.day) self.assertEqual(person._data['name'], person.name) self.assertEqual(person._data['age'], person.age) self.assertEqual(person._data['userid'], person.userid) self.assertEqual(person._data['created'], person.created) + self.assertEqual(person._data['day'], person.day) # Confirm introspection changes nothing data_to_be_saved = sorted(person.to_mongo().keys()) self.assertEqual( - data_to_be_saved, ['age', 'created', 'name', 'userid']) + data_to_be_saved, ['age', 'created', 'day', 'name', 'userid']) def test_default_values_set_to_None(self): """Ensure that default field values are used even when @@ -662,6 +687,32 @@ class FieldTest(MongoDBTestCase): log.time = 'ABC' self.assertRaises(ValidationError, log.validate) + def test_date_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) + def test_datetime_tz_aware_mark_as_changed(self): from mongoengine import connection @@ -733,6 +784,51 @@ class FieldTest(MongoDBTestCase): self.assertNotEqual(log.date, d1) self.assertEqual(log.date, d2) + 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_datetime_usage(self): """Tests for regular datetime fields""" class LogEntry(Document): @@ -787,6 +883,51 @@ class FieldTest(MongoDBTestCase): ) self.assertEqual(logs.count(), 5) + def test_date_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_complexdatetime_storage(self): """Tests for complex datetime fields - which can handle microseconds without rounding. From 6da27e59760d8498344ddb1628b7f5d3d5ca3d5f Mon Sep 17 00:00:00 2001 From: Gram Date: Fri, 27 Jul 2018 12:31:27 +0300 Subject: [PATCH 152/250] +changelog --- docs/changelog.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index 7eaed75a..9d9fa976 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -2,6 +2,10 @@ Changelog ========= +Changes in 0.15.4 +================= +- Added `DateField` #513 + Changes in 0.15.3 ================= - Subfield resolve error in generic_emdedded_document query #1651 #1652 From 3d45cdc339a08717267b94c7cfe47cb99c2afec8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 12 Jun 2018 20:59:12 +0200 Subject: [PATCH 153/250] Implemented lazy regex compiling in Field classes to improve 'import mongoengine' performance --- mongoengine/base/utils.py | 22 ++++++++++++++++++++ mongoengine/common.py | 1 + mongoengine/fields.py | 10 ++++----- mongoengine/python_support.py | 6 +----- tests/test_utils.py | 38 +++++++++++++++++++++++++++++++++++ 5 files changed, 67 insertions(+), 10 deletions(-) create mode 100644 mongoengine/base/utils.py create mode 100644 tests/test_utils.py diff --git a/mongoengine/base/utils.py b/mongoengine/base/utils.py new file mode 100644 index 00000000..288c2f3e --- /dev/null +++ b/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, obj, objtype): + return self.compiled_regex + + def __set__(self, instance, value): + raise AttributeError("Can not set attribute LazyRegexCompiler") diff --git a/mongoengine/common.py b/mongoengine/common.py index bde7e78c..2e64130f 100644 --- a/mongoengine/common.py +++ b/mongoengine/common.py @@ -56,3 +56,4 @@ def _import_class(cls_name): _class_registry_cache[cls] = getattr(module, cls) return _class_registry_cache.get(cls_name) + diff --git a/mongoengine/fields.py b/mongoengine/fields.py index f9622b31..28ab25c7 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -5,7 +5,6 @@ import re import socket import time import uuid -import warnings from operator import itemgetter from bson import Binary, DBRef, ObjectId, SON @@ -28,6 +27,7 @@ except ImportError: from mongoengine.base import (BaseDocument, BaseField, ComplexBaseField, GeoJsonBaseField, LazyReference, ObjectIdField, get_document) +from mongoengine.base.utils import LazyRegexCompiler from mongoengine.common import _import_class from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db from mongoengine.document import Document, EmbeddedDocument @@ -123,7 +123,7 @@ class URLField(StringField): .. versionadded:: 0.3 """ - _URL_REGEX = re.compile( + _URL_REGEX = LazyRegexCompiler( r'^(?:[a-z0-9\.\-]*)://' # scheme is validated separately r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}(?= 3 # six.BytesIO resolves to StringIO.StringIO in Py2 and io.BytesIO in Py3. StringIO = six.BytesIO diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 00000000..562cc1ff --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,38 @@ +import unittest +import re + +from mongoengine.base.utils import LazyRegexCompiler + +signal_output = [] + + +class LazyRegexCompilerTest(unittest.TestCase): + + def test_lazy_regex_compiler_verify_laziness_of_descriptor(self): + class UserEmail(object): + EMAIL_REGEX = LazyRegexCompiler('@', flags=32) + + descriptor = UserEmail.__dict__['EMAIL_REGEX'] + self.assertIsNone(descriptor._compiled_regex) + + regex = UserEmail.EMAIL_REGEX + self.assertEqual(regex, re.compile('@', flags=32)) + self.assertEqual(regex.search('user@domain.com').group(), '@') + + user_email = UserEmail() + self.assertIs(user_email.EMAIL_REGEX, UserEmail.EMAIL_REGEX) + + def test_lazy_regex_compiler_verify_cannot_set_descriptor_on_instance(self): + class UserEmail(object): + EMAIL_REGEX = LazyRegexCompiler('@') + + user_email = UserEmail() + with self.assertRaises(AttributeError): + user_email.EMAIL_REGEX = re.compile('@') + + def test_lazy_regex_compiler_verify_can_override_class_attr(self): + class UserEmail(object): + EMAIL_REGEX = LazyRegexCompiler('@') + + UserEmail.EMAIL_REGEX = re.compile('cookies') + self.assertEqual(UserEmail.EMAIL_REGEX.search('Cake & cookies').group(), 'cookies') From 727866f090668881e425b8a90491be1f23563737 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 5 Aug 2018 22:30:51 +0200 Subject: [PATCH 154/250] fix styling flake8 error from CI --- mongoengine/common.py | 1 - 1 file changed, 1 deletion(-) diff --git a/mongoengine/common.py b/mongoengine/common.py index 2e64130f..bde7e78c 100644 --- a/mongoengine/common.py +++ b/mongoengine/common.py @@ -56,4 +56,3 @@ def _import_class(cls_name): _class_registry_cache[cls] = getattr(module, cls) return _class_registry_cache.get(cls_name) - From 820f7b4d9375d35bdadb1d6b49b0b0429faea3b5 Mon Sep 17 00:00:00 2001 From: JoschSan Date: Tue, 7 Aug 2018 14:29:15 -0400 Subject: [PATCH 155/250] Update connecting.rst My suggest is append the parameter in authentication_source in authentication example, because was included in https://github.com/MongoEngine/mongoengine/pull/590/files --- docs/guide/connecting.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/guide/connecting.rst b/docs/guide/connecting.rst index f40ed4c5..5dac6ae9 100644 --- a/docs/guide/connecting.rst +++ b/docs/guide/connecting.rst @@ -18,10 +18,10 @@ 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 the :attr:`host` to From 1a2b1f283bc4dac8cd853fc6207d63185be3c012 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Mon, 13 Aug 2018 21:21:33 +0200 Subject: [PATCH 156/250] Update signals doc - clarification on EmbeddedDocument Since there is a .save() method on EmbeddedDocument, you could be tempted to attach a pre_save event to an EmbeddedDocument (#1720). This update is an attempt to make this clearer. --- docs/guide/signals.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/guide/signals.rst b/docs/guide/signals.rst index eed382c4..06bccb3b 100644 --- a/docs/guide/signals.rst +++ b/docs/guide/signals.rst @@ -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:: From 364813dd73f7deecaf197bbc5c25a1b63833f655 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Mon, 13 Aug 2018 22:34:37 +0200 Subject: [PATCH 157/250] Clarify that you should use python 2 when developing on mongoengine #1837 --- CONTRIBUTING.rst | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index 573d7060..f7b15c85 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -22,8 +22,11 @@ Supported Interpreters 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 `_ 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 `_. Style Guide ----------- From c09bfca6342a60ee20f931c16731282969c378bc Mon Sep 17 00:00:00 2001 From: "Terence D. Honles" Date: Wed, 15 Aug 2018 12:36:13 -0700 Subject: [PATCH 158/250] add __repr__ to Q and QCombination --- mongoengine/queryset/visitor.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/mongoengine/queryset/visitor.py b/mongoengine/queryset/visitor.py index bcf93a13..3ae053b8 100644 --- a/mongoengine/queryset/visitor.py +++ b/mongoengine/queryset/visitor.py @@ -131,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): @@ -151,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) From 1bcdcce93abdbf1c20410dcde395e20b6987cc2b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sat, 18 Aug 2018 00:03:17 +0200 Subject: [PATCH 159/250] remove dead code --- mongoengine/base/document.py | 4 +--- mongoengine/document.py | 2 +- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 4181bcd5..f03ce848 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -100,13 +100,11 @@ class BaseDocument(object): for key, value in values.iteritems(): if key in self._fields or key == '_id': setattr(self, key, value) - elif self._dynamic: + else: dynamic_data[key] = value else: FileField = _import_class('FileField') for key, value in values.iteritems(): - if key == '__auto_convert': - continue key = self._reverse_db_field_map.get(key, key) if key in self._fields or key in ('id', 'pk', '_cls'): if __auto_convert and value is not None: diff --git a/mongoengine/document.py b/mongoengine/document.py index c8532e5b..b9db8bc6 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -1000,7 +1000,7 @@ class Document(BaseDocument): class DynamicDocument(Document): """A Dynamic Document class allowing flexible, expandable and uncontrolled schemas. As a :class:`~mongoengine.Document` subclass, acts in the same - way as an ordinary document but has expando style properties. Any data + way as an ordinary document but has expanded style properties. Any data passed or set against the :class:`~mongoengine.DynamicDocument` that is not a field is automatically converted into a :class:`~mongoengine.fields.DynamicField` and data can be attributed to that From b71ff6fbb8f91c903d498ff0024f35ee47e128af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sat, 18 Aug 2018 23:04:46 +0200 Subject: [PATCH 160/250] fix validator of BinaryField. In fact bson.Binary fails if we give it unicode in input #273 --- mongoengine/fields.py | 4 ++-- tests/fields/fields.py | 35 ++++++++++++++++------------------- 2 files changed, 18 insertions(+), 21 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index f9622b31..75686e57 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1460,10 +1460,10 @@ class BinaryField(BaseField): return Binary(value) def validate(self, value): - if not isinstance(value, (six.binary_type, six.text_type, Binary)): + if not isinstance(value, (six.binary_type, Binary)): self.error('BinaryField only accepts instances of ' '(%s, %s, Binary)' % ( - six.binary_type.__name__, six.text_type.__name__)) + six.binary_type.__name__, Binary.__name__)) if self.max_bytes is not None and len(value) > self.max_bytes: self.error('Binary value is too long') diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 7352d242..96b77ee7 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -2967,37 +2967,34 @@ class FieldTest(MongoDBTestCase): self.assertEqual(MIME_TYPE, attachment_1.content_type) self.assertEqual(BLOB, six.binary_type(attachment_1.blob)) - def test_binary_validation(self): - """Ensure that invalid values cannot be assigned to binary fields. + def test_binary_validation_succeeds(self): + """Ensure that valid values can be assigned to binary fields. """ - class Attachment(Document): - blob = BinaryField() - class AttachmentRequired(Document): blob = BinaryField(required=True) class AttachmentSizeLimit(Document): blob = BinaryField(max_bytes=4) - Attachment.drop_collection() - AttachmentRequired.drop_collection() - AttachmentSizeLimit.drop_collection() - - attachment = Attachment() - attachment.validate() - attachment.blob = 2 - self.assertRaises(ValidationError, attachment.validate) - attachment_required = AttachmentRequired() self.assertRaises(ValidationError, attachment_required.validate) attachment_required.blob = Binary(six.b('\xe6\x00\xc4\xff\x07')) attachment_required.validate() - attachment_size_limit = AttachmentSizeLimit( - blob=six.b('\xe6\x00\xc4\xff\x07')) - self.assertRaises(ValidationError, attachment_size_limit.validate) - attachment_size_limit.blob = six.b('\xe6\x00\xc4\xff') - attachment_size_limit.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_binary_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_binary_field_primary(self): class Attachment(Document): From 461b789515306d2e339310aef691367c52204c49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 19 Aug 2018 22:54:37 +0200 Subject: [PATCH 161/250] relates to (#710) - Update gridfs.rst to make it clearer that you should save the Document hosting the GridFSProxy after calling .delete() or .replace() on the GridFSProxy - updated GridFSProxy.__str__ so that it would always print both the filename and the grid_id. This should improve debugging --- docs/guide/gridfs.rst | 6 ++++-- mongoengine/fields.py | 6 +++--- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/docs/guide/gridfs.rst b/docs/guide/gridfs.rst index 68e7a6d2..f7380e89 100644 --- a/docs/guide/gridfs.rst +++ b/docs/guide/gridfs.rst @@ -53,7 +53,8 @@ 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:: @@ -71,4 +72,5 @@ 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', 'rb') - marmot.photo.replace(another_marmot, content_type='image/png') + marmot.photo.replace(another_marmot, content_type='image/png') # Replaces the GridFS document + marmot.save() # Replaces the GridFS reference contained in marmot instance diff --git a/mongoengine/fields.py b/mongoengine/fields.py index f9622b31..9648bb0b 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1528,9 +1528,9 @@ class GridFSProxy(object): return '<%s: %s>' % (self.__class__.__name__, self.grid_id) def __str__(self): - name = getattr( - self.get(), 'filename', self.grid_id) if self.get() else '(no file)' - return '<%s: %s>' % (self.__class__.__name__, name) + gridout = self.get() + filename = getattr(gridout, 'filename') if gridout else '' + return '<%s: %s (%s)>' % (self.__class__.__name__, filename, self.grid_id) def __eq__(self, other): if isinstance(other, GridFSProxy): From 48a85ee6e000d744490faf5128e069d4094a4cab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Mon, 20 Aug 2018 00:10:27 +0200 Subject: [PATCH 162/250] update related tests --- tests/fields/file_tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/fields/file_tests.py b/tests/fields/file_tests.py index 8364d5ef..841e7c7d 100644 --- a/tests/fields/file_tests.py +++ b/tests/fields/file_tests.py @@ -54,7 +54,7 @@ class FileTest(MongoDBTestCase): result = PutFile.objects.first() self.assertTrue(putfile == result) - self.assertEqual("%s" % result.the_file, "") + self.assertEqual("%s" % result.the_file, "" % 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 From a7658c75735a5593a99e4b59895d09ecee30cb8f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 21 Aug 2018 18:01:12 +0200 Subject: [PATCH 163/250] fix BaseList.__iter__ operator (#1305) + minor improvements --- AUTHORS | 1 + mongoengine/base/datastructures.py | 8 ++++---- tests/test_datastructures.py | 17 ++++++++++++++++- 3 files changed, 21 insertions(+), 5 deletions(-) diff --git a/AUTHORS b/AUTHORS index 2e7b56fc..b38825dc 100644 --- a/AUTHORS +++ b/AUTHORS @@ -246,3 +246,4 @@ that much better: * Renjianxin (https://github.com/Davidrjx) * Erdenezul Batmunkh (https://github.com/erdenezul) * Andy Yankovsky (https://github.com/werat) + * Bastien Gérard (https://github.com/bagerard) diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index fddd945a..8948243e 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -128,8 +128,8 @@ class BaseList(list): return value def __iter__(self): - for i in six.moves.range(self.__len__()): - yield self[i] + for v in super(BaseList, self).__iter__(): + yield v def __setitem__(self, key, value, *args, **kwargs): if isinstance(key, slice): @@ -138,7 +138,7 @@ class BaseList(list): self._mark_as_changed(key) return super(BaseList, self).__setitem__(key, value) - def __delitem__(self, key, *args, **kwargs): + def __delitem__(self, key): self._mark_as_changed() return super(BaseList, self).__delitem__(key) @@ -187,7 +187,7 @@ class BaseList(list): self._mark_as_changed() return super(BaseList, self).remove(*args, **kwargs) - def reverse(self, *args, **kwargs): + def reverse(self): self._mark_as_changed() return super(BaseList, self).reverse() diff --git a/tests/test_datastructures.py b/tests/test_datastructures.py index 79381c5a..1ea562a5 100644 --- a/tests/test_datastructures.py +++ b/tests/test_datastructures.py @@ -1,6 +1,21 @@ import unittest -from mongoengine.base.datastructures import StrictDict +from mongoengine.base.datastructures import StrictDict, BaseList + + +class TestBaseList(unittest.TestCase): + + def test_iter_simple(self): + values = [True, False, True, False] + base_list = BaseList(values, instance=None, name='my_name') + self.assertEqual(values, list(base_list)) + + def test_iter_allow_modification_while_iterating_withou_error(self): + # regular list allows for this, thus this subclass must comply to that + base_list = BaseList([True, False, True, False], instance=None, name='my_name') + for idx, val in enumerate(base_list): + if val: + base_list.pop(idx) class TestStrictDict(unittest.TestCase): From d72daf5f39c2234207181362e5d3befd43106cc4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 26 Aug 2018 19:52:17 +0200 Subject: [PATCH 164/250] Fix BaseList bug with marked_as_changed getting called on error + Fix BaseDict as well since it suffers from the same problem --- mongoengine/base/datastructures.py | 159 ++++++-------- tests/test_datastructures.py | 329 ++++++++++++++++++++++++++++- 2 files changed, 394 insertions(+), 94 deletions(-) diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index 8948243e..6340dcdd 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -1,4 +1,3 @@ -import itertools import weakref from bson import DBRef @@ -7,7 +6,25 @@ import six from mongoengine.common import _import_class from mongoengine.errors import DoesNotExist, MultipleObjectsReturned -__all__ = ('BaseDict', 'BaseList', 'EmbeddedDocumentList', 'LazyReference') +__all__ = ('BaseDict', 'StrictDict', 'BaseList', 'EmbeddedDocumentList', 'LazyReference') + + +def mark_as_changed_wrapper(parent_method): + """Decorators that ensures _mark_as_changed method gets called""" + def wrapper(self, *args, **kwargs): + result = parent_method(self, *args, **kwargs) # Can't use super() in the decorator + self._mark_as_changed() + return result + return wrapper + + +def mark_key_as_changed_wrapper(parent_method): + """Decorators that ensures _mark_as_changed method gets called with the key argument""" + def wrapper(self, key, *args, **kwargs): + result = parent_method(self, key, *args, **kwargs) # Can't use super() in the decorator + self._mark_as_changed(key) + return result + return wrapper class BaseDict(dict): @@ -42,22 +59,6 @@ class BaseDict(dict): value._instance = self._instance return value - def __setitem__(self, key, value, *args, **kwargs): - self._mark_as_changed(key) - return super(BaseDict, self).__setitem__(key, value) - - def __delete__(self, *args, **kwargs): - self._mark_as_changed() - return super(BaseDict, self).__delete__(*args, **kwargs) - - def __delitem__(self, key, *args, **kwargs): - self._mark_as_changed(key) - return super(BaseDict, self).__delitem__(key) - - def __delattr__(self, key, *args, **kwargs): - self._mark_as_changed(key) - return super(BaseDict, self).__delattr__(key) - def __getstate__(self): self.instance = None self._dereferenced = False @@ -67,25 +68,14 @@ class BaseDict(dict): self = state return self - def clear(self, *args, **kwargs): - self._mark_as_changed() - return super(BaseDict, self).clear() - - 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() - - def setdefault(self, *args, **kwargs): - self._mark_as_changed() - return super(BaseDict, self).setdefault(*args, **kwargs) - - def update(self, *args, **kwargs): - self._mark_as_changed() - return super(BaseDict, self).update(*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 _mark_as_changed(self, key=None): if hasattr(self._instance, '_mark_as_changed'): @@ -111,17 +101,24 @@ class BaseList(list): self._name = name super(BaseList, self).__init__(list_items) - def __getitem__(self, key, *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 not isinstance(value, BaseDict) and isinstance(value, dict): + # Replace dict by BaseDict value = BaseDict(value, None, '%s.%s' % (self._name, key)) super(BaseList, self).__setitem__(key, value) value._instance = self._instance elif not isinstance(value, BaseList) and isinstance(value, list): + # Replace list by BaseList value = BaseList(value, None, '%s.%s' % (self._name, key)) super(BaseList, self).__setitem__(key, value) value._instance = self._instance @@ -131,25 +128,6 @@ class BaseList(list): for v in super(BaseList, self).__iter__(): yield v - def __setitem__(self, key, value, *args, **kwargs): - if isinstance(key, slice): - self._mark_as_changed() - else: - self._mark_as_changed(key) - return super(BaseList, self).__setitem__(key, value) - - def __delitem__(self, key): - self._mark_as_changed() - return super(BaseList, self).__delitem__(key) - - 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 __getstate__(self): self.instance = None self._dereferenced = False @@ -159,41 +137,40 @@ class BaseList(list): self = state return self - def __iadd__(self, other): - self._mark_as_changed() - return super(BaseList, self).__iadd__(other) + 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 __imul__(self, other): - self._mark_as_changed() - return super(BaseList, self).__imul__(other) + result = super(BaseList, self).__setitem__(key, value) + self._mark_as_changed(changed_key) + return result - def append(self, *args, **kwargs): - self._mark_as_changed() - return super(BaseList, self).append(*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 extend(self, *args, **kwargs): - self._mark_as_changed() - return super(BaseList, self).extend(*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 insert(self, *args, **kwargs): - self._mark_as_changed() - return super(BaseList, self).insert(*args, **kwargs) + def __delslice__(self, i, j): + return self.__delitem__(slice(i, j)) - def pop(self, *args, **kwargs): - self._mark_as_changed() - return super(BaseList, self).pop(*args, **kwargs) - - def remove(self, *args, **kwargs): - self._mark_as_changed() - return super(BaseList, self).remove(*args, **kwargs) - - def reverse(self): - self._mark_as_changed() - return super(BaseList, self).reverse() - - def sort(self, *args, **kwargs): - self._mark_as_changed() - return super(BaseList, self).sort(*args, **kwargs) + def __getslice__(self, i, j): + return self.__getitem__(slice(i, j)) def _mark_as_changed(self, key=None): if hasattr(self._instance, '_mark_as_changed'): @@ -207,6 +184,10 @@ class BaseList(list): 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 @@ -225,10 +206,6 @@ class EmbeddedDocumentList(BaseList): return embedded_docs return [doc for doc in embedded_docs if cls.__match_all(doc, kwargs)] - def __init__(self, list_items, instance, name): - super(EmbeddedDocumentList, self).__init__(list_items, instance, name) - self._instance = instance - def filter(self, **kwargs): """ Filters the list by only including embedded documents with the diff --git a/tests/test_datastructures.py b/tests/test_datastructures.py index 1ea562a5..f2ec098e 100644 --- a/tests/test_datastructures.py +++ b/tests/test_datastructures.py @@ -1,22 +1,345 @@ import unittest -from mongoengine.base.datastructures import StrictDict, BaseList +from mongoengine import Document +from mongoengine.base.datastructures import StrictDict, BaseList, BaseDict + + +class DocumentStub(object): + def __init__(self): + self._changed_fields = [] + + def _mark_as_changed(self, key): + self._changed_fields.append(key) + + +class TestBaseDict(unittest.TestCase): + + @staticmethod + def _get_basedict(dict_items): + """Get a BaseList bound to a fake document instance""" + fake_doc = DocumentStub() + base_list = BaseDict(dict_items, instance=None, name='my_name') + base_list._instance = fake_doc # hack to inject the mock, it does not work in the constructor + return base_list + + def test___init___(self): + class MyDoc(Document): + pass + + dict_items = {'k': 'v'} + doc = MyDoc() + base_dict = BaseDict(dict_items, instance=doc, name='my_name') + self.assertIsInstance(base_dict._instance, Document) + self.assertEqual(base_dict._name, 'my_name') + self.assertEqual(base_dict, dict_items) + + def test_setdefault_calls_mark_as_changed(self): + base_dict = self._get_basedict({}) + base_dict.setdefault('k', 'v') + self.assertEqual(base_dict._instance._changed_fields, [base_dict._name]) + + def test_popitems_calls_mark_as_changed(self): + base_dict = self._get_basedict({'k': 'v'}) + self.assertEqual(base_dict.popitem(), ('k', 'v')) + self.assertEqual(base_dict._instance._changed_fields, [base_dict._name]) + self.assertFalse(base_dict) + + def test_pop_calls_mark_as_changed(self): + base_dict = self._get_basedict({'k': 'v'}) + self.assertEqual(base_dict.pop('k'), 'v') + self.assertEqual(base_dict._instance._changed_fields, [base_dict._name]) + self.assertFalse(base_dict) + + def test_pop_calls_does_not_mark_as_changed_when_it_fails(self): + base_dict = self._get_basedict({'k': 'v'}) + with self.assertRaises(KeyError): + base_dict.pop('X') + self.assertFalse(base_dict._instance._changed_fields) + + def test_clear_calls_mark_as_changed(self): + base_dict = self._get_basedict({'k': 'v'}) + base_dict.clear() + self.assertEqual(base_dict._instance._changed_fields, ['my_name']) + self.assertEqual(base_dict, {}) + + def test___delitem___calls_mark_as_changed(self): + base_dict = self._get_basedict({'k': 'v'}) + del base_dict['k'] + self.assertEqual(base_dict._instance._changed_fields, ['my_name.k']) + self.assertEqual(base_dict, {}) + + def test___getitem____simple_value(self): + base_dict = self._get_basedict({'k': 'v'}) + base_dict['k'] = 'v' + + def test___getitem____sublist_gets_converted_to_BaseList(self): + base_dict = self._get_basedict({'k': [0, 1, 2]}) + sub_list = base_dict['k'] + self.assertEqual(sub_list, [0, 1, 2]) + self.assertIsInstance(sub_list, BaseList) + self.assertIs(sub_list._instance, base_dict._instance) + self.assertEqual(sub_list._name, 'my_name.k') + self.assertEqual(base_dict._instance._changed_fields, []) + + # Challenge mark_as_changed from sublist + sub_list[1] = None + self.assertEqual(base_dict._instance._changed_fields, ['my_name.k.1']) + + def test___getitem____subdict_gets_converted_to_BaseDict(self): + base_dict = self._get_basedict({'k': {'subk': 'subv'}}) + sub_dict = base_dict['k'] + self.assertEqual(sub_dict, {'subk': 'subv'}) + self.assertIsInstance(sub_dict, BaseDict) + self.assertIs(sub_dict._instance, base_dict._instance) + self.assertEqual(sub_dict._name, 'my_name.k') + self.assertEqual(base_dict._instance._changed_fields, []) + + # Challenge mark_as_changed from subdict + sub_dict['subk'] = None + self.assertEqual(base_dict._instance._changed_fields, ['my_name.k.subk']) + + def test___setitem___calls_mark_as_changed(self): + base_dict = self._get_basedict({}) + base_dict['k'] = 'v' + self.assertEqual(base_dict._instance._changed_fields, ['my_name.k']) + self.assertEqual(base_dict, {'k': 'v'}) + + def test_update_calls_mark_as_changed(self): + base_dict = self._get_basedict({}) + base_dict.update({'k': 'v'}) + self.assertEqual(base_dict._instance._changed_fields, ['my_name']) + + def test___setattr____not_tracked_by_changes(self): + base_dict = self._get_basedict({}) + base_dict.a_new_attr = 'test' + self.assertEqual(base_dict._instance._changed_fields, []) + + def test___delattr____tracked_by_changes(self): + # This is probably a bug as __setattr__ is not tracked + # This is even bad because it could be that there is an attribute + # with the same name as a key + base_dict = self._get_basedict({}) + base_dict.a_new_attr = 'test' + del base_dict.a_new_attr + self.assertEqual(base_dict._instance._changed_fields, ['my_name.a_new_attr']) class TestBaseList(unittest.TestCase): - def test_iter_simple(self): + @staticmethod + def _get_baselist(list_items): + """Get a BaseList bound to a fake document instance""" + fake_doc = DocumentStub() + base_list = BaseList(list_items, instance=None, name='my_name') + base_list._instance = fake_doc # hack to inject the mock, it does not work in the constructor + return base_list + + def test___init___(self): + class MyDoc(Document): + pass + + list_items = [True] + doc = MyDoc() + base_list = BaseList(list_items, instance=doc, name='my_name') + self.assertIsInstance(base_list._instance, Document) + self.assertEqual(base_list._name, 'my_name') + self.assertEqual(base_list, list_items) + + def test___iter__(self): values = [True, False, True, False] base_list = BaseList(values, instance=None, name='my_name') self.assertEqual(values, list(base_list)) - def test_iter_allow_modification_while_iterating_withou_error(self): + def test___iter___allow_modification_while_iterating_withou_error(self): # regular list allows for this, thus this subclass must comply to that base_list = BaseList([True, False, True, False], instance=None, name='my_name') for idx, val in enumerate(base_list): if val: base_list.pop(idx) + def test_append_calls_mark_as_changed(self): + base_list = self._get_baselist([]) + self.assertFalse(base_list._instance._changed_fields) + base_list.append(True) + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + + def test_subclass_append(self): + # Due to the way mark_as_changed_wrapper is implemented + # it is good to test subclasses + class SubBaseList(BaseList): + pass + + base_list = SubBaseList([], instance=None, name='my_name') + base_list.append(True) + + def test___getitem__using_simple_index(self): + base_list = self._get_baselist([0, 1, 2]) + self.assertEqual(base_list[0], 0) + self.assertEqual(base_list[1], 1) + self.assertEqual(base_list[-1], 2) + + def test___getitem__using_slice(self): + base_list = self._get_baselist([0, 1, 2]) + self.assertEqual(base_list[1:3], [1,2]) + self.assertEqual(base_list[0:3:2], [0, 2]) + + def test___getitem___using_slice_returns_list(self): + # Bug: using slice does not properly handles the instance + # and mark_as_changed behaviour. + base_list = self._get_baselist([0, 1, 2]) + sliced = base_list[1:3] + self.assertEqual(sliced, [1, 2]) + self.assertIsInstance(sliced, list) + self.assertEqual(base_list._instance._changed_fields, []) + + def test___getitem__sublist_returns_BaseList_bound_to_instance(self): + base_list = self._get_baselist( + [ + [1,2], + [3, 4] + ] + ) + sub_list = base_list[0] + self.assertEqual(sub_list, [1, 2]) + self.assertIsInstance(sub_list, BaseList) + self.assertIs(sub_list._instance, base_list._instance) + self.assertEqual(sub_list._name, 'my_name.0') + self.assertEqual(base_list._instance._changed_fields, []) + + # Challenge mark_as_changed from sublist + sub_list[1] = None + self.assertEqual(base_list._instance._changed_fields, ['my_name.0.1']) + + def test___getitem__subdict_returns_BaseList_bound_to_instance(self): + base_list = self._get_baselist( + [ + {'subk': 'subv'} + ] + ) + sub_dict = base_list[0] + self.assertEqual(sub_dict, {'subk': 'subv'}) + self.assertIsInstance(sub_dict, BaseDict) + self.assertIs(sub_dict._instance, base_list._instance) + self.assertEqual(sub_dict._name, 'my_name.0') + self.assertEqual(base_list._instance._changed_fields, []) + + # Challenge mark_as_changed from subdict + sub_dict['subk'] = None + self.assertEqual(base_list._instance._changed_fields, ['my_name.0.subk']) + + def test_extend_calls_mark_as_changed(self): + base_list = self._get_baselist([]) + base_list.extend([True]) + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + + def test_insert_calls_mark_as_changed(self): + base_list = self._get_baselist([]) + base_list.insert(0, True) + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + + def test_remove_calls_mark_as_changed(self): + base_list = self._get_baselist([True]) + base_list.remove(True) + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + + def test_remove_not_mark_as_changed_when_it_fails(self): + base_list = self._get_baselist([True]) + try: + base_list.remove(False) + except ValueError: + self.assertFalse(base_list._instance._changed_fields) + + def test_pop_calls_mark_as_changed(self): + base_list = self._get_baselist([True]) + base_list.pop() + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + + def test_reverse_calls_mark_as_changed(self): + base_list = self._get_baselist([True, False]) + base_list.reverse() + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + + def test___delitem___calls_mark_as_changed(self): + base_list = self._get_baselist([True]) + del base_list[0] + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + + def test___setitem___calls_with_full_slice_mark_as_changed(self): + base_list = self._get_baselist([]) + base_list[:] = [0, 1] # Will use __setslice__ under py2 and __setitem__ under py3 + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + self.assertEqual(base_list, [0, 1]) + + def test___setitem___calls_with_partial_slice_mark_as_changed(self): + base_list = self._get_baselist([0, 1, 2]) + base_list[0:2] = [1, 0] # Will use __setslice__ under py2 and __setitem__ under py3 + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + self.assertEqual(base_list, [1, 0, 2]) + + def test___setitem___calls_with_step_slice_mark_as_changed(self): + base_list = self._get_baselist([0, 1, 2]) + base_list[0:3:2] = [-1, -2] # uses __setitem__ in both py2 & 3 + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + self.assertEqual(base_list, [-1, 1, -2]) + + def test___setitem___with_slice(self): + base_list = self._get_baselist([0,1,2,3,4,5]) + base_list[0:6:2] = [None, None, None] + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + self.assertEqual(base_list, [None,1,None,3,None,5]) + + def test___setitem___item_0_calls_mark_as_changed(self): + base_list = self._get_baselist([True]) + base_list[0] = False + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + self.assertEqual(base_list, [False]) + + def test___setitem___item_1_calls_mark_as_changed(self): + base_list = self._get_baselist([True, True]) + base_list[1] = False + self.assertEqual(base_list._instance._changed_fields, ['my_name.1']) + self.assertEqual(base_list, [True, False]) + + def test___delslice___calls_mark_as_changed(self): + base_list = self._get_baselist([0, 1]) + del base_list[0:1] + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + self.assertEqual(base_list, [1]) + + def test___iadd___calls_mark_as_changed(self): + base_list = self._get_baselist([True]) + base_list += [False] + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + + def test___iadd___not_mark_as_changed_when_it_fails(self): + base_list = self._get_baselist([True]) + try: + base_list += None + except TypeError: + self.assertFalse(base_list._instance._changed_fields) + + def test___imul___calls_mark_as_changed(self): + base_list = self._get_baselist([True]) + base_list *= 2 + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + + def test___imul___not_mark_as_changed_when_it_fails(self): + base_list = self._get_baselist([True]) + try: + base_list *= None + except TypeError: + self.assertFalse(base_list._instance._changed_fields) + + def test_sort_calls_mark_as_changed(self): + base_list = self._get_baselist([True, False]) + base_list.sort() + self.assertEqual(base_list._instance._changed_fields, ['my_name']) + + def test_sort_calls_with_key(self): + base_list = self._get_baselist([1, 2, 11]) + base_list.sort(key=lambda i: str(i)) + self.assertEqual(base_list, [1, 11, 2]) + class TestStrictDict(unittest.TestCase): def strict_dict_class(self, *args, **kwargs): From b3b4d992fefaf3ae3e61465818c1dc3e6bdd9256 Mon Sep 17 00:00:00 2001 From: "Terence D. Honles" Date: Mon, 27 Aug 2018 19:24:24 -0700 Subject: [PATCH 165/250] add Q repr tests --- tests/queryset/visitor.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/tests/queryset/visitor.py b/tests/queryset/visitor.py index 6f020e88..6186e726 100644 --- a/tests/queryset/visitor.py +++ b/tests/queryset/visitor.py @@ -296,6 +296,18 @@ class QTest(unittest.TestCase): obj = self.Person.objects(Q(name__not=re.compile('^Gui'))).first() self.assertEqual(obj, None) + def test_q_repr(self): + self.assertEqual(repr(Q()), 'Q(**{})') + self.assertEqual(repr(Q(name='test')), "Q(**{'name': 'test'})") + + self.assertEqual( + repr(Q(name='test') & Q(age__gte=18)), + "(Q(**{'name': 'test'}) & Q(**{'age__gte': 18}))") + + self.assertEqual( + repr(Q(name='test') | Q(age__gte=18)), + "(Q(**{'name': 'test'}) | Q(**{'age__gte': 18}))") + def test_q_lists(self): """Ensure that Q objects query ListFields correctly. """ From 86548fc7bfcd73d75f5cf6fbc8cba690294d8253 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 28 Aug 2018 22:42:51 +0200 Subject: [PATCH 166/250] Document the attribute of .from_json --- mongoengine/base/document.py | 10 +++- tests/document/instance.py | 92 ++++++++++++++++++++++++++++-------- tests/queryset/queryset.py | 1 - 3 files changed, 81 insertions(+), 22 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index f03ce848..85906a3e 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -404,7 +404,15 @@ class BaseDocument(object): @classmethod def from_json(cls, json_data, created=False): - """Converts json data to an unsaved document instance""" + """Converts json data to a Document instance + + :param json_data: The json data to load into the Document + :param created: If True, the document will be considered as a brand new document + If False and an id is provided, it will consider that the data being + loaded corresponds to what's already in the database (This has an impact of subsequent call to .save()) + If False and no id is provided, it will consider the data as a new document + (default ``False``) + """ return cls._from_son(json_util.loads(json_data), created=created) def __expand_dynamic_values(self, name, value): diff --git a/tests/document/instance.py b/tests/document/instance.py index b255e8a6..ca0a5ad0 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -550,21 +550,14 @@ class InstanceTest(unittest.TestCase): pass f = Foo() - try: + with self.assertRaises(Foo.DoesNotExist): f.reload() - except Foo.DoesNotExist: - pass - except Exception: - self.assertFalse("Threw wrong exception") f.save() f.delete() - try: + + with self.assertRaises(Foo.DoesNotExist): f.reload() - except Foo.DoesNotExist: - pass - except Exception: - self.assertFalse("Threw wrong exception") def test_reload_of_non_strict_with_special_field_name(self): """Ensures reloading works for documents with meta strict == False.""" @@ -734,12 +727,12 @@ class InstanceTest(unittest.TestCase): t = TestDocument(status="draft", pub_date=datetime.now()) - try: + with self.assertRaises(ValidationError) as cm: t.save() - except ValidationError as e: - expect_msg = "Draft entries may not have a publication date." - self.assertTrue(expect_msg in e.message) - self.assertEqual(e.to_dict(), {'__all__': expect_msg}) + + expected_msg = "Draft entries may not have a publication date." + self.assertIn(expected_msg, cm.exception.message) + self.assertEqual(cm.exception.to_dict(), {'__all__': expected_msg}) t = TestDocument(status="published") t.save(clean=False) @@ -773,12 +766,13 @@ class InstanceTest(unittest.TestCase): TestDocument.drop_collection() t = TestDocument(doc=TestEmbeddedDocument(x=10, y=25, z=15)) - try: + + with self.assertRaises(ValidationError) as cm: t.save() - except ValidationError as e: - expect_msg = "Value of z != x + y" - self.assertTrue(expect_msg in e.message) - self.assertEqual(e.to_dict(), {'doc': {'__all__': expect_msg}}) + + expected_msg = "Value of z != x + y" + self.assertIn(expected_msg, cm.exception.message) + self.assertEqual(cm.exception.to_dict(), {'doc': {'__all__': expected_msg}}) t = TestDocument(doc=TestEmbeddedDocument(x=10, y=25)).save() self.assertEqual(t.doc.z, 35) @@ -3148,6 +3142,64 @@ class InstanceTest(unittest.TestCase): self.assertEquals(p.id, None) p.id = "12345" # in case it is not working: "OperationError: Shard Keys are immutable..." will be raised here + def test_from_son_created_False_without_id(self): + class MyPerson(Document): + name = StringField() + + MyPerson.objects.delete() + + p = MyPerson.from_json('{"name": "a_fancy_name"}', created=False) + self.assertFalse(p._created) + self.assertIsNone(p.id) + p.save() + self.assertIsNotNone(p.id) + saved_p = MyPerson.objects.get(id=p.id) + self.assertEqual(saved_p.name, 'a_fancy_name') + + def test_from_son_created_False_with_id(self): + # 1854 + class MyPerson(Document): + name = StringField() + + MyPerson.objects.delete() + + p = MyPerson.from_json('{"_id": "5b85a8b04ec5dc2da388296e", "name": "a_fancy_name"}', created=False) + self.assertFalse(p._created) + self.assertEqual(p._changed_fields, []) + self.assertEqual(p.name, 'a_fancy_name') + self.assertEqual(p.id, ObjectId('5b85a8b04ec5dc2da388296e')) + p.save() + + with self.assertRaises(DoesNotExist): + # Since created=False and we gave an id in the json and _changed_fields is empty + # mongoengine assumes that the document exits with that structure already + # and calling .save() didn't save anything + MyPerson.objects.get(id=p.id) + + self.assertFalse(p._created) + p.name = 'a new fancy name' + self.assertEqual(p._changed_fields, ['name']) + p.save() + saved_p = MyPerson.objects.get(id=p.id) + self.assertEqual(saved_p.name, p.name) + + def test_from_son_created_True_with_an_id(self): + class MyPerson(Document): + name = StringField() + + MyPerson.objects.delete() + + p = MyPerson.from_json('{"_id": "5b85a8b04ec5dc2da388296e", "name": "a_fancy_name"}', created=True) + self.assertTrue(p._created) + self.assertEqual(p._changed_fields, []) + self.assertEqual(p.name, 'a_fancy_name') + self.assertEqual(p.id, ObjectId('5b85a8b04ec5dc2da388296e')) + p.save() + + saved_p = MyPerson.objects.get(id=p.id) + self.assertEqual(saved_p, p) + self.assertEqual(p.name, 'a_fancy_name') + def test_null_field(self): # 734 class User(Document): diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 497a0d23..a405e892 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4457,7 +4457,6 @@ class QuerySetTest(unittest.TestCase): self.assertNotEqual(bars._CommandCursor__collection.read_preference, ReadPreference.SECONDARY_PREFERRED) - def test_json_simple(self): class Embedded(EmbeddedDocument): From 576f23d5fb371315e2b54b6798915d8a103c3e7e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 28 Aug 2018 22:58:13 +0200 Subject: [PATCH 167/250] Fix .delete doc of **write_concern as suggested by #1779 --- mongoengine/document.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index b9db8bc6..25af273d 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -585,9 +585,8 @@ class Document(BaseDocument): :param signal_kwargs: (optional) kwargs dictionary to be passed to the signal calls. :param write_concern: Extra keyword arguments are passed down which - will be used as options for the resultant - ``getLastError`` command. For example, - ``save(..., write_concern={w: 2, fsync: True}, ...)`` will + will be used as options for the resultant ``getLastError`` command. + For example, ``save(..., w: 2, fsync: True)`` will wait until at least two servers have recorded the write and will force an fsync on the primary server. From b4860de34dd922936b290d98c95e575c12c713d7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Wed, 29 Aug 2018 23:04:18 +0200 Subject: [PATCH 168/250] Fix index creation error that was swallowed by hasattr under python2 (#1688) --- mongoengine/dereference.py | 7 ++++++- tests/document/instance.py | 25 +++++++++++++++++++++---- 2 files changed, 27 insertions(+), 5 deletions(-) diff --git a/mongoengine/dereference.py b/mongoengine/dereference.py index 18b365cc..40bc72b2 100644 --- a/mongoengine/dereference.py +++ b/mongoengine/dereference.py @@ -133,7 +133,12 @@ class DeReference(object): """ object_map = {} for collection, dbrefs in self.reference_map.iteritems(): - if hasattr(collection, 'objects'): # We have a document class for the refs + + # we use getattr instead of hasattr because as 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] diff --git a/tests/document/instance.py b/tests/document/instance.py index b255e8a6..c933eaf4 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -8,9 +8,12 @@ import weakref from datetime import datetime from bson import DBRef, ObjectId +from pymongo.errors import DuplicateKeyError + from tests import fixtures from tests.fixtures import (PickleEmbedded, PickleTest, PickleSignalsTest, PickleDynamicEmbedded, PickleDynamicTest) +from tests.utils import MongoDBTestCase from mongoengine import * from mongoengine.base import get_document, _document_registry @@ -30,12 +33,9 @@ TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__), __all__ = ("InstanceTest",) -class InstanceTest(unittest.TestCase): +class InstanceTest(MongoDBTestCase): def setUp(self): - connect(db='mongoenginetest') - self.db = get_db() - class Job(EmbeddedDocument): name = StringField() years = IntField() @@ -3248,6 +3248,23 @@ class InstanceTest(unittest.TestCase): blog.reload() self.assertEqual(blog.tags, [["value1", 123]]) + def test_accessing_objects_with_indexes_error(self): + insert_result = self.db.company.insert_many([{'name': 'Foo'}, + {'name': 'Foo'}]) # Force 2 doc with same name + REF_OID = insert_result.inserted_ids[0] + self.db.user.insert_one({'company': REF_OID}) # Force 2 doc with same name + + class Company(Document): + name = StringField(unique=True) + + class User(Document): + company = ReferenceField(Company) + + + # Ensure index creation exception aren't swallowed (#1688) + with self.assertRaises(DuplicateKeyError): + User.objects().select_related() + if __name__ == '__main__': unittest.main() From 7ddbea697e84dc8a9b06dbc144a03a27706a21d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Thu, 30 Aug 2018 14:33:57 +0200 Subject: [PATCH 169/250] fix CI that fails due to pypi + override BaseDict.get as it was missing --- mongoengine/base/datastructures.py | 9 +++++- tests/test_datastructures.py | 46 ++++++++++++++++++++---------- 2 files changed, 39 insertions(+), 16 deletions(-) diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index 6340dcdd..d5faa71b 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -43,7 +43,14 @@ class BaseDict(dict): self._name = name super(BaseDict, self).__init__(dict_items) - def __getitem__(self, key, *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') diff --git a/tests/test_datastructures.py b/tests/test_datastructures.py index f2ec098e..2f1277e6 100644 --- a/tests/test_datastructures.py +++ b/tests/test_datastructures.py @@ -68,6 +68,11 @@ class TestBaseDict(unittest.TestCase): self.assertEqual(base_dict._instance._changed_fields, ['my_name.k']) self.assertEqual(base_dict, {}) + def test___getitem____KeyError(self): + base_dict = self._get_basedict({}) + with self.assertRaises(KeyError): + base_dict['new'] + def test___getitem____simple_value(self): base_dict = self._get_basedict({'k': 'v'}) base_dict['k'] = 'v' @@ -98,6 +103,24 @@ class TestBaseDict(unittest.TestCase): sub_dict['subk'] = None self.assertEqual(base_dict._instance._changed_fields, ['my_name.k.subk']) + def test_get_sublist_gets_converted_to_BaseList_just_like__getitem__(self): + base_dict = self._get_basedict({'k': [0, 1, 2]}) + sub_list = base_dict.get('k') + self.assertEqual(sub_list, [0, 1, 2]) + self.assertIsInstance(sub_list, BaseList) + + def test_get_returns_the_same_as___getitem__(self): + base_dict = self._get_basedict({'k': [0, 1, 2]}) + get_ = base_dict.get('k') + getitem_ = base_dict['k'] + self.assertEqual(get_, getitem_) + + def test_get_default(self): + base_dict = self._get_basedict({}) + sentinel = object() + self.assertEqual(base_dict.get('new'), None) + self.assertIs(base_dict.get('new', sentinel), sentinel) + def test___setitem___calls_mark_as_changed(self): base_dict = self._get_basedict({}) base_dict['k'] = 'v' @@ -244,10 +267,9 @@ class TestBaseList(unittest.TestCase): def test_remove_not_mark_as_changed_when_it_fails(self): base_list = self._get_baselist([True]) - try: + with self.assertRaises(ValueError): base_list.remove(False) - except ValueError: - self.assertFalse(base_list._instance._changed_fields) + self.assertFalse(base_list._instance._changed_fields) def test_pop_calls_mark_as_changed(self): base_list = self._get_baselist([True]) @@ -311,24 +333,18 @@ class TestBaseList(unittest.TestCase): base_list += [False] self.assertEqual(base_list._instance._changed_fields, ['my_name']) - def test___iadd___not_mark_as_changed_when_it_fails(self): - base_list = self._get_baselist([True]) - try: - base_list += None - except TypeError: - self.assertFalse(base_list._instance._changed_fields) - def test___imul___calls_mark_as_changed(self): base_list = self._get_baselist([True]) + self.assertEqual(base_list._instance._changed_fields, []) base_list *= 2 self.assertEqual(base_list._instance._changed_fields, ['my_name']) - def test___imul___not_mark_as_changed_when_it_fails(self): + def test_sort_calls_not_marked_as_changed_when_it_fails(self): base_list = self._get_baselist([True]) - try: - base_list *= None - except TypeError: - self.assertFalse(base_list._instance._changed_fields) + with self.assertRaises(TypeError): + base_list.sort(key=1) + + self.assertEqual(base_list._instance._changed_fields, []) def test_sort_calls_mark_as_changed(self): base_list = self._get_baselist([True, False]) From 4779106139306257fb9dfd8203ed7cc7c3310385 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Thu, 30 Aug 2018 21:50:03 +0200 Subject: [PATCH 170/250] Improve doc of EmbeddedDocumentList.filter and clarify that it does not supports operators like __lte, __gte, etc --- mongoengine/base/datastructures.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index 8948243e..db292f14 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -234,6 +234,9 @@ class EmbeddedDocumentList(BaseList): 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.* From 5dbee2a2708722a4e9835ac5738991ba394954c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Thu, 30 Aug 2018 16:03:16 +0200 Subject: [PATCH 171/250] Ensures EmbeddedDocumentField does not accepts references to Document classes in its constructor --- mongoengine/fields.py | 12 +++++++++-- tests/fields/fields.py | 47 ++++++++++++++++++++++++++++++++++++++++++ tests/utils.py | 8 +++++-- 3 files changed, 63 insertions(+), 4 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 16f3185f..a54d3a52 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -645,9 +645,17 @@ class EmbeddedDocumentField(BaseField): def document_type(self): if isinstance(self.document_type_obj, six.string_types): if self.document_type_obj == RECURSIVE_REFERENCE_CONSTANT: - self.document_type_obj = self.owner_document + resolved_document_type = self.owner_document else: - self.document_type_obj = get_document(self.document_type_obj) + resolved_document_type = get_document(self.document_type_obj) + + if not issubclass(resolved_document_type, EmbeddedDocument): + # Due to the late resolution of the document_type + # There is a chance that it won't be an EmbeddedDocument (#1661) + self.error('Invalid embedded document class provided to an ' + 'EmbeddedDocumentField') + self.document_type_obj = resolved_document_type + return self.document_type_obj def to_python(self, value): diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 7352d242..362acec4 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -2147,6 +2147,15 @@ class FieldTest(MongoDBTestCase): ])) self.assertEqual(a.b.c.txt, 'hi') + def test_embedded_document_field_cant_reference_using_a_str_if_it_does_not_exist_yet(self): + raise SkipTest("Using a string reference in an EmbeddedDocumentField does not work if the class isnt registerd yet") + + class MyDoc2(Document): + emb = EmbeddedDocumentField('MyDoc') + + class MyDoc(EmbeddedDocument): + name = StringField() + def test_embedded_document_validation(self): """Ensure that invalid embedded documents cannot be assigned to embedded document fields. @@ -4388,6 +4397,44 @@ class EmbeddedDocumentListFieldTestCase(MongoDBTestCase): self.assertEqual(custom_data['a'], CustomData.c_field.custom_data['a']) +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') + class CachedReferenceFieldTest(MongoDBTestCase): def test_cached_reference_field_get_and_save(self): diff --git a/tests/utils.py b/tests/utils.py index 4566d864..acd318c5 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -7,12 +7,12 @@ from mongoengine.connection import get_db, get_connection from mongoengine.python_support import IS_PYMONGO_3 -MONGO_TEST_DB = 'mongoenginetest' +MONGO_TEST_DB = 'mongoenginetest' # standard name for the test database class MongoDBTestCase(unittest.TestCase): """Base class for tests that need a mongodb connection - db is being dropped automatically + It ensures that the db is clean at the beginning and dropped at the end automatically """ @classmethod @@ -32,6 +32,7 @@ def get_mongodb_version(): """ return tuple(get_connection().server_info()['versionArray']) + def _decorated_with_ver_requirement(func, ver_tuple): """Return a given function decorated with the version requirement for a particular MongoDB version tuple. @@ -50,18 +51,21 @@ def _decorated_with_ver_requirement(func, ver_tuple): return _inner + def needs_mongodb_v26(func): """Raise a SkipTest exception if we're working with MongoDB version lower than v2.6. """ return _decorated_with_ver_requirement(func, (2, 6)) + def needs_mongodb_v3(func): """Raise a SkipTest exception if we're working with MongoDB version lower than v3.0. """ return _decorated_with_ver_requirement(func, (3, 0)) + def skip_pymongo3(f): """Raise a SkipTest exception if we're running a test against PyMongo v3.x. From d9fce49b082d774163f355d17ad432f0627ae086 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Thu, 30 Aug 2018 22:46:37 +0200 Subject: [PATCH 172/250] minor improvement to DateTimeField doc --- mongoengine/fields.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 9648bb0b..ead86291 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -462,6 +462,8 @@ class DateTimeField(BaseField): installed you can utilise it to convert varying types of date formats into valid python datetime objects. + Note: To default the field to the current datetime, use: DateTimeField(default=datetime.utcnow) + Note: Microseconds are rounded to the nearest millisecond. Pre UTC microsecond support is effectively broken. Use :class:`~mongoengine.fields.ComplexDateTimeField` if you From bd524d2e1e51f2c9ea4bc971003eeb34e8e7a090 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Thu, 30 Aug 2018 23:13:10 +0200 Subject: [PATCH 173/250] Documented that it is possible to specify a name when using a dict to define an index --- docs/guide/defining-documents.rst | 3 +++ mongoengine/context_managers.py | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index 2a8d5418..366d12c7 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -513,6 +513,9 @@ 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 + .. note:: Inheritance adds extra fields indices see: :ref:`document-inheritance`. diff --git a/mongoengine/context_managers.py b/mongoengine/context_managers.py index ec2e9e8b..0343e163 100644 --- a/mongoengine/context_managers.py +++ b/mongoengine/context_managers.py @@ -215,7 +215,7 @@ class query_counter(object): """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 + self.counter += 1 # Account for the query we just fired return count From a7852a89cc5d8a9bf0f976c99cd42eacade4ef85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sat, 1 Sep 2018 23:30:50 +0200 Subject: [PATCH 174/250] Fixes 2 bugs in no_subclasses context mgr (__exit__ swallows exception + repair feature) --- mongoengine/context_managers.py | 9 +++---- tests/test_context_managers.py | 44 +++++++++++++++++++++++++-------- 2 files changed, 38 insertions(+), 15 deletions(-) diff --git a/mongoengine/context_managers.py b/mongoengine/context_managers.py index ec2e9e8b..cfc0cdd4 100644 --- a/mongoengine/context_managers.py +++ b/mongoengine/context_managers.py @@ -145,18 +145,17 @@ class no_sub_classes(object): :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,) + 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 + self.cls._subclasses = self.cls_initial_subclasses class query_counter(object): diff --git a/tests/test_context_managers.py b/tests/test_context_managers.py index 0f6bf815..8c96016c 100644 --- a/tests/test_context_managers.py +++ b/tests/test_context_managers.py @@ -140,8 +140,6 @@ class ContextManagersTest(unittest.TestCase): def test_no_sub_classes(self): class A(Document): x = IntField() - y = IntField() - meta = {'allow_inheritance': True} class B(A): @@ -152,29 +150,29 @@ class ContextManagersTest(unittest.TestCase): A.drop_collection() - A(x=10, y=20).save() - A(x=15, y=30).save() - B(x=20, y=40).save() - B(x=30, y=50).save() - C(x=40, y=60).save() + A(x=10).save() + A(x=15).save() + B(x=20).save() + B(x=30).save() + C(x=40).save() self.assertEqual(A.objects.count(), 5) self.assertEqual(B.objects.count(), 3) self.assertEqual(C.objects.count(), 1) - with no_sub_classes(A) as A: + with no_sub_classes(A): self.assertEqual(A.objects.count(), 2) for obj in A.objects: self.assertEqual(obj.__class__, A) - with no_sub_classes(B) as B: + with no_sub_classes(B): self.assertEqual(B.objects.count(), 2) for obj in B.objects: self.assertEqual(obj.__class__, B) - with no_sub_classes(C) as C: + with no_sub_classes(C): self.assertEqual(C.objects.count(), 1) for obj in C.objects: @@ -185,6 +183,32 @@ class ContextManagersTest(unittest.TestCase): self.assertEqual(B.objects.count(), 3) self.assertEqual(C.objects.count(), 1) + def test_no_sub_classes_modification_to_document_class_are_temporary(self): + class A(Document): + x = IntField() + meta = {'allow_inheritance': True} + + class B(A): + z = IntField() + + self.assertEqual(A._subclasses, ('A', 'A.B')) + with no_sub_classes(A): + self.assertEqual(A._subclasses, ('A',)) + self.assertEqual(A._subclasses, ('A', 'A.B')) + + self.assertEqual(B._subclasses, ('A.B',)) + with no_sub_classes(B): + self.assertEqual(B._subclasses, ('A.B',)) + self.assertEqual(B._subclasses, ('A.B',)) + + def test_no_subclass_context_manager_does_not_swallow_exception(self): + class User(Document): + name = StringField() + + with self.assertRaises(TypeError): + with no_sub_classes(User): + raise TypeError() + def test_query_counter(self): connect('mongoenginetest') db = get_db() From 8ff82996fb76314f799e9a153f32a4adc37485d0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Mon, 3 Sep 2018 11:11:15 +0200 Subject: [PATCH 175/250] Fix few things related to query_counter context manager: - Improve doc - Fix the fact that the context was modifying the initial profiling_level in case it was != 0 - Ignores 'killcursors' to fix flaky test that were impacted by killcursors queries (#1869) --- mongoengine/context_managers.py | 56 +++++++++++++------- tests/queryset/queryset.py | 29 +++++++---- tests/test_context_managers.py | 91 +++++++++++++++++++++++++++++++-- 3 files changed, 143 insertions(+), 33 deletions(-) diff --git a/mongoengine/context_managers.py b/mongoengine/context_managers.py index 67c83581..ee1f5e01 100644 --- a/mongoengine/context_managers.py +++ b/mongoengine/context_managers.py @@ -159,51 +159,69 @@ class no_sub_classes(object): 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': + {'$ne': 'killcursors'} + } + + 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): @@ -211,10 +229,12 @@ class query_counter(object): 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 # Account for the query we just fired + """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 = self.db.system.profile.find(self._ignored_query).count() - self._ctx_query_counter + self._ctx_query_counter += 1 # Account for the query we just issued to gather the information return count diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index a405e892..ff5407df 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4714,18 +4714,27 @@ class QuerySetTest(unittest.TestCase): for i in range(100): Person(name="No: %s" % i).save() - with query_counter() as q: - self.assertEqual(q, 0) - people = Person.objects.no_cache() + with query_counter() as q: + try: + self.assertEqual(q, 0) + people = Person.objects.no_cache() - [x for x in people] - self.assertEqual(q, 1) + [x for x in people] + self.assertEqual(q, 1) - list(people) - self.assertEqual(q, 2) + list(people) + self.assertEqual(q, 2) + + people.count() + self.assertEqual(q, 3) + except AssertionError as exc: + db = get_db() + msg = '' + for q in list(db.system.profile.find())[-50:]: + msg += str([q['ts'], q['ns'], q.get('query'), q['op']])+'\n' + msg += str(q) + raise AssertionError(str(exc) + '\n'+msg) - people.count() - self.assertEqual(q, 3) def test_cache_not_cloned(self): @@ -5053,7 +5062,7 @@ class QuerySetTest(unittest.TestCase): {"$ne": "%s.system.indexes" % q.db.name}})[0] self.assertFalse('$orderby' in op['query'], - 'BaseQuerySet must remove orderby from meta in boolen test') + 'BaseQuerySet must remove orderby from meta in boolean test') self.assertEqual(Person.objects.first().name, 'A') self.assertTrue(Person.objects._has_data(), diff --git a/tests/test_context_managers.py b/tests/test_context_managers.py index 8c96016c..2b265cbd 100644 --- a/tests/test_context_managers.py +++ b/tests/test_context_managers.py @@ -209,18 +209,99 @@ class ContextManagersTest(unittest.TestCase): with no_sub_classes(User): raise TypeError() + def test_query_counter_does_not_swallow_exception(self): + + with self.assertRaises(TypeError): + with query_counter() as q: + raise TypeError() + + def test_query_counter_temporarily_modifies_profiling_level(self): + connect('mongoenginetest') + db = get_db() + + initial_profiling_level = db.profiling_level() + + try: + NEW_LEVEL = 1 + db.set_profiling_level(NEW_LEVEL) + self.assertEqual(db.profiling_level(), NEW_LEVEL) + with query_counter() as q: + self.assertEqual(db.profiling_level(), 2) + self.assertEqual(db.profiling_level(), NEW_LEVEL) + except Exception: + db.set_profiling_level(initial_profiling_level) # Ensures it gets reseted no matter the outcome of the test + raise + def test_query_counter(self): connect('mongoenginetest') db = get_db() - db.test.find({}) + + collection = db.query_counter + collection.drop() + + def issue_1_count_query(): + collection.find({}).count() + + def issue_1_insert_query(): + collection.insert_one({'test': 'garbage'}) + + def issue_1_find_query(): + collection.find_one() + + counter = 0 + with query_counter() as q: + self.assertEqual(q, counter) + self.assertEqual(q, counter) # Ensures previous count query did not get counted + + for _ in range(10): + issue_1_insert_query() + counter += 1 + self.assertEqual(q, counter) + + for _ in range(4): + issue_1_find_query() + counter += 1 + self.assertEqual(q, counter) + + for _ in range(3): + issue_1_count_query() + counter += 1 + self.assertEqual(q, counter) + + def test_query_counter_counts_getmore_queries(self): + connect('mongoenginetest') + db = get_db() + + collection = db.query_counter + collection.drop() + + many_docs = [{'test': 'garbage %s' % i} for i in range(150)] + collection.insert_many(many_docs) # first batch of documents contains 101 documents with query_counter() as q: - self.assertEqual(0, q) + self.assertEqual(q, 0) + list(collection.find()) + self.assertEqual(q, 2) # 1st select + 1 getmore - for i in range(1, 51): - db.test.find({}).count() + def test_query_counter_ignores_particular_queries(self): + connect('mongoenginetest') + db = get_db() - self.assertEqual(50, q) + collection = db.query_counter + collection.insert_many([{'test': 'garbage %s' % i} for i in range(10)]) + + with query_counter() as q: + self.assertEqual(q, 0) + cursor = collection.find() + self.assertEqual(q, 0) # cursor wasn't opened yet + _ = next(cursor) # opens the cursor and fires the find query + self.assertEqual(q, 1) + + cursor.close() # issues a `killcursors` query that is ignored by the context + self.assertEqual(q, 1) + + _ = db.system.indexes.find_one() # queries on db.system.indexes are ignored as well + self.assertEqual(q, 1) if __name__ == '__main__': unittest.main() From 408274152baf75485f17eee9cc0550fd7bb82960 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Tue, 4 Sep 2018 20:24:34 +0800 Subject: [PATCH 176/250] reduce cycle complexity using logic map --- mongoengine/queryset/transform.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index 5f777f41..555be6f9 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -214,17 +214,20 @@ def update(_doc_cls=None, **update): 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 operator doesn't found from operator map, op value will stay + # unchanged + op = operator_map.get(op, op) + if op == 'dec': # Support decrement by flipping a positive value's sign # and using 'inc' - op = 'inc' value = -value - elif op == 'add_to_set': - op = 'addToSet' - elif op == 'set_on_insert': - op = 'setOnInsert' match = None if parts[-1] in COMPARISON_OPERATORS: From e83b529f1c8cc032968797057d7791169fc9bba5 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Tue, 4 Sep 2018 20:38:42 +0800 Subject: [PATCH 177/250] flip value before changing op to inc --- mongoengine/queryset/transform.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index 555be6f9..a8670543 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -221,13 +221,13 @@ def update(_doc_cls=None, **update): 'add_to_set': 'addToSet', 'set_on_insert': 'setOnInsert' } - # If operator doesn't found from operator map, op value will stay - # unchanged - op = operator_map.get(op, op) if op == 'dec': # Support decrement by flipping a positive value's sign # and using 'inc' value = -value + # If operator doesn't found from operator map, op value will stay + # unchanged + op = operator_map.get(op, op) match = None if parts[-1] in COMPARISON_OPERATORS: From b65478e7d9c8f09d915a102a367e8da52ad6bdf4 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Tue, 4 Sep 2018 20:44:44 +0800 Subject: [PATCH 178/250] trigger ci --- mongoengine/queryset/transform.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index a8670543..6021d464 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -225,8 +225,8 @@ def update(_doc_cls=None, **update): # Support decrement by flipping a positive value's sign # and using 'inc' value = -value - # If operator doesn't found from operator map, op value will stay - # unchanged + # If the operator doesn't found from operator map, the op value + # will stay unchanged op = operator_map.get(op, op) match = None From ab08e67eaf3f6b809a58740c0cfbbb24e1a3ef0b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Thu, 30 Aug 2018 23:57:16 +0200 Subject: [PATCH 179/250] fix inc/dec operator with decimal --- mongoengine/fields.py | 7 ++- mongoengine/queryset/transform.py | 6 +++ tests/queryset/queryset.py | 79 ++++++++++++++++++++++++++----- 3 files changed, 78 insertions(+), 14 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 89b901e7..d8eaec4e 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -364,7 +364,8 @@ class FloatField(BaseField): class DecimalField(BaseField): - """Fixed-point decimal number field. + """Fixed-point decimal number field. Stores the value as a float by default unless `force_string` is used. + If using floats, beware of Decimal to float conversion (potential precision loss) .. versionchanged:: 0.8 .. versionadded:: 0.3 @@ -375,7 +376,9 @@ class DecimalField(BaseField): """ :param min_value: Validation rule for the minimum acceptable value. :param max_value: Validation rule for the maximum acceptable value. - :param force_string: Store as a string. + :param force_string: Store the value as a string (instead of a float). + Be aware that this affects query sorting and operation like lte, gte (as string comparison is applied) + and some query operator won't work (e.g: inc, dec) :param precision: Number of decimal places to store. :param rounding: The rounding rule from the python decimal library: diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index 6021d464..25bd68e0 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -201,14 +201,18 @@ def update(_doc_cls=None, **update): format. """ mongo_update = {} + for key, value in update.items(): 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: @@ -294,6 +298,8 @@ def update(_doc_cls=None, **update): value = field.prepare_query_value(op, value) elif op == 'unset': value = 1 + elif op == 'inc': + value = field.prepare_query_value(op, value) if match: match = '$' + match diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index a405e892..b0dd354d 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -3,6 +3,7 @@ import datetime import unittest import uuid +from decimal import Decimal from bson import DBRef, ObjectId from nose.plugins.skip import SkipTest @@ -1851,21 +1852,16 @@ class QuerySetTest(unittest.TestCase): self.assertEqual( 1, BlogPost.objects(author__in=["%s" % me.pk]).count()) - def test_update(self): - """Ensure that atomic updates work properly. - """ + def test_update_intfield_operator(self): class BlogPost(Document): - name = StringField() - title = StringField() hits = IntField() - tags = ListField(StringField()) BlogPost.drop_collection() - post = BlogPost(name="Test Post", hits=5, tags=['test']) + post = BlogPost(hits=5) post.save() - BlogPost.objects.update(set__hits=10) + BlogPost.objects.update_one(set__hits=10) post.reload() self.assertEqual(post.hits, 10) @@ -1882,6 +1878,55 @@ class QuerySetTest(unittest.TestCase): post.reload() self.assertEqual(post.hits, 11) + def test_update_decimalfield_operator(self): + class BlogPost(Document): + review = DecimalField() + + BlogPost.drop_collection() + + post = BlogPost(review=3.5) + post.save() + + BlogPost.objects.update_one(inc__review=0.1) # test with floats + post.reload() + self.assertEqual(float(post.review), 3.6) + + BlogPost.objects.update_one(dec__review=0.1) + post.reload() + self.assertEqual(float(post.review), 3.5) + + BlogPost.objects.update_one(inc__review=Decimal(0.12)) # test with Decimal + post.reload() + self.assertEqual(float(post.review), 3.62) + + BlogPost.objects.update_one(dec__review=Decimal(0.12)) + post.reload() + self.assertEqual(float(post.review), 3.5) + + def test_update_decimalfield_operator_not_working_with_force_string(self): + class BlogPost(Document): + review = DecimalField(force_string=True) + + BlogPost.drop_collection() + + post = BlogPost(review=3.5) + post.save() + + with self.assertRaises(OperationError): + BlogPost.objects.update_one(inc__review=0.1) # test with floats + + def test_update_listfield_operator(self): + """Ensure that atomic updates work properly. + """ + class BlogPost(Document): + tags = ListField(StringField()) + + BlogPost.drop_collection() + + post = BlogPost(tags=['test']) + post.save() + + # ListField operator BlogPost.objects.update(push__tags='mongo') post.reload() self.assertTrue('mongo' in post.tags) @@ -1900,13 +1945,23 @@ class QuerySetTest(unittest.TestCase): post.reload() self.assertEqual(post.tags.count('unique'), 1) - self.assertNotEqual(post.hits, None) - BlogPost.objects.update_one(unset__hits=1) - post.reload() - self.assertEqual(post.hits, None) + BlogPost.drop_collection() + + def test_update_unset(self): + class BlogPost(Document): + title = StringField() BlogPost.drop_collection() + post = BlogPost(title='garbage').save() + + self.assertNotEqual(post.title, None) + BlogPost.objects.update_one(unset__title=1) + post.reload() + self.assertEqual(post.title, None) + pymongo_doc = BlogPost.objects.as_pymongo().first() + self.assertNotIn('title', pymongo_doc) + @needs_mongodb_v26 def test_update_push_with_position(self): """Ensure that the 'push' update with position works properly. From cf9df548ca1280a34f6bf5bbce1971400bb07656 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 4 Sep 2018 19:18:40 +0200 Subject: [PATCH 180/250] reverted back to the StopIteration in queryset.next that one didnt have to be changed (test stalled) --- mongoengine/queryset/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index a4e64018..2c80218c 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -1481,7 +1481,7 @@ class BaseQuerySet(object): """Wrap the result in a :class:`~mongoengine.Document` object. """ if self._limit == 0 or self._none: - return + raise StopIteration raw_doc = self._cursor.next() From a25d127f368b7dfba1f697d34d27ee0b54a29df6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 4 Sep 2018 20:51:06 +0200 Subject: [PATCH 181/250] Remove DictField.basecls related code, it is useless --- mongoengine/fields.py | 9 ++------- tests/queryset/queryset.py | 27 --------------------------- 2 files changed, 2 insertions(+), 34 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 6994b315..91604a16 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -945,14 +945,9 @@ class DictField(ComplexBaseField): .. versionchanged:: 0.5 - Can now handle complex / varying types of data """ - def __init__(self, basecls=None, field=None, *args, **kwargs): + def __init__(self, field=None, *args, **kwargs): self.field = field self._auto_dereference = False - self.basecls = basecls or BaseField - - # XXX ValidationError raised outside of the "validate" method. - if not issubclass(self.basecls, BaseField): - self.error('DictField only accepts dict values') kwargs.setdefault('default', lambda: {}) super(DictField, self).__init__(*args, **kwargs) @@ -972,7 +967,7 @@ class DictField(ComplexBaseField): super(DictField, self).validate(value) def lookup_member(self, member_name): - return DictField(basecls=self.basecls, db_field=member_name) + return DictField(db_field=member_name) def prepare_query_value(self, op, value): match_operators = ['contains', 'icontains', 'startswith', diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 77308c26..c6aa3594 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -3618,33 +3618,6 @@ class QuerySetTest(unittest.TestCase): Group.drop_collection() - def test_dict_with_custom_baseclass(self): - """Ensure DictField working with custom base clases. - """ - class Test(Document): - testdict = DictField() - - Test.drop_collection() - - t = Test(testdict={'f': 'Value'}) - t.save() - - self.assertEqual( - Test.objects(testdict__f__startswith='Val').count(), 1) - self.assertEqual(Test.objects(testdict__f='Value').count(), 1) - Test.drop_collection() - - class Test(Document): - testdict = DictField(basecls=StringField) - - t = Test(testdict={'f': 'Value'}) - t.save() - - self.assertEqual(Test.objects(testdict__f='Value').count(), 1) - self.assertEqual( - Test.objects(testdict__f__startswith='Val').count(), 1) - Test.drop_collection() - def test_bulk(self): """Ensure bulk querying by object id returns a proper dict. """ From 193656e71be15c6b84c4d22bccf6fcf184893da5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 4 Sep 2018 22:25:53 +0200 Subject: [PATCH 182/250] detect when EmbeddedDocumentListField receives an EmbeddedDocument instance instead of a list. It is a common mistake and the error wasn't meaningful (was fired from _from_son) (relates to #1464) --- mongoengine/base/fields.py | 7 ++++++- tests/fields/fields.py | 40 +++++++++++++++++++++++++++++++++++++- 2 files changed, 45 insertions(+), 2 deletions(-) diff --git a/mongoengine/base/fields.py b/mongoengine/base/fields.py index 69034d5d..906f7ff2 100644 --- a/mongoengine/base/fields.py +++ b/mongoengine/base/fields.py @@ -313,11 +313,16 @@ class ComplexBaseField(BaseField): 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 = {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 diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 362acec4..84877be3 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -3868,7 +3868,7 @@ class FieldTest(MongoDBTestCase): assert isinstance(doc.field, ToEmbedChild) assert doc.field == to_embed_child - def test_invalid_dict_value(self): + def test_dict_field_invalid_dict_value(self): class DictFieldTest(Document): dictionary = DictField(required=True) @@ -3882,6 +3882,22 @@ class FieldTest(MongoDBTestCase): 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_cls_field(self): class Animal(Document): meta = {'allow_inheritance': True} @@ -3980,6 +3996,28 @@ class EmbeddedDocumentListFieldTestCase(MongoDBTestCase): self.Comments(author='user3', message='message1') ]).save() + def test_fails_upon_validate_if_provide_a_doc_instead_of_a_list_of_doc(self): + # Relates to Issue #1464 + comment = self.Comments(author='John') + + class Title(Document): + content = StringField() + + # Test with an embeddedDocument instead of a list(embeddedDocument) + # It's an edge case but it used to fail with a vague error, making it difficult to troubleshoot it + post = self.BlogPost(comments=comment) + with self.assertRaises(ValidationError) as ctx_err: + post.validate() + self.assertIn("'comments'", str(ctx_err.exception)) + self.assertIn('Only lists and tuples may be used in a list field', str(ctx_err.exception)) + + # Test with a Document + post = self.BlogPost(comments=Title(content='garbage')) + with self.assertRaises(ValidationError) as e: + post.validate() + self.assertIn("'comments'", str(ctx_err.exception)) + self.assertIn('Only lists and tuples may be used in a list field', str(ctx_err.exception)) + def test_no_keyword_filter(self): """ Tests the filter method of a List of Embedded Documents From 282b83ac08a3b4cf680b6f81627187b7a08a2889 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 4 Sep 2018 23:48:07 +0200 Subject: [PATCH 183/250] Fix default value of ComplexDateTime + fixed descriptor .__get__ for class attribute --- mongoengine/base/fields.py | 3 +- mongoengine/fields.py | 20 ++- tests/fields/fields.py | 327 +++++++++++++++++++++---------------- 3 files changed, 199 insertions(+), 151 deletions(-) diff --git a/mongoengine/base/fields.py b/mongoengine/base/fields.py index 69034d5d..d25d4305 100644 --- a/mongoengine/base/fields.py +++ b/mongoengine/base/fields.py @@ -55,7 +55,7 @@ class BaseField(object): field. Generally this is deprecated in favour of the `FIELD.validate` method :param choices: (optional) The valid choices - :param null: (optional) Is the field value can be null. If no and there is a default value + :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 @@ -130,7 +130,6 @@ class BaseField(object): def __set__(self, instance, value): """Descriptor for assigning a value to a field in a document. """ - # If setting to None and there is a default # Then set the value to the default value if value is None: diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 6994b315..bc632ac9 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -562,11 +562,15 @@ class ComplexDateTimeField(StringField): The `,` as the separator can be easily modified by passing the `separator` keyword when initializing the field. + Note: To default the field to the current datetime, use: DateTimeField(default=datetime.utcnow) + .. versionadded:: 0.5 """ def __init__(self, separator=',', **kwargs): - self.names = ['year', 'month', 'day', 'hour', 'minute', 'second', 'microsecond'] + """ + :param separator: Allows to customize the separator used for storage (default ``,``) + """ self.separator = separator self.format = separator.join(['%Y', '%m', '%d', '%H', '%M', '%S', '%f']) super(ComplexDateTimeField, self).__init__(**kwargs) @@ -597,16 +601,20 @@ class ComplexDateTimeField(StringField): return datetime.datetime(*values) def __get__(self, instance, owner): + if instance is None: + return self + data = super(ComplexDateTimeField, self).__get__(instance, owner) - if data is None: - return None if self.null else datetime.datetime.now() - if isinstance(data, datetime.datetime): + + if isinstance(data, datetime.datetime) or data is None: return data return self._convert_from_string(data) def __set__(self, instance, value): - value = self._convert_from_datetime(value) if value else value - return super(ComplexDateTimeField, self).__set__(instance, value) + super(ComplexDateTimeField, self).__set__(instance, value) + value = instance._data[self.name] + if value is not None: + instance._data[self.name] = self._convert_from_datetime(value) def validate(self, value): value = self.to_python(value) diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 362acec4..4bfd7c74 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -264,12 +264,11 @@ class FieldTest(MongoDBTestCase): # Retrive data from db and verify it. ret = HandleNoneFields.objects.all()[0] - self.assertEqual(ret.str_fld, None) - self.assertEqual(ret.int_fld, None) - self.assertEqual(ret.flt_fld, None) + self.assertIsNone(ret.str_fld) + self.assertIsNone(ret.int_fld) + self.assertIsNone(ret.flt_fld) - # Return current time if retrived value is None. - self.assertTrue(isinstance(ret.comp_dt_fld, datetime.datetime)) + self.assertIsNone(ret.comp_dt_fld) def test_not_required_handles_none_from_database(self): """Ensure that every field can handle null values from the @@ -287,7 +286,7 @@ class FieldTest(MongoDBTestCase): doc.str_fld = u'spam ham egg' doc.int_fld = 42 doc.flt_fld = 4.2 - doc.com_dt_fld = datetime.datetime.utcnow() + doc.comp_dt_fld = datetime.datetime.utcnow() doc.save() # Unset all the fields @@ -302,12 +301,10 @@ class FieldTest(MongoDBTestCase): # Retrive data from db and verify it. ret = HandleNoneFields.objects.first() - self.assertEqual(ret.str_fld, None) - self.assertEqual(ret.int_fld, None) - self.assertEqual(ret.flt_fld, None) - - # ComplexDateTimeField returns current time if retrived value is None. - self.assertTrue(isinstance(ret.comp_dt_fld, datetime.datetime)) + self.assertIsNone(ret.str_fld) + self.assertIsNone(ret.int_fld) + self.assertIsNone(ret.flt_fld) + self.assertIsNone(ret.comp_dt_fld) # Retrieved object shouldn't pass validation when a re-save is # attempted. @@ -928,137 +925,6 @@ class FieldTest(MongoDBTestCase): logs = LogEntry.objects.filter(date__gte=datetime.datetime(1980, 1, 1)) self.assertEqual(logs.count(), 10) - 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_list_validation(self): """Ensure that a list field only accepts lists with valid elements.""" AccessLevelChoices = ( @@ -5389,5 +5255,180 @@ class GenericLazyReferenceFieldTest(MongoDBTestCase): check_fields_type(occ) +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) + + if __name__ == '__main__': unittest.main() From b15673c52566dbf1fb1f29005901fda35bd97373 Mon Sep 17 00:00:00 2001 From: Sergey Tereschenko Date: Wed, 5 Sep 2018 11:53:15 +0300 Subject: [PATCH 184/250] fixed TypeError on translated choices join expect strings, but if we use django ugettext_lazy like this: choices=[(1, _("One")), (2, _("Two"))] there will be TypeError: sequence item 0: expected string, __proxy__ found this commif fixes error by converting label to string --- mongoengine/base/document.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 85906a3e..aaf99ace 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -1091,6 +1091,6 @@ class BaseDocument(object): sep = getattr(field, 'display_sep', ' ') values = value if field.__class__.__name__ in ('ListField', 'SortedListField') else [value] return sep.join([ - dict(field.choices).get(val, val) + six.text_type(dict(field.choices).get(val, val)) for val in values or []]) return value From 003827e91600dc49c4504eba4cf4e419b406a820 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Thu, 6 Sep 2018 21:47:06 +0200 Subject: [PATCH 185/250] rewrote some poorly written assertions like: assertTrue(isinstance(a, b)) assertTrue(a==b) assertTrue(a!=b) assertTrue(a in b) --- tests/document/class_methods.py | 8 +- tests/document/delta.py | 4 +- tests/document/dynamic.py | 6 +- tests/document/indexes.py | 36 ++++----- tests/document/inheritance.py | 12 +-- tests/document/instance.py | 95 ++++++++++++----------- tests/document/validation.py | 28 +++---- tests/fields/fields.py | 67 ++++++++-------- tests/fields/file_tests.py | 18 ++--- tests/fields/geo.py | 16 ++-- tests/queryset/field_list.py | 2 +- tests/queryset/geo.py | 12 +-- tests/queryset/queryset.py | 131 ++++++++++++++++---------------- tests/queryset/transform.py | 34 ++++----- tests/queryset/visitor.py | 2 +- tests/test_connection.py | 60 +++++++-------- tests/test_context_managers.py | 24 +++--- tests/test_dereference.py | 48 ++++++------ 18 files changed, 298 insertions(+), 305 deletions(-) diff --git a/tests/document/class_methods.py b/tests/document/class_methods.py index 2fab1f72..5289e483 100644 --- a/tests/document/class_methods.py +++ b/tests/document/class_methods.py @@ -66,10 +66,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, self.db.collection_names()) self.Person.drop_collection() - self.assertFalse(collection_name in self.db.collection_names()) + self.assertNotIn(collection_name, self.db.collection_names()) def test_register_delete_rule(self): """Ensure that register delete rule adds a delete rule to the document @@ -340,7 +340,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, self.db.collection_names()) user_obj = self.db[collection_name].find_one() self.assertEqual(user_obj['name'], "Test User") @@ -349,7 +349,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, self.db.collection_names()) def test_collection_name_and_primary(self): """Ensure that a collection with a specified name may be used. diff --git a/tests/document/delta.py b/tests/document/delta.py index add4fe8d..30296956 100644 --- a/tests/document/delta.py +++ b/tests/document/delta.py @@ -694,7 +694,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) @@ -709,7 +709,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): diff --git a/tests/document/dynamic.py b/tests/document/dynamic.py index a478df42..94cea134 100644 --- a/tests/document/dynamic.py +++ b/tests/document/dynamic.py @@ -174,8 +174,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()) @@ -189,7 +189,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""" diff --git a/tests/document/indexes.py b/tests/document/indexes.py index 58e09199..1cbb4ec3 100644 --- a/tests/document/indexes.py +++ b/tests/document/indexes.py @@ -70,7 +70,7 @@ class IndexesTest(unittest.TestCase): self.assertEqual(len(info), 4) info = [value['key'] for key, value in info.iteritems()] for expected in expected_specs: - self.assertTrue(expected['fields'] in info) + self.assertIn(expected['fields'], info) def _index_test_inheritance(self, InheritFrom): @@ -102,7 +102,7 @@ class IndexesTest(unittest.TestCase): self.assertEqual(len(info), 4) info = [value['key'] for key, value in info.iteritems()] for expected in expected_specs: - self.assertTrue(expected['fields'] in info) + self.assertIn(expected['fields'], info) class ExtendedBlogPost(BlogPost): title = StringField() @@ -117,7 +117,7 @@ class IndexesTest(unittest.TestCase): info = ExtendedBlogPost.objects._collection.index_information() info = [value['key'] for key, value in info.iteritems()] 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 @@ -226,7 +226,7 @@ class IndexesTest(unittest.TestCase): 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) + self.assertIn([('rank.title', 1)], info) def test_explicit_geo2d_index(self): """Ensure that geo2d indexes work when created via meta[indexes] @@ -246,7 +246,7 @@ 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) + self.assertIn([('location.point', '2d')], info) def test_explicit_geo2d_index_embedded(self): """Ensure that geo2d indexes work when created via meta[indexes] @@ -269,7 +269,7 @@ 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) + self.assertIn([('current.location.point', '2d')], info) def test_explicit_geosphere_index(self): """Ensure that geosphere indexes work when created via meta[indexes] @@ -289,7 +289,7 @@ 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', '2dsphere')] in info) + self.assertIn([('location.point', '2dsphere')], info) def test_explicit_geohaystack_index(self): """Ensure that geohaystack indexes work when created via meta[indexes] @@ -311,7 +311,7 @@ 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', 'geoHaystack')] in info) + self.assertIn([('location.point', 'geoHaystack')], info) def test_create_geohaystack_index(self): """Ensure that geohaystack indexes can be created @@ -323,7 +323,7 @@ class IndexesTest(unittest.TestCase): Place.create_index({'fields': (')location.point', 'name')}, bucketSize=10) info = Place._get_collection().index_information() info = [value['key'] for key, value in info.iteritems()] - self.assertTrue([('location.point', 'geoHaystack'), ('name', 1)] in info) + self.assertIn([('location.point', 'geoHaystack'), ('name', 1)], info) def test_dictionary_indexes(self): """Ensure that indexes are used when meta[indexes] contains @@ -356,7 +356,7 @@ class IndexesTest(unittest.TestCase): value.get('unique', False), value.get('sparse', False)) for key, value in info.iteritems()] - self.assertTrue(([('addDate', -1)], True, True) in info) + self.assertIn(([('addDate', -1)], True, True), info) BlogPost.drop_collection() @@ -803,7 +803,7 @@ class IndexesTest(unittest.TestCase): info = BlogPost.objects._collection.index_information() info = [value['key'] for key, value in info.iteritems()] 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): @@ -850,8 +850,8 @@ class IndexesTest(unittest.TestCase): info = MyDoc.objects._collection.index_information() info = [value['key'] for key, value in info.iteritems()] - self.assertTrue([('provider_ids.foo', 1)] in info) - self.assertTrue([('provider_ids.bar', 1)] in info) + self.assertIn([('provider_ids.foo', 1)], info) + self.assertIn([('provider_ids.bar', 1)], info) def test_sparse_compound_indexes(self): @@ -876,9 +876,9 @@ class IndexesTest(unittest.TestCase): } indexes = Book.objects._collection.index_information() - self.assertTrue("title_text" in indexes) + self.assertIn("title_text", indexes) key = indexes["title_text"]["key"] - self.assertTrue(('_fts', 'text') in key) + self.assertIn(('_fts', 'text'), key) def test_hashed_indexes(self): @@ -889,8 +889,8 @@ class IndexesTest(unittest.TestCase): } indexes = Book.objects._collection.index_information() - self.assertTrue("ref_id_hashed" in indexes) - self.assertTrue(('ref_id', 'hashed') in indexes["ref_id_hashed"]["key"]) + self.assertIn("ref_id_hashed", indexes) + self.assertIn(('ref_id', 'hashed'), indexes["ref_id_hashed"]["key"]) def test_indexes_after_database_drop(self): """ @@ -1013,7 +1013,7 @@ class IndexesTest(unittest.TestCase): TestDoc.ensure_indexes() index_info = TestDoc._get_collection().index_information() - self.assertTrue('shard_1_1__cls_1_txt_1_1' in index_info) + self.assertIn('shard_1_1__cls_1_txt_1_1', index_info) if __name__ == '__main__': diff --git a/tests/document/inheritance.py b/tests/document/inheritance.py index 2897e1d1..b2ab1b52 100644 --- a/tests/document/inheritance.py +++ b/tests/document/inheritance.py @@ -268,7 +268,7 @@ 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. @@ -298,7 +298,7 @@ class InheritanceTest(unittest.TestCase): # 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_abstract_handle_ids_in_metaclass_properly(self): @@ -374,14 +374,14 @@ class InheritanceTest(unittest.TestCase): pass 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 @@ -434,8 +434,8 @@ class InheritanceTest(unittest.TestCase): 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) diff --git a/tests/document/instance.py b/tests/document/instance.py index cffe4f30..e637b3e6 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -357,7 +357,7 @@ class InstanceTest(MongoDBTestCase): user_son = User.objects._collection.find_one() self.assertEqual(user_son['_id'], 'test') - self.assertTrue('username' not in user_son['_id']) + self.assertNotIn('username', user_son['_id']) User.drop_collection() @@ -370,7 +370,7 @@ class InstanceTest(MongoDBTestCase): user_son = User.objects._collection.find_one() self.assertEqual(user_son['_id'], 'mongo') - self.assertTrue('username' not in user_son['_id']) + self.assertNotIn('username', user_son['_id']) def test_document_not_registered(self): class Place(Document): @@ -594,10 +594,10 @@ class InstanceTest(MongoDBTestCase): # Length = length(assigned fields + id) self.assertEqual(len(person), 5) - self.assertTrue('age' in person) + self.assertIn('age', person) person.age = None - self.assertFalse('age' in person) - self.assertFalse('nationality' in person) + self.assertNotIn('age', person) + self.assertNotIn('nationality', person) def test_embedded_document_to_mongo(self): class Person(EmbeddedDocument): @@ -627,8 +627,8 @@ class InstanceTest(MongoDBTestCase): class Comment(EmbeddedDocument): content = StringField() - self.assertTrue('content' in Comment._fields) - self.assertFalse('id' in Comment._fields) + self.assertIn('content', Comment._fields) + self.assertNotIn('id', Comment._fields) def test_embedded_document_instance(self): """Ensure that embedded documents can reference parent instance.""" @@ -1455,9 +1455,9 @@ class InstanceTest(MongoDBTestCase): user = User.objects.first() # Even if stored as ObjectId's internally mongoengine uses DBRefs # As ObjectId's aren't automatically derefenced - self.assertTrue(isinstance(user._data['orgs'][0], DBRef)) - self.assertTrue(isinstance(user.orgs[0], Organization)) - self.assertTrue(isinstance(user._data['orgs'][0], Organization)) + self.assertIsInstance(user._data['orgs'][0], DBRef) + self.assertIsInstance(user.orgs[0], Organization) + self.assertIsInstance(user._data['orgs'][0], Organization) # Changing a value with query_counter() as q: @@ -1837,9 +1837,8 @@ class InstanceTest(MongoDBTestCase): post_obj = BlogPost.objects.first() # Test laziness - self.assertTrue(isinstance(post_obj._data['author'], - bson.DBRef)) - self.assertTrue(isinstance(post_obj.author, self.Person)) + self.assertIsInstance(post_obj._data['author'], bson.DBRef) + self.assertIsInstance(post_obj.author, self.Person) self.assertEqual(post_obj.author.name, 'Test User') # Ensure that the dereferenced object may be changed and saved @@ -2245,12 +2244,12 @@ class InstanceTest(MongoDBTestCase): # Make sure docs are properly identified in a list (__eq__ is used # for the comparison). all_user_list = list(User.objects.all()) - self.assertTrue(u1 in all_user_list) - self.assertTrue(u2 in all_user_list) - self.assertTrue(u3 in all_user_list) - self.assertTrue(u4 not in all_user_list) # New object - self.assertTrue(b1 not in all_user_list) # Other object - self.assertTrue(b2 not in all_user_list) # Other object + self.assertIn(u1, all_user_list) + self.assertIn(u2, all_user_list) + self.assertIn(u3, all_user_list) + self.assertNotIn(u4, all_user_list) # New object + self.assertNotIn(b1, all_user_list) # Other object + self.assertNotIn(b2, all_user_list) # Other object # Make sure docs can be used as keys in a dict (__hash__ is used # for hashing the docs). @@ -2268,10 +2267,10 @@ class InstanceTest(MongoDBTestCase): # Make sure docs are properly identified in a set (__hash__ is used # for hashing the docs). all_user_set = set(User.objects.all()) - self.assertTrue(u1 in all_user_set) - self.assertTrue(u4 not in all_user_set) - self.assertTrue(b1 not in all_user_list) - self.assertTrue(b2 not in all_user_list) + self.assertIn(u1, all_user_set) + self.assertNotIn(u4, all_user_set) + self.assertNotIn(b1, all_user_list) + self.assertNotIn(b2, all_user_list) # Make sure duplicate docs aren't accepted in the set self.assertEqual(len(all_user_set), 3) @@ -2972,7 +2971,7 @@ class InstanceTest(MongoDBTestCase): Person(name="Harry Potter").save() person = Person.objects.first() - self.assertTrue('id' in person._data.keys()) + self.assertIn('id', person._data.keys()) self.assertEqual(person._data.get('id'), person.id) def test_complex_nesting_document_and_embedded_document(self): @@ -3064,36 +3063,36 @@ class InstanceTest(MongoDBTestCase): dbref2 = f._data['test2'] obj2 = f.test2 - self.assertTrue(isinstance(dbref2, DBRef)) - self.assertTrue(isinstance(obj2, Test2)) - self.assertTrue(obj2.id == dbref2.id) - self.assertTrue(obj2 == dbref2) - self.assertTrue(dbref2 == obj2) + self.assertIsInstance(dbref2, DBRef) + self.assertIsInstance(obj2, Test2) + self.assertEqual(obj2.id, dbref2.id) + self.assertEqual(obj2, dbref2) + self.assertEqual(dbref2, obj2) dbref3 = f._data['test3'] obj3 = f.test3 - self.assertTrue(isinstance(dbref3, DBRef)) - self.assertTrue(isinstance(obj3, Test3)) - self.assertTrue(obj3.id == dbref3.id) - self.assertTrue(obj3 == dbref3) - self.assertTrue(dbref3 == obj3) + self.assertIsInstance(dbref3, DBRef) + self.assertIsInstance(obj3, Test3) + self.assertEqual(obj3.id, dbref3.id) + self.assertEqual(obj3, dbref3) + self.assertEqual(dbref3, obj3) - self.assertTrue(obj2.id == obj3.id) - self.assertTrue(dbref2.id == dbref3.id) - self.assertFalse(dbref2 == dbref3) - self.assertFalse(dbref3 == dbref2) - self.assertTrue(dbref2 != dbref3) - self.assertTrue(dbref3 != dbref2) + self.assertEqual(obj2.id, obj3.id) + self.assertEqual(dbref2.id, dbref3.id) + self.assertNotEqual(dbref2, dbref3) + self.assertNotEqual(dbref3, dbref2) + self.assertNotEqual(dbref2, dbref3) + self.assertNotEqual(dbref3, dbref2) - self.assertFalse(obj2 == dbref3) - self.assertFalse(dbref3 == obj2) - self.assertTrue(obj2 != dbref3) - self.assertTrue(dbref3 != obj2) + self.assertNotEqual(obj2, dbref3) + self.assertNotEqual(dbref3, obj2) + self.assertNotEqual(obj2, dbref3) + self.assertNotEqual(dbref3, obj2) - self.assertFalse(obj3 == dbref2) - self.assertFalse(dbref2 == obj3) - self.assertTrue(obj3 != dbref2) - self.assertTrue(dbref2 != obj3) + self.assertNotEqual(obj3, dbref2) + self.assertNotEqual(dbref2, obj3) + self.assertNotEqual(obj3, dbref2) + self.assertNotEqual(dbref2, obj3) def test_default_values(self): class Person(Document): diff --git a/tests/document/validation.py b/tests/document/validation.py index 105bc8b0..30a285b2 100644 --- a/tests/document/validation.py +++ b/tests/document/validation.py @@ -20,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 @@ -40,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') @@ -58,7 +58,7 @@ class ValidatorErrorTest(unittest.TestCase): try: User().validate() except ValidationError as e: - self.assertTrue("User:None" in e.message) + self.assertIn("User:None", e.message) self.assertEqual(e.to_dict(), { 'username': 'Field is required', 'name': 'Field is required'}) @@ -68,7 +68,7 @@ class ValidatorErrorTest(unittest.TestCase): try: user.save() except ValidationError as e: - self.assertTrue("User:RossC0" in e.message) + self.assertIn("User:RossC0", e.message) self.assertEqual(e.to_dict(), { 'name': 'Field is required'}) @@ -116,7 +116,7 @@ class ValidatorErrorTest(unittest.TestCase): try: Doc(id="bad").validate() except ValidationError as e: - self.assertTrue("SubDoc:None" in e.message) + self.assertIn("SubDoc:None", e.message) self.assertEqual(e.to_dict(), { "e": {'val': 'OK could not be converted to int'}}) @@ -127,14 +127,14 @@ 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 as e: - self.assertTrue("Doc:test" in e.message) + self.assertIn("Doc:test", e.message) self.assertEqual(e.to_dict(), { "e": {'val': 'OK could not be converted to int'}}) diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 4bfd7c74..d6df061d 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -175,7 +175,7 @@ class FieldTest(MongoDBTestCase): self.assertEqual(person.name, None) self.assertEqual(person.age, 30) self.assertEqual(person.userid, 'test') - self.assertTrue(isinstance(person.created, datetime.datetime)) + self.assertIsInstance(person.created, datetime.datetime) self.assertEqual(person._data['name'], person.name) self.assertEqual(person._data['age'], person.age) @@ -211,7 +211,7 @@ class FieldTest(MongoDBTestCase): self.assertEqual(person.name, None) self.assertEqual(person.age, 30) self.assertEqual(person.userid, 'test') - self.assertTrue(isinstance(person.created, datetime.datetime)) + self.assertIsInstance(person.created, datetime.datetime) self.assertNotEqual(person.created, datetime.datetime(2014, 6, 12)) self.assertEqual(person._data['name'], person.name) @@ -1602,8 +1602,8 @@ class FieldTest(MongoDBTestCase): e.save() e2 = Simple.objects.get(id=e.id) - self.assertTrue(isinstance(e2.mapping[0], StringSetting)) - self.assertTrue(isinstance(e2.mapping[1], IntegerSetting)) + self.assertIsInstance(e2.mapping[0], StringSetting) + self.assertIsInstance(e2.mapping[1], IntegerSetting) # Test querying self.assertEqual( @@ -1772,8 +1772,8 @@ class FieldTest(MongoDBTestCase): e.save() e2 = Simple.objects.get(id=e.id) - self.assertTrue(isinstance(e2.mapping['somestring'], StringSetting)) - self.assertTrue(isinstance(e2.mapping['someint'], IntegerSetting)) + self.assertIsInstance(e2.mapping['somestring'], StringSetting) + self.assertIsInstance(e2.mapping['someint'], IntegerSetting) # Test querying self.assertEqual( @@ -1857,8 +1857,8 @@ class FieldTest(MongoDBTestCase): e.save() e2 = Extensible.objects.get(id=e.id) - self.assertTrue(isinstance(e2.mapping['somestring'], StringSetting)) - self.assertTrue(isinstance(e2.mapping['someint'], IntegerSetting)) + self.assertIsInstance(e2.mapping['somestring'], StringSetting) + self.assertIsInstance(e2.mapping['someint'], IntegerSetting) with self.assertRaises(ValidationError): e.mapping['someint'] = 123 @@ -2563,7 +2563,7 @@ class FieldTest(MongoDBTestCase): bm = Bookmark.objects(bookmark_object=post_1).first() self.assertEqual(bm.bookmark_object, post_1) - self.assertTrue(isinstance(bm.bookmark_object, Post)) + self.assertIsInstance(bm.bookmark_object, Post) bm.bookmark_object = link_1 bm.save() @@ -2571,7 +2571,7 @@ class FieldTest(MongoDBTestCase): bm = Bookmark.objects(bookmark_object=link_1).first() self.assertEqual(bm.bookmark_object, link_1) - self.assertTrue(isinstance(bm.bookmark_object, Link)) + self.assertIsInstance(bm.bookmark_object, Link) def test_generic_reference_list(self): """Ensure that a ListField properly dereferences generic references. @@ -2818,7 +2818,7 @@ class FieldTest(MongoDBTestCase): doc1 = Doc.objects.create() doc2 = Doc.objects.create(ref=doc1) - self.assertTrue(isinstance(doc1.pk, ObjectId)) + self.assertIsInstance(doc1.pk, ObjectId) doc = Doc.objects.get(ref=doc1.pk) self.assertEqual(doc, doc2) @@ -3421,13 +3421,13 @@ class FieldTest(MongoDBTestCase): person.save() person = Person.objects.first() - self.assertTrue(isinstance(person.like, Car)) + self.assertIsInstance(person.like, Car) person.like = Dish(food="arroz", number=15) person.save() person = Person.objects.first() - self.assertTrue(isinstance(person.like, Dish)) + self.assertIsInstance(person.like, Dish) def test_generic_embedded_document_choices(self): """Ensure you can limit GenericEmbeddedDocument choices.""" @@ -3452,7 +3452,7 @@ class FieldTest(MongoDBTestCase): person.save() person = Person.objects.first() - self.assertTrue(isinstance(person.like, Dish)) + self.assertIsInstance(person.like, Dish) def test_generic_list_embedded_document_choices(self): """Ensure you can limit GenericEmbeddedDocument choices inside @@ -3479,7 +3479,7 @@ class FieldTest(MongoDBTestCase): person.save() person = Person.objects.first() - self.assertTrue(isinstance(person.likes[0], Dish)) + self.assertIsInstance(person.likes[0], Dish) def test_recursive_validation(self): """Ensure that a validation result to_dict is available.""" @@ -3505,18 +3505,17 @@ class FieldTest(MongoDBTestCase): except ValidationError as error: # ValidationError.errors property self.assertTrue(hasattr(error, 'errors')) - self.assertTrue(isinstance(error.errors, dict)) - self.assertTrue('comments' in error.errors) - self.assertTrue(1 in error.errors['comments']) - self.assertTrue(isinstance(error.errors['comments'][1]['content'], - ValidationError)) + self.assertIsInstance(error.errors, dict) + self.assertIn('comments', error.errors) + self.assertIn(1, error.errors['comments']) + self.assertIsInstance(error.errors['comments'][1]['content'], ValidationError) # ValidationError.schema property error_dict = error.to_dict() - self.assertTrue(isinstance(error_dict, dict)) - self.assertTrue('comments' in error_dict) - self.assertTrue(1 in error_dict['comments']) - self.assertTrue('content' in error_dict['comments'][1]) + self.assertIsInstance(error_dict, dict) + self.assertIn('comments', error_dict) + self.assertIn(1, error_dict['comments']) + self.assertIn('content', error_dict['comments'][1]) self.assertEqual(error_dict['comments'][1]['content'], u'Field is required') @@ -3632,7 +3631,7 @@ class FieldTest(MongoDBTestCase): # Passes regex validation user = User(email='me@example.com') - self.assertTrue(user.validate() is None) + self.assertIsNone(user.validate()) def test_tuples_as_tuples(self): """Ensure that tuples remain tuples when they are inside @@ -3659,10 +3658,10 @@ class FieldTest(MongoDBTestCase): doc.items = tuples doc.save() x = TestDoc.objects().get() - self.assertTrue(x is not None) - self.assertTrue(len(x.items) == 1) - self.assertTrue(tuple(x.items[0]) in tuples) - self.assertTrue(x.items[0] in tuples) + self.assertIsNotNone(x) + self.assertEqual(len(x.items), 1) + self.assertIn(tuple(x.items[0]), tuples) + self.assertIn(x.items[0], tuples) def test_dynamic_fields_class(self): class Doc2(Document): @@ -3812,8 +3811,8 @@ class FieldTest(MongoDBTestCase): doc = TestLongFieldConsideredAsInt64(some_long=42).save() db = get_db() - self.assertTrue(isinstance(db.test_long_field_considered_as_int64.find()[0]['some_long'], Int64)) - self.assertTrue(isinstance(doc.some_long, six.integer_types)) + self.assertIsInstance(db.test_long_field_considered_as_int64.find()[0]['some_long'], Int64) + self.assertIsInstance(doc.some_long, six.integer_types) class EmbeddedDocumentListFieldTestCase(MongoDBTestCase): @@ -4364,7 +4363,7 @@ class CachedReferenceFieldTest(MongoDBTestCase): ocorrence = Ocorrence.objects(animal__tag='heavy').first() self.assertEqual(ocorrence.person, "teste") - self.assertTrue(isinstance(ocorrence.animal, Animal)) + self.assertIsInstance(ocorrence.animal, Animal) def test_cached_reference_field_decimal(self): class PersonAuto(Document): @@ -4681,7 +4680,7 @@ class CachedReferenceFieldTest(MongoDBTestCase): animal__tag='heavy', animal__owner__tp='u').first() self.assertEqual(ocorrence.person, "teste") - self.assertTrue(isinstance(ocorrence.animal, Animal)) + self.assertIsInstance(ocorrence.animal, Animal) def test_cached_reference_embedded_list_fields(self): class Owner(EmbeddedDocument): @@ -4735,7 +4734,7 @@ class CachedReferenceFieldTest(MongoDBTestCase): animal__tag='heavy', animal__owner__tags='cool').first() self.assertEqual(ocorrence.person, "teste 2") - self.assertTrue(isinstance(ocorrence.animal, Animal)) + self.assertIsInstance(ocorrence.animal, Animal) class LazyReferenceFieldTest(MongoDBTestCase): diff --git a/tests/fields/file_tests.py b/tests/fields/file_tests.py index 841e7c7d..213e889c 100644 --- a/tests/fields/file_tests.py +++ b/tests/fields/file_tests.py @@ -53,7 +53,7 @@ class FileTest(MongoDBTestCase): putfile.save() result = PutFile.objects.first() - self.assertTrue(putfile == result) + self.assertEqual(putfile, result) self.assertEqual("%s" % result.the_file, "" % result.the_file.grid_id) self.assertEqual(result.the_file.read(), text) self.assertEqual(result.the_file.content_type, content_type) @@ -71,7 +71,7 @@ class FileTest(MongoDBTestCase): 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() @@ -96,7 +96,7 @@ class FileTest(MongoDBTestCase): 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) @@ -132,7 +132,7 @@ class FileTest(MongoDBTestCase): 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) @@ -161,7 +161,7 @@ class FileTest(MongoDBTestCase): 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 @@ -169,7 +169,7 @@ class FileTest(MongoDBTestCase): 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() @@ -231,8 +231,8 @@ class FileTest(MongoDBTestCase): 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() @@ -291,7 +291,7 @@ class FileTest(MongoDBTestCase): 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 """ diff --git a/tests/fields/geo.py b/tests/fields/geo.py index 1c5bccc0..754f4203 100644 --- a/tests/fields/geo.py +++ b/tests/fields/geo.py @@ -298,9 +298,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. @@ -316,9 +316,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): @@ -335,9 +335,9 @@ class GeoFieldTest(unittest.TestCase): Parent(name='Berlin').save() info = Parent._get_collection().index_information() - self.assertFalse('location_2d' in info) + self.assertNotIn('location_2d', info) info = Location._get_collection().index_information() - self.assertTrue('location_2d' in info) + self.assertIn('location_2d', info) self.assertEqual(len(Parent._geo_indices()), 0) self.assertEqual(len(Location._geo_indices()), 1) diff --git a/tests/queryset/field_list.py b/tests/queryset/field_list.py index c07cec3e..b111238a 100644 --- a/tests/queryset/field_list.py +++ b/tests/queryset/field_list.py @@ -181,7 +181,7 @@ class OnlyExcludeAllTest(unittest.TestCase): employee.save() obj = self.Person.objects(id=employee.id).only('age').get() - self.assertTrue(isinstance(obj, Employee)) + self.assertIsInstance(obj, Employee) # Check field names are looked up properly obj = Employee.objects(id=employee.id).only('salary').get() diff --git a/tests/queryset/geo.py b/tests/queryset/geo.py index 38c0377e..fea225b2 100644 --- a/tests/queryset/geo.py +++ b/tests/queryset/geo.py @@ -95,9 +95,9 @@ class GeoQueriesTest(MongoDBTestCase): location__within_distance=point_and_distance) self.assertEqual(events.count(), 2) events = list(events) - self.assertTrue(event2 not in events) - self.assertTrue(event1 in events) - self.assertTrue(event3 in events) + self.assertNotIn(event2, events) + self.assertIn(event1, events) + self.assertIn(event3, events) # find events within 10 degrees of san francisco point_and_distance = [[-122.415579, 37.7566023], 10] @@ -285,9 +285,9 @@ class GeoQueriesTest(MongoDBTestCase): location__geo_within_center=point_and_distance) self.assertEqual(events.count(), 2) events = list(events) - self.assertTrue(event2 not in events) - self.assertTrue(event1 in events) - self.assertTrue(event3 in events) + self.assertNotIn(event2, events) + self.assertIn(event1, events) + self.assertIn(event3, events) def _test_embedded(self, point_field_class): """Helper test method ensuring given point field class works diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index c6aa3594..16268cbf 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -59,11 +59,10 @@ class QuerySetTest(unittest.TestCase): def test_initialisation(self): """Ensure that a QuerySet is correctly initialised by QuerySetManager. """ - self.assertTrue(isinstance(self.Person.objects, QuerySet)) + self.assertIsInstance(self.Person.objects, QuerySet) self.assertEqual(self.Person.objects._collection.name, self.Person._get_collection_name()) - self.assertTrue(isinstance(self.Person.objects._collection, - pymongo.collection.Collection)) + self.assertIsInstance(self.Person.objects._collection, pymongo.collection.Collection) def test_cannot_perform_joins_references(self): @@ -89,8 +88,8 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(people.count(), 2) results = list(people) - self.assertTrue(isinstance(results[0], self.Person)) - self.assertTrue(isinstance(results[0].id, (ObjectId, str, unicode))) + self.assertIsInstance(results[0], self.Person) + self.assertIsInstance(results[0].id, (ObjectId, str, unicode)) self.assertEqual(results[0], user_a) self.assertEqual(results[0].name, 'User A') @@ -225,7 +224,7 @@ class QuerySetTest(unittest.TestCase): # Retrieve the first person from the database person = self.Person.objects.first() - self.assertTrue(isinstance(person, self.Person)) + self.assertIsInstance(person, self.Person) self.assertEqual(person.name, "User A") self.assertEqual(person.age, 20) @@ -672,13 +671,13 @@ class QuerySetTest(unittest.TestCase): result = self.Person(name="Bob", age=25).update( upsert=True, full_result=True) - self.assertTrue(isinstance(result, UpdateResult)) - self.assertTrue("upserted" in result.raw_result) + self.assertIsInstance(result, UpdateResult) + self.assertIn("upserted", result.raw_result) self.assertFalse(result.raw_result["updatedExisting"]) bob = self.Person.objects.first() result = bob.update(set__age=30, full_result=True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertTrue(result.raw_result["updatedExisting"]) self.Person(name="Bob", age=20).save() @@ -994,7 +993,7 @@ class QuerySetTest(unittest.TestCase): # Retrieve the first person from the database person = self.Person.objects.slave_okay(True).first() - self.assertTrue(isinstance(person, self.Person)) + self.assertIsInstance(person, self.Person) self.assertEqual(person.name, "User A") self.assertEqual(person.age, 20) @@ -1061,10 +1060,10 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(docs.count(), 1000) docs_string = "%s" % docs - self.assertTrue("Doc: 0" in docs_string) + self.assertIn("Doc: 0", docs_string) self.assertEqual(docs.count(), 1000) - self.assertTrue('(remaining elements truncated)' in "%s" % docs) + self.assertIn('(remaining elements truncated)', "%s" % docs) # Limit and skip docs = docs[1:4] @@ -1281,7 +1280,7 @@ class QuerySetTest(unittest.TestCase): with db_ops_tracker() as q: BlogPost.objects.filter(title='whatever').order_by().first() self.assertEqual(len(q.get_ops()), 1) - self.assertFalse('$orderby' in q.get_ops()[0]['query']) + self.assertNotIn('$orderby', q.get_ops()[0]['query']) # calling an explicit order_by should use a specified sort with db_ops_tracker() as q: @@ -1297,7 +1296,7 @@ class QuerySetTest(unittest.TestCase): qs = BlogPost.objects.filter(title='whatever').order_by('published_date') qs.order_by().first() self.assertEqual(len(q.get_ops()), 1) - self.assertFalse('$orderby' in q.get_ops()[0]['query']) + self.assertNotIn('$orderby', q.get_ops()[0]['query']) def test_no_ordering_for_get(self): """ Ensure that Doc.objects.get doesn't use any ordering. @@ -1316,13 +1315,13 @@ class QuerySetTest(unittest.TestCase): with db_ops_tracker() as q: BlogPost.objects.get(title='whatever') self.assertEqual(len(q.get_ops()), 1) - self.assertFalse('$orderby' in q.get_ops()[0]['query']) + self.assertNotIn('$orderby', q.get_ops()[0]['query']) # Ordering should be ignored for .get even if we set it explicitly with db_ops_tracker() as q: BlogPost.objects.order_by('-title').get(title='whatever') self.assertEqual(len(q.get_ops()), 1) - self.assertFalse('$orderby' in q.get_ops()[0]['query']) + self.assertNotIn('$orderby', q.get_ops()[0]['query']) def test_find_embedded(self): """Ensure that an embedded document is properly returned from @@ -1344,15 +1343,15 @@ class QuerySetTest(unittest.TestCase): ) result = BlogPost.objects.first() - self.assertTrue(isinstance(result.author, User)) + self.assertIsInstance(result.author, User) self.assertEqual(result.author.name, 'Test User') result = BlogPost.objects.get(author__name=user.name) - self.assertTrue(isinstance(result.author, User)) + self.assertIsInstance(result.author, User) self.assertEqual(result.author.name, 'Test User') result = BlogPost.objects.get(author={'name': user.name}) - self.assertTrue(isinstance(result.author, User)) + self.assertIsInstance(result.author, User) self.assertEqual(result.author.name, 'Test User') # Fails, since the string is not a type that is able to represent the @@ -1470,7 +1469,7 @@ class QuerySetTest(unittest.TestCase): code_chunks = ['doc["cmnts"];', 'doc["doc-name"],', 'doc["cmnts"][i]["body"]'] for chunk in code_chunks: - self.assertTrue(chunk in sub_code) + self.assertIn(chunk, sub_code) results = BlogPost.objects.exec_js(code) expected_results = [ @@ -1937,11 +1936,12 @@ class QuerySetTest(unittest.TestCase): # ListField operator BlogPost.objects.update(push__tags='mongo') post.reload() - self.assertTrue('mongo' in post.tags) + self.assertIn('mongo', post.tags) BlogPost.objects.update_one(push_all__tags=['db', 'nosql']) post.reload() - self.assertTrue('db' in post.tags and 'nosql' in post.tags) + self.assertIn('db', post.tags) + self.assertIn('nosql', post.tags) tags = post.tags[:-1] BlogPost.objects.update(pop__tags=1) @@ -3274,8 +3274,8 @@ class QuerySetTest(unittest.TestCase): News.drop_collection() info = News.objects._collection.index_information() - self.assertTrue('title_text_content_text' in info) - self.assertTrue('textIndexVersion' in info['title_text_content_text']) + self.assertIn('title_text_content_text', info) + self.assertIn('textIndexVersion', info['title_text_content_text']) News(title="Neymar quebrou a vertebra", content="O Brasil sofre com a perda de Neymar").save() @@ -3309,15 +3309,15 @@ class QuerySetTest(unittest.TestCase): '$search': 'dilma', '$language': 'pt'}, 'is_active': False}) - self.assertEqual(new.is_active, False) - self.assertTrue('dilma' in new.content) - self.assertTrue('planejamento' in new.title) + self.assertFalse(new.is_active) + self.assertIn('dilma', new.content) + self.assertIn('planejamento', new.title) query = News.objects.search_text("candidata") self.assertEqual(query._search_text, "candidata") new = query.first() - self.assertTrue(isinstance(new.get_text_score(), float)) + self.assertIsInstance(new.get_text_score(), float) # count query = News.objects.search_text('brasil').order_by('$text_score') @@ -3612,7 +3612,7 @@ class QuerySetTest(unittest.TestCase): Group.objects(id=group.id).update(set__members=[user1, user2]) group.reload() - self.assertTrue(len(group.members) == 2) + self.assertEqual(len(group.members), 2) self.assertEqual(group.members[0].name, user1.name) self.assertEqual(group.members[1].name, user2.name) @@ -3643,13 +3643,13 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(len(objects), 3) - self.assertTrue(post_1.id in objects) - self.assertTrue(post_2.id in objects) - self.assertTrue(post_5.id in objects) + self.assertIn(post_1.id, objects) + self.assertIn(post_2.id, objects) + self.assertIn(post_5.id, objects) - self.assertTrue(objects[post_1.id].title == post_1.title) - self.assertTrue(objects[post_2.id].title == post_2.title) - self.assertTrue(objects[post_5.id].title == post_5.title) + self.assertEqual(objects[post_1.id].title, post_1.title) + self.assertEqual(objects[post_2.id].title, post_2.title) + self.assertEqual(objects[post_5.id].title, post_5.title) BlogPost.drop_collection() @@ -3669,7 +3669,7 @@ class QuerySetTest(unittest.TestCase): Post.drop_collection() - self.assertTrue(isinstance(Post.objects, CustomQuerySet)) + self.assertIsInstance(Post.objects, CustomQuerySet) self.assertFalse(Post.objects.not_empty()) Post().save() @@ -3694,7 +3694,7 @@ class QuerySetTest(unittest.TestCase): Post.drop_collection() - self.assertTrue(isinstance(Post.objects, CustomQuerySet)) + self.assertIsInstance(Post.objects, CustomQuerySet) self.assertFalse(Post.objects.not_empty()) Post().save() @@ -3741,7 +3741,7 @@ class QuerySetTest(unittest.TestCase): pass Post.drop_collection() - self.assertTrue(isinstance(Post.objects, CustomQuerySet)) + self.assertIsInstance(Post.objects, CustomQuerySet) self.assertFalse(Post.objects.not_empty()) Post().save() @@ -3769,7 +3769,7 @@ class QuerySetTest(unittest.TestCase): pass Post.drop_collection() - self.assertTrue(isinstance(Post.objects, CustomQuerySet)) + self.assertIsInstance(Post.objects, CustomQuerySet) self.assertFalse(Post.objects.not_empty()) Post().save() @@ -3860,17 +3860,17 @@ class QuerySetTest(unittest.TestCase): test = Number.objects test2 = test.clone() - self.assertFalse(test == test2) + self.assertNotEqual(test, test2) self.assertEqual(test.count(), test2.count()) test = test.filter(n__gt=11) test2 = test.clone() - self.assertFalse(test == test2) + self.assertNotEqual(test, test2) self.assertEqual(test.count(), test2.count()) test = test.limit(10) test2 = test.clone() - self.assertFalse(test == test2) + self.assertNotEqual(test, test2) self.assertEqual(test.count(), test2.count()) Number.drop_collection() @@ -3960,7 +3960,7 @@ class QuerySetTest(unittest.TestCase): value.get('unique', False), value.get('sparse', False)) for key, value in info.iteritems()] - self.assertTrue(([('_cls', 1), ('message', 1)], False, False) in info) + self.assertIn(([('_cls', 1), ('message', 1)], False, False), info) def test_where(self): """Ensure that where clauses work. @@ -3984,13 +3984,13 @@ class QuerySetTest(unittest.TestCase): 'this["fielda"] >= this["fieldb"]', query._where_clause) results = list(query) self.assertEqual(2, len(results)) - self.assertTrue(a in results) - self.assertTrue(c in results) + self.assertIn(a, results) + self.assertIn(c, results) query = IntPair.objects.where('this[~fielda] == this[~fieldb]') results = list(query) self.assertEqual(1, len(results)) - self.assertTrue(a in results) + self.assertIn(a, results) query = IntPair.objects.where( 'function() { return this[~fielda] >= this[~fieldb] }') @@ -3998,8 +3998,8 @@ class QuerySetTest(unittest.TestCase): 'function() { return this["fielda"] >= this["fieldb"] }', query._where_clause) results = list(query) self.assertEqual(2, len(results)) - self.assertTrue(a in results) - self.assertTrue(c in results) + self.assertIn(a, results) + self.assertIn(c, results) with self.assertRaises(TypeError): list(IntPair.objects.where(fielda__gte=3)) @@ -4381,7 +4381,7 @@ class QuerySetTest(unittest.TestCase): Test.drop_collection() Test.objects(test='foo').update_one(upsert=True, set__test='foo') - self.assertFalse('_cls' in Test._collection.find_one()) + self.assertNotIn('_cls', Test._collection.find_one()) class Test(Document): meta = {'allow_inheritance': True} @@ -4390,7 +4390,7 @@ class QuerySetTest(unittest.TestCase): Test.drop_collection() Test.objects(test='foo').update_one(upsert=True, set__test='foo') - self.assertTrue('_cls' in Test._collection.find_one()) + self.assertIn('_cls', Test._collection.find_one()) def test_update_upsert_looks_like_a_digit(self): class MyDoc(DynamicDocument): @@ -4602,8 +4602,8 @@ class QuerySetTest(unittest.TestCase): users = User.objects.only('name', 'price').as_pymongo() results = list(users) - self.assertTrue(isinstance(results[0], dict)) - self.assertTrue(isinstance(results[1], dict)) + self.assertIsInstance(results[0], dict) + self.assertIsInstance(results[1], dict) self.assertEqual(results[0]['name'], 'Bob Dole') self.assertEqual(results[0]['price'], 1.11) self.assertEqual(results[1]['name'], 'Barack Obama') @@ -4611,8 +4611,8 @@ class QuerySetTest(unittest.TestCase): users = User.objects.only('name', 'last_login').as_pymongo() results = list(users) - self.assertTrue(isinstance(results[0], dict)) - self.assertTrue(isinstance(results[1], dict)) + self.assertIsInstance(results[0], dict) + self.assertIsInstance(results[1], dict) self.assertEqual(results[0], { 'name': 'Bob Dole' }) @@ -4669,12 +4669,10 @@ class QuerySetTest(unittest.TestCase): User(name="Bob Dole", organization=whitehouse).save() qs = User.objects() - self.assertTrue(isinstance(qs.first().organization, Organization)) - self.assertFalse(isinstance(qs.no_dereference().first().organization, - Organization)) - self.assertFalse(isinstance(qs.no_dereference().get().organization, - Organization)) - self.assertTrue(isinstance(qs.first().organization, Organization)) + self.assertIsInstance(qs.first().organization, Organization) + self.assertNotIsInstance(qs.no_dereference().first().organization, Organization) + self.assertNotIsInstance(qs.no_dereference().get().organization, Organization) + self.assertIsInstance(qs.first().organization, Organization) def test_no_dereference_embedded_doc(self): @@ -4707,9 +4705,9 @@ class QuerySetTest(unittest.TestCase): result = Organization.objects().no_dereference().first() - self.assertTrue(isinstance(result.admin[0], (DBRef, ObjectId))) - self.assertTrue(isinstance(result.member.user, (DBRef, ObjectId))) - self.assertTrue(isinstance(result.members[0].user, (DBRef, ObjectId))) + self.assertIsInstance(result.admin[0], (DBRef, ObjectId)) + self.assertIsInstance(result.member.user, (DBRef, ObjectId)) + self.assertIsInstance(result.members[0].user, (DBRef, ObjectId)) def test_cached_queryset(self): class Person(Document): @@ -5052,7 +5050,7 @@ class QuerySetTest(unittest.TestCase): op = q.db.system.profile.find({"ns": {"$ne": "%s.system.indexes" % q.db.name}})[0] - self.assertFalse('$orderby' in op['query'], + self.assertNotIn('$orderby', op['query'], 'BaseQuerySet cannot use orderby in if stmt') with query_counter() as p: @@ -5063,8 +5061,7 @@ class QuerySetTest(unittest.TestCase): op = p.db.system.profile.find({"ns": {"$ne": "%s.system.indexes" % q.db.name}})[0] - self.assertTrue('$orderby' in op['query'], - 'BaseQuerySet cannot remove orderby in for loop') + self.assertIn('$orderby', op['query'], 'BaseQuerySet cannot remove orderby in for loop') def test_bool_with_ordering_from_meta_dict(self): @@ -5088,7 +5085,7 @@ class QuerySetTest(unittest.TestCase): op = q.db.system.profile.find({"ns": {"$ne": "%s.system.indexes" % q.db.name}})[0] - self.assertFalse('$orderby' in op['query'], + self.assertNotIn('$orderby', op['query'], 'BaseQuerySet must remove orderby from meta in boolen test') self.assertEqual(Person.objects.first().name, 'A') diff --git a/tests/queryset/transform.py b/tests/queryset/transform.py index 38098432..8064f09c 100644 --- a/tests/queryset/transform.py +++ b/tests/queryset/transform.py @@ -48,15 +48,15 @@ class TransformTest(unittest.TestCase): for k, v in (("set", "$set"), ("set_on_insert", "$setOnInsert"), ("push", "$push")): update = transform.update(DicDoc, **{"%s__dictField__test" % k: doc}) - self.assertTrue(isinstance(update[v]["dictField.test"], dict)) + self.assertIsInstance(update[v]["dictField.test"], dict) # Update special cases update = transform.update(DicDoc, unset__dictField__test=doc) self.assertEqual(update["$unset"]["dictField.test"], 1) update = transform.update(DicDoc, pull__dictField__test=doc) - self.assertTrue(isinstance(update["$pull"]["dictField"]["test"], dict)) - + self.assertIsInstance(update["$pull"]["dictField"]["test"], dict) + update = transform.update(LisDoc, pull__foo__in=['a']) self.assertEqual(update, {'$pull': {'foo': {'$in': ['a']}}}) @@ -88,17 +88,15 @@ class TransformTest(unittest.TestCase): post = BlogPost(**data) post.save() - self.assertTrue('postTitle' in - BlogPost.objects(title=data['title'])._query) + self.assertIn('postTitle', BlogPost.objects(title=data['title'])._query) self.assertFalse('title' in BlogPost.objects(title=data['title'])._query) self.assertEqual(BlogPost.objects(title=data['title']).count(), 1) - self.assertTrue('_id' in BlogPost.objects(pk=post.id)._query) + self.assertIn('_id', BlogPost.objects(pk=post.id)._query) self.assertEqual(BlogPost.objects(pk=post.id).count(), 1) - self.assertTrue('postComments.commentContent' in - BlogPost.objects(comments__content='test')._query) + self.assertIn('postComments.commentContent', BlogPost.objects(comments__content='test')._query) self.assertEqual(BlogPost.objects(comments__content='test').count(), 1) BlogPost.drop_collection() @@ -116,8 +114,8 @@ class TransformTest(unittest.TestCase): post = BlogPost(**data) post.save() - self.assertTrue('_id' in BlogPost.objects(pk=data['title'])._query) - self.assertTrue('_id' in BlogPost.objects(title=data['title'])._query) + self.assertIn('_id', BlogPost.objects(pk=data['title'])._query) + self.assertIn('_id', BlogPost.objects(title=data['title'])._query) self.assertEqual(BlogPost.objects(pk=data['title']).count(), 1) BlogPost.drop_collection() @@ -260,31 +258,31 @@ class TransformTest(unittest.TestCase): events = Event.objects(location__within=box) with self.assertRaises(InvalidQueryError): events.count() - + def test_update_pull_for_list_fields(self): - """ - Test added to check pull operation in update for + """ + Test added to check pull operation in update for EmbeddedDocumentListField which is inside a EmbeddedDocumentField """ class Word(EmbeddedDocument): word = StringField() index = IntField() - + class SubDoc(EmbeddedDocument): heading = ListField(StringField()) text = EmbeddedDocumentListField(Word) - + class MainDoc(Document): title = StringField() content = EmbeddedDocumentField(SubDoc) - + word = Word(word='abc', index=1) update = transform.update(MainDoc, pull__content__text=word) self.assertEqual(update, {'$pull': {'content.text': SON([('word', u'abc'), ('index', 1)])}}) update = transform.update(MainDoc, pull__content__heading='xyz') self.assertEqual(update, {'$pull': {'content.heading': 'xyz'}}) - - + + if __name__ == '__main__': unittest.main() diff --git a/tests/queryset/visitor.py b/tests/queryset/visitor.py index 6f020e88..7b68cfb0 100644 --- a/tests/queryset/visitor.py +++ b/tests/queryset/visitor.py @@ -196,7 +196,7 @@ class QTest(unittest.TestCase): test2 = test.clone() self.assertEqual(test2.count(), 3) - self.assertFalse(test2 == test) + self.assertNotEqual(test2, test) test3 = test2.filter(x=6) self.assertEqual(test3.count(), 1) diff --git a/tests/test_connection.py b/tests/test_connection.py index f58b1a3e..88d63cdb 100644 --- a/tests/test_connection.py +++ b/tests/test_connection.py @@ -39,15 +39,15 @@ class ConnectionTest(unittest.TestCase): connect('mongoenginetest') conn = get_connection() - self.assertTrue(isinstance(conn, pymongo.mongo_client.MongoClient)) + self.assertIsInstance(conn, pymongo.mongo_client.MongoClient) db = get_db() - self.assertTrue(isinstance(db, pymongo.database.Database)) + self.assertIsInstance(db, pymongo.database.Database) self.assertEqual(db.name, 'mongoenginetest') connect('mongoenginetest2', alias='testdb') conn = get_connection('testdb') - self.assertTrue(isinstance(conn, pymongo.mongo_client.MongoClient)) + self.assertIsInstance(conn, pymongo.mongo_client.MongoClient) def test_connect_in_mocking(self): """Ensure that the connect() method works properly in mocking. @@ -59,31 +59,31 @@ class ConnectionTest(unittest.TestCase): connect('mongoenginetest', host='mongomock://localhost') conn = get_connection() - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect('mongoenginetest2', host='mongomock://localhost', alias='testdb2') conn = get_connection('testdb2') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect('mongoenginetest3', host='mongodb://localhost', is_mock=True, alias='testdb3') conn = get_connection('testdb3') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect('mongoenginetest4', is_mock=True, alias='testdb4') conn = get_connection('testdb4') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect(host='mongodb://localhost:27017/mongoenginetest5', is_mock=True, alias='testdb5') conn = get_connection('testdb5') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect(host='mongomock://localhost:27017/mongoenginetest6', alias='testdb6') conn = get_connection('testdb6') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect(host='mongomock://localhost:27017/mongoenginetest7', is_mock=True, alias='testdb7') conn = get_connection('testdb7') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) def test_connect_with_host_list(self): """Ensure that the connect() method works when host is a list @@ -97,27 +97,27 @@ class ConnectionTest(unittest.TestCase): connect(host=['mongomock://localhost']) conn = get_connection() - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect(host=['mongodb://localhost'], is_mock=True, alias='testdb2') conn = get_connection('testdb2') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect(host=['localhost'], is_mock=True, alias='testdb3') conn = get_connection('testdb3') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect(host=['mongomock://localhost:27017', 'mongomock://localhost:27018'], alias='testdb4') conn = get_connection('testdb4') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect(host=['mongodb://localhost:27017', 'mongodb://localhost:27018'], is_mock=True, alias='testdb5') conn = get_connection('testdb5') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) connect(host=['localhost:27017', 'localhost:27018'], is_mock=True, alias='testdb6') conn = get_connection('testdb6') - self.assertTrue(isinstance(conn, mongomock.MongoClient)) + self.assertIsInstance(conn, mongomock.MongoClient) def test_disconnect(self): """Ensure that the disconnect() method works properly @@ -163,10 +163,10 @@ class ConnectionTest(unittest.TestCase): connect("testdb_uri", host='mongodb://username:password@localhost/mongoenginetest') conn = get_connection() - self.assertTrue(isinstance(conn, pymongo.mongo_client.MongoClient)) + self.assertIsInstance(conn, pymongo.mongo_client.MongoClient) db = get_db() - self.assertTrue(isinstance(db, pymongo.database.Database)) + self.assertIsInstance(db, pymongo.database.Database) self.assertEqual(db.name, 'mongoenginetest') c.admin.system.users.remove({}) @@ -179,10 +179,10 @@ class ConnectionTest(unittest.TestCase): connect("mongoenginetest", host='mongodb://localhost/') conn = get_connection() - self.assertTrue(isinstance(conn, pymongo.mongo_client.MongoClient)) + self.assertIsInstance(conn, pymongo.mongo_client.MongoClient) db = get_db() - self.assertTrue(isinstance(db, pymongo.database.Database)) + self.assertIsInstance(db, pymongo.database.Database) self.assertEqual(db.name, 'mongoenginetest') def test_connect_uri_default_db(self): @@ -192,10 +192,10 @@ class ConnectionTest(unittest.TestCase): connect(host='mongodb://localhost/') conn = get_connection() - self.assertTrue(isinstance(conn, pymongo.mongo_client.MongoClient)) + self.assertIsInstance(conn, pymongo.mongo_client.MongoClient) db = get_db() - self.assertTrue(isinstance(db, pymongo.database.Database)) + self.assertIsInstance(db, pymongo.database.Database) self.assertEqual(db.name, 'test') def test_uri_without_credentials_doesnt_override_conn_settings(self): @@ -242,7 +242,7 @@ class ConnectionTest(unittest.TestCase): 'mongoenginetest?authSource=admin') ) db = get_db('test2') - self.assertTrue(isinstance(db, pymongo.database.Database)) + self.assertIsInstance(db, pymongo.database.Database) self.assertEqual(db.name, 'mongoenginetest') # Clear all users @@ -255,10 +255,10 @@ class ConnectionTest(unittest.TestCase): self.assertRaises(MongoEngineConnectionError, get_connection) conn = get_connection('testdb') - self.assertTrue(isinstance(conn, pymongo.mongo_client.MongoClient)) + self.assertIsInstance(conn, pymongo.mongo_client.MongoClient) db = get_db('testdb') - self.assertTrue(isinstance(db, pymongo.database.Database)) + self.assertIsInstance(db, pymongo.database.Database) self.assertEqual(db.name, 'mongoenginetest2') def test_register_connection_defaults(self): @@ -267,7 +267,7 @@ class ConnectionTest(unittest.TestCase): register_connection('testdb', 'mongoenginetest', host=None, port=None) conn = get_connection('testdb') - self.assertTrue(isinstance(conn, pymongo.mongo_client.MongoClient)) + self.assertIsInstance(conn, pymongo.mongo_client.MongoClient) def test_connection_kwargs(self): """Ensure that connection kwargs get passed to pymongo.""" @@ -326,7 +326,7 @@ class ConnectionTest(unittest.TestCase): if IS_PYMONGO_3: c = connect(host='mongodb://localhost/test?replicaSet=local-rs') db = get_db() - self.assertTrue(isinstance(db, pymongo.database.Database)) + self.assertIsInstance(db, pymongo.database.Database) self.assertEqual(db.name, 'test') else: # PyMongo < v3.x raises an exception: @@ -343,7 +343,7 @@ class ConnectionTest(unittest.TestCase): self.assertEqual(c._MongoClient__options.replica_set_name, 'local-rs') db = get_db() - self.assertTrue(isinstance(db, pymongo.database.Database)) + self.assertIsInstance(db, pymongo.database.Database) self.assertEqual(db.name, 'test') else: # PyMongo < v3.x raises an exception: @@ -377,8 +377,8 @@ class ConnectionTest(unittest.TestCase): mongo_connections = mongoengine.connection._connections self.assertEqual(len(mongo_connections.items()), 2) - self.assertTrue('t1' in mongo_connections.keys()) - self.assertTrue('t2' in mongo_connections.keys()) + self.assertIn('t1', mongo_connections.keys()) + self.assertIn('t2', mongo_connections.keys()) if not IS_PYMONGO_3: self.assertEqual(mongo_connections['t1'].host, 'localhost') self.assertEqual(mongo_connections['t2'].host, '127.0.0.1') diff --git a/tests/test_context_managers.py b/tests/test_context_managers.py index 8c96016c..3c93b96f 100644 --- a/tests/test_context_managers.py +++ b/tests/test_context_managers.py @@ -89,15 +89,15 @@ class ContextManagersTest(unittest.TestCase): with no_dereference(Group) as Group: group = Group.objects.first() - self.assertTrue(all([not isinstance(m, User) - for m in group.members])) - self.assertFalse(isinstance(group.ref, User)) - self.assertFalse(isinstance(group.generic, User)) + for m in group.members: + self.assertNotIsInstance(m, User) + self.assertNotIsInstance(group.ref, User) + self.assertNotIsInstance(group.generic, User) - self.assertTrue(all([isinstance(m, User) - for m in group.members])) - self.assertTrue(isinstance(group.ref, User)) - self.assertTrue(isinstance(group.generic, User)) + for m in group.members: + self.assertIsInstance(m, User) + self.assertIsInstance(group.ref, User) + self.assertIsInstance(group.generic, User) def test_no_dereference_context_manager_dbref(self): """Ensure that DBRef items in ListFields aren't dereferenced. @@ -129,13 +129,13 @@ class ContextManagersTest(unittest.TestCase): group = Group.objects.first() self.assertTrue(all([not isinstance(m, User) for m in group.members])) - self.assertFalse(isinstance(group.ref, User)) - self.assertFalse(isinstance(group.generic, User)) + self.assertNotIsInstance(group.ref, User) + self.assertNotIsInstance(group.generic, User) self.assertTrue(all([isinstance(m, User) for m in group.members])) - self.assertTrue(isinstance(group.ref, User)) - self.assertTrue(isinstance(group.generic, User)) + self.assertIsInstance(group.ref, User) + self.assertIsInstance(group.generic, User) def test_no_sub_classes(self): class A(Document): diff --git a/tests/test_dereference.py b/tests/test_dereference.py index 7f58a85b..8b8bcfb2 100644 --- a/tests/test_dereference.py +++ b/tests/test_dereference.py @@ -200,8 +200,8 @@ class FieldTest(unittest.TestCase): group = Group(author=user, members=[user]).save() raw_data = Group._get_collection().find_one() - self.assertTrue(isinstance(raw_data['author'], DBRef)) - self.assertTrue(isinstance(raw_data['members'][0], DBRef)) + self.assertIsInstance(raw_data['author'], DBRef) + self.assertIsInstance(raw_data['members'][0], DBRef) group = Group.objects.first() self.assertEqual(group.author, user) @@ -224,8 +224,8 @@ class FieldTest(unittest.TestCase): self.assertEqual(group.members, [user]) raw_data = Group._get_collection().find_one() - self.assertTrue(isinstance(raw_data['author'], ObjectId)) - self.assertTrue(isinstance(raw_data['members'][0], ObjectId)) + self.assertIsInstance(raw_data['author'], ObjectId) + self.assertIsInstance(raw_data['members'][0], ObjectId) def test_recursive_reference(self): """Ensure that ReferenceFields can reference their own documents. @@ -469,7 +469,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for m in group_obj.members: - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) # Document select_related with query_counter() as q: @@ -485,7 +485,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for m in group_obj.members: - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) # Queryset select_related with query_counter() as q: @@ -502,7 +502,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for m in group_obj.members: - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) UserA.drop_collection() UserB.drop_collection() @@ -560,7 +560,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for m in group_obj.members: - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) # Document select_related with query_counter() as q: @@ -576,7 +576,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for m in group_obj.members: - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) # Queryset select_related with query_counter() as q: @@ -593,7 +593,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for m in group_obj.members: - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) UserA.drop_collection() UserB.drop_collection() @@ -633,7 +633,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 2) for k, m in group_obj.members.iteritems(): - self.assertTrue(isinstance(m, User)) + self.assertIsInstance(m, User) # Document select_related with query_counter() as q: @@ -646,7 +646,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 2) for k, m in group_obj.members.iteritems(): - self.assertTrue(isinstance(m, User)) + self.assertIsInstance(m, User) # Queryset select_related with query_counter() as q: @@ -660,7 +660,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 2) for k, m in group_obj.members.iteritems(): - self.assertTrue(isinstance(m, User)) + self.assertIsInstance(m, User) User.drop_collection() Group.drop_collection() @@ -715,7 +715,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for k, m in group_obj.members.iteritems(): - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) # Document select_related with query_counter() as q: @@ -731,7 +731,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for k, m in group_obj.members.iteritems(): - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) # Queryset select_related with query_counter() as q: @@ -748,7 +748,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for k, m in group_obj.members.iteritems(): - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) Group.objects.delete() Group().save() @@ -806,7 +806,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 2) for k, m in group_obj.members.iteritems(): - self.assertTrue(isinstance(m, UserA)) + self.assertIsInstance(m, UserA) # Document select_related with query_counter() as q: @@ -822,7 +822,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 2) for k, m in group_obj.members.iteritems(): - self.assertTrue(isinstance(m, UserA)) + self.assertIsInstance(m, UserA) # Queryset select_related with query_counter() as q: @@ -839,7 +839,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 2) for k, m in group_obj.members.iteritems(): - self.assertTrue(isinstance(m, UserA)) + self.assertIsInstance(m, UserA) UserA.drop_collection() Group.drop_collection() @@ -894,7 +894,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for k, m in group_obj.members.iteritems(): - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) # Document select_related with query_counter() as q: @@ -910,7 +910,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for k, m in group_obj.members.iteritems(): - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) # Queryset select_related with query_counter() as q: @@ -927,7 +927,7 @@ class FieldTest(unittest.TestCase): self.assertEqual(q, 4) for k, m in group_obj.members.iteritems(): - self.assertTrue('User' in m.__class__.__name__) + self.assertIn('User', m.__class__.__name__) Group.objects.delete() Group().save() @@ -1209,10 +1209,10 @@ class FieldTest(unittest.TestCase): # Can't use query_counter across databases - so test the _data object book = Book.objects.first() - self.assertFalse(isinstance(book._data['author'], User)) + self.assertNotIsInstance(book._data['author'], User) book.select_related() - self.assertTrue(isinstance(book._data['author'], User)) + self.assertIsInstance(book._data['author'], User) def test_non_ascii_pk(self): """ From a86092fb6450df0911aea761230451d88027ae60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Thu, 6 Sep 2018 22:33:24 +0200 Subject: [PATCH 186/250] fix doc for meta index_options --- docs/guide/defining-documents.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index 366d12c7..62cbcd67 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -529,7 +529,7 @@ 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, @@ -537,7 +537,7 @@ There are a few top level defaults for all indexes that can be set:: } -:attr:`index_options` (Optional) +:attr:`index_opts` (Optional) Set any default index options - see the `full options list `_ :attr:`index_background` (Optional) From 7fc5ced3af3380ffec60787a508a7a049180d194 Mon Sep 17 00:00:00 2001 From: Stefan VanBuren Date: Thu, 6 Sep 2018 16:50:31 -0400 Subject: [PATCH 187/250] Update link to index options --- docs/guide/defining-documents.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index 366d12c7..06666022 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -538,7 +538,7 @@ There are a few top level defaults for all indexes that can be set:: :attr:`index_options` (Optional) - Set any default index options - see the `full options list `_ + Set any default index options - see the `full options list `_ :attr:`index_background` (Optional) Set the default value for if an index should be indexed in the background From aa49283fa9394ede764c26a0329ccae3c62b5375 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Fri, 7 Sep 2018 15:39:55 +0800 Subject: [PATCH 188/250] fix trailing whitespace --- mongoengine/queryset/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index eb0fd669..6fddc381 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -775,7 +775,7 @@ class BaseQuerySet(object): """Limit the number of returned documents to `n`. This may also be achieved using array-slicing syntax (e.g. ``User.objects[:5]``). - :param n: the maximum number of objects to return if n is greater than 0. + :param n: the maximum number of objects to return if n is greater than 0. When 0 is passed, returns all the documents in the cursor """ queryset = self.clone() From f89214f9cf39d2a06fd3611ffb6e1647e6fce4b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sat, 8 Sep 2018 22:20:49 +0200 Subject: [PATCH 189/250] Fixes bug where an EmbeddedDocument that shares the same id of its parent Document could be missing updates when .save was called Fixes #1768, Fixes #1685 --- mongoengine/base/document.py | 53 +++++++++++++++++------------------ tests/document/instance.py | 54 ++++++++++++++++++++++++++++++++++++ tests/test_dereference.py | 1 - 3 files changed, 79 insertions(+), 29 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 85906a3e..7a3e22f9 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -503,7 +503,13 @@ class BaseDocument(object): self._changed_fields = [] - def _nestable_types_changed_fields(self, changed_fields, key, data, inspected): + def _nestable_types_changed_fields(self, changed_fields, base_key, data): + """Inspect nested data for changed fields + + :param changed_fields: Previously collected changed fields + :param base_key: The base key that must be used to prepend changes to this data + :param data: data to inspect for changes + """ # Loop list / dict fields as they contain documents # Determine the iterator to use if not hasattr(data, 'items'): @@ -511,57 +517,48 @@ class BaseDocument(object): else: iterator = data.iteritems() - for index, value in iterator: - list_key = '%s%s.' % (key, index) + for index_or_key, value in iterator: + item_key = '%s%s.' % (base_key, index_or_key) # don't check anything lower if this key is already marked # as changed. - if list_key[:-1] in changed_fields: + if item_key[:-1] in changed_fields: continue + if hasattr(value, '_get_changed_fields'): - changed = value._get_changed_fields(inspected) - changed_fields += ['%s%s' % (list_key, k) - for k in changed if k] + changed = value._get_changed_fields() + changed_fields += ['%s%s' % (item_key, k) for k in changed if k] elif isinstance(value, (list, tuple, dict)): self._nestable_types_changed_fields( - changed_fields, list_key, value, inspected) + changed_fields, item_key, value) - def _get_changed_fields(self, inspected=None): + def _get_changed_fields(self): """Return a list of all fields that have explicitly been changed. """ EmbeddedDocument = _import_class('EmbeddedDocument') - DynamicEmbeddedDocument = _import_class('DynamicEmbeddedDocument') ReferenceField = _import_class('ReferenceField') SortedListField = _import_class('SortedListField') changed_fields = [] changed_fields += getattr(self, '_changed_fields', []) - inspected = inspected or set() - if hasattr(self, 'id') and isinstance(self.id, Hashable): - if self.id in inspected: - return changed_fields - inspected.add(self.id) - for field_name in self._fields_ordered: db_field_name = self._db_field_map.get(field_name, field_name) key = '%s.' % db_field_name data = self._data.get(field_name, None) field = self._fields.get(field_name) - if hasattr(data, 'id'): - if data.id in inspected: - continue - if isinstance(field, ReferenceField): + if db_field_name in changed_fields: + # Whole field already marked as changed, no need to go further continue - elif ( - isinstance(data, (EmbeddedDocument, DynamicEmbeddedDocument)) and - db_field_name not in changed_fields - ): + + if isinstance(field, ReferenceField): # Don't follow referenced documents + continue + + if isinstance(data, EmbeddedDocument): # Find all embedded fields that have been changed - changed = data._get_changed_fields(inspected) + changed = data._get_changed_fields() changed_fields += ['%s%s' % (key, k) for k in changed if k] - elif (isinstance(data, (list, tuple, dict)) and - db_field_name not in changed_fields): + elif isinstance(data, (list, tuple, dict)): if (hasattr(field, 'field') and isinstance(field.field, ReferenceField)): continue @@ -572,7 +569,7 @@ class BaseDocument(object): continue self._nestable_types_changed_fields( - changed_fields, key, data, inspected) + changed_fields, key, data) return changed_fields def _delta(self): diff --git a/tests/document/instance.py b/tests/document/instance.py index e637b3e6..d8ff8b43 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -1422,6 +1422,60 @@ class InstanceTest(MongoDBTestCase): self.assertEqual(person.age, 21) self.assertEqual(person.active, False) + def test__get_changed_fields_same_ids_reference_field_does_not_enters_infinite_loop(self): + # Refers to Issue #1685 + class EmbeddedChildModel(EmbeddedDocument): + id = DictField(primary_key=True) + + class ParentModel(Document): + child = EmbeddedDocumentField( + EmbeddedChildModel) + + emb = EmbeddedChildModel(id={'1': [1]}) + ParentModel(children=emb)._get_changed_fields() + + def test__get_changed_fields_same_ids_reference_field_does_not_enters_infinite_loop(self): + class User(Document): + id = IntField(primary_key=True) + name = StringField() + + class Message(Document): + id = IntField(primary_key=True) + author = ReferenceField(User) + + Message.drop_collection() + + # All objects share the same id, but each in a different collection + user = User(id=1, name='user-name').save() + message = Message(id=1, author=user).save() + + message.author.name = 'tutu' + self.assertEqual(message._get_changed_fields(), []) + self.assertEqual(user._get_changed_fields(), ['name']) + + def test__get_changed_fields_same_ids_embedded(self): + # Refers to Issue #1768 + class User(EmbeddedDocument): + id = IntField() + name = StringField() + + class Message(Document): + id = IntField(primary_key=True) + author = EmbeddedDocumentField(User) + + Message.drop_collection() + + # All objects share the same id, but each in a different collection + user = User(id=1, name='user-name')#.save() + message = Message(id=1, author=user).save() + + message.author.name = 'tutu' + self.assertEqual(message._get_changed_fields(), ['author.name']) + message.save() + + message_fetched = Message.objects.with_id(message.id) + self.assertEqual(message_fetched.author.name, 'tutu') + def test_query_count_when_saving(self): """Ensure references don't cause extra fetches when saving""" class Organization(Document): diff --git a/tests/test_dereference.py b/tests/test_dereference.py index 8b8bcfb2..5cf089f4 100644 --- a/tests/test_dereference.py +++ b/tests/test_dereference.py @@ -1029,7 +1029,6 @@ class FieldTest(unittest.TestCase): self.assertEqual(type(foo.bar), Bar) self.assertEqual(type(foo.baz), Baz) - def test_document_reload_reference_integrity(self): """ Ensure reloading a document with multiple similar id From d6e39b362b7837aa4ca3f84f5b9eccb3adf3e808 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Fri, 7 Sep 2018 22:51:17 +0200 Subject: [PATCH 190/250] Updating inheritance doc Fixes #429 --- docs/guide/defining-documents.rst | 3 +++ 1 file changed, 3 insertions(+) diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index 62cbcd67..bf74ad8c 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -736,6 +736,9 @@ document.:: .. 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 -------------------------- From 4314fa883fffbbfee056028a4846f98333748e29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 9 Sep 2018 15:50:48 +0200 Subject: [PATCH 191/250] improve 2-3 codebase compatibility --- docs/code/tumblelog.py | 26 +++++++++++++------------- mongoengine/base/common.py | 8 ++++---- mongoengine/base/datastructures.py | 2 +- mongoengine/base/document.py | 4 ++-- mongoengine/base/fields.py | 2 +- mongoengine/dereference.py | 2 +- mongoengine/document.py | 12 ++++-------- mongoengine/fields.py | 13 +++++++++++-- mongoengine/queryset/base.py | 17 ++++++++--------- mongoengine/queryset/field_list.py | 4 +++- mongoengine/queryset/manager.py | 2 +- mongoengine/queryset/queryset.py | 4 ++-- setup.py | 3 +-- tests/__init__.py | 8 ++++---- tests/document/__init__.py | 16 ++++++++-------- tests/fields/__init__.py | 6 +++--- tests/queryset/__init__.py | 12 ++++++------ 17 files changed, 73 insertions(+), 68 deletions(-) diff --git a/docs/code/tumblelog.py b/docs/code/tumblelog.py index c10160ea..796336e6 100644 --- a/docs/code/tumblelog.py +++ b/docs/code/tumblelog.py @@ -45,27 +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) #print '=' * post.title.count() - print "=" * 20 + 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) diff --git a/mongoengine/base/common.py b/mongoengine/base/common.py index f80471ef..dd177920 100644 --- a/mongoengine/base/common.py +++ b/mongoengine/base/common.py @@ -3,10 +3,10 @@ from mongoengine.errors import NotRegistered __all__ = ('UPDATE_OPERATORS', 'get_document', '_document_registry') -UPDATE_OPERATORS = set(['set', 'unset', 'inc', 'dec', 'mul', - 'pop', 'push', 'push_all', 'pull', - 'pull_all', 'add_to_set', 'set_on_insert', - 'min', 'max', 'rename']) +UPDATE_OPERATORS = {'set', 'unset', 'inc', 'dec', 'mul', + 'pop', 'push', 'push_all', 'pull', + 'pull_all', 'add_to_set', 'set_on_insert', + 'min', 'max', 'rename'} _document_registry = {} diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index db292f14..0197ad10 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -377,7 +377,7 @@ class EmbeddedDocumentList(BaseList): class StrictDict(object): __slots__ = () - _special_fields = set(['get', 'pop', 'iteritems', 'items', 'keys', 'create']) + _special_fields = {'get', 'pop', 'iteritems', 'items', 'keys', 'create'} _classes = {} def __init__(self, **kwargs): diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 85906a3e..fdebab23 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -302,7 +302,7 @@ class BaseDocument(object): data['_cls'] = self._class_name # only root fields ['test1.a', 'test2'] => ['test1', 'test2'] - root_fields = set([f.split('.')[0] for f in fields]) + root_fields = {f.split('.')[0] for f in fields} for field_name in self: if root_fields and field_name not in root_fields: @@ -567,7 +567,7 @@ class BaseDocument(object): continue elif isinstance(field, SortedListField) and field._ordering: # if ordering is affected whole list is changed - if any(map(lambda d: field._ordering in d._changed_fields, data)): + if any(field._ordering in d._changed_fields for d in data): changed_fields.append(db_field_name) continue diff --git a/mongoengine/base/fields.py b/mongoengine/base/fields.py index d25d4305..a0726aa6 100644 --- a/mongoengine/base/fields.py +++ b/mongoengine/base/fields.py @@ -501,7 +501,7 @@ class GeoJsonBaseField(BaseField): def validate(self, value): """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)) diff --git a/mongoengine/dereference.py b/mongoengine/dereference.py index 40bc72b2..6c993223 100644 --- a/mongoengine/dereference.py +++ b/mongoengine/dereference.py @@ -146,7 +146,7 @@ class DeReference(object): for key, doc in references.iteritems(): 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 diff --git a/mongoengine/document.py b/mongoengine/document.py index 25af273d..cdeed4c6 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -39,7 +39,7 @@ class InvalidCollectionError(Exception): pass -class EmbeddedDocument(BaseDocument): +class EmbeddedDocument(six.with_metaclass(DocumentMetaclass, BaseDocument)): """A :class:`~mongoengine.Document` that isn't stored in its own collection. :class:`~mongoengine.EmbeddedDocument`\ s should be used as fields on :class:`~mongoengine.Document`\ s through the @@ -58,7 +58,6 @@ class EmbeddedDocument(BaseDocument): # The __metaclass__ attribute is removed by 2to3 when running with Python3 # my_metaclass is defined so that metaclass can be queried in Python 2 & 3 my_metaclass = DocumentMetaclass - __metaclass__ = DocumentMetaclass # A generic embedded document doesn't have any immutable properties # that describe it uniquely, hence it shouldn't be hashable. You can @@ -95,7 +94,7 @@ class EmbeddedDocument(BaseDocument): self._instance.reload(*args, **kwargs) -class Document(BaseDocument): +class Document(six.with_metaclass(TopLevelDocumentMetaclass, BaseDocument)): """The base class used for defining the structure and properties of collections of documents stored in MongoDB. Inherit from this class, and add fields as class attributes to define a document's structure. @@ -150,7 +149,6 @@ class Document(BaseDocument): # The __metaclass__ attribute is removed by 2to3 when running with Python3 # my_metaclass is defined so that metaclass can be queried in Python 2 & 3 my_metaclass = TopLevelDocumentMetaclass - __metaclass__ = TopLevelDocumentMetaclass __slots__ = ('__objects',) @@ -996,7 +994,7 @@ class Document(BaseDocument): return {'missing': missing, 'extra': extra} -class DynamicDocument(Document): +class DynamicDocument(six.with_metaclass(TopLevelDocumentMetaclass, Document)): """A Dynamic Document class allowing flexible, expandable and uncontrolled schemas. As a :class:`~mongoengine.Document` subclass, acts in the same way as an ordinary document but has expanded style properties. Any data @@ -1013,7 +1011,6 @@ class DynamicDocument(Document): # The __metaclass__ attribute is removed by 2to3 when running with Python3 # my_metaclass is defined so that metaclass can be queried in Python 2 & 3 my_metaclass = TopLevelDocumentMetaclass - __metaclass__ = TopLevelDocumentMetaclass _dynamic = True @@ -1029,7 +1026,7 @@ class DynamicDocument(Document): super(DynamicDocument, self).__delattr__(*args, **kwargs) -class DynamicEmbeddedDocument(EmbeddedDocument): +class DynamicEmbeddedDocument(six.with_metaclass(DocumentMetaclass, EmbeddedDocument)): """A Dynamic Embedded Document class allowing flexible, expandable and uncontrolled schemas. See :class:`~mongoengine.DynamicDocument` for more information about dynamic documents. @@ -1038,7 +1035,6 @@ class DynamicEmbeddedDocument(EmbeddedDocument): # The __metaclass__ attribute is removed by 2to3 when running with Python3 # my_metaclass is defined so that metaclass can be queried in Python 2 & 3 my_metaclass = DocumentMetaclass - __metaclass__ = DocumentMetaclass _dynamic = True diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 244551d2..f794edff 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -24,6 +24,7 @@ try: except ImportError: Int64 = long + from mongoengine.base import (BaseDocument, BaseField, ComplexBaseField, GeoJsonBaseField, LazyReference, ObjectIdField, get_document) @@ -41,6 +42,12 @@ except ImportError: Image = None ImageOps = None +if six.PY3: + # Useless as long as 2to3 gets executed + # as it turns `long` into `int` blindly + long = int + + __all__ = ( 'StringField', 'URLField', 'EmailField', 'IntField', 'LongField', 'FloatField', 'DecimalField', 'BooleanField', 'DateTimeField', 'DateField', @@ -597,7 +604,7 @@ class ComplexDateTimeField(StringField): >>> ComplexDateTimeField()._convert_from_string(a) datetime.datetime(2011, 6, 8, 20, 26, 24, 92284) """ - values = map(int, data.split(self.separator)) + values = [int(d) for d in data.split(self.separator)] return datetime.datetime(*values) def __get__(self, instance, owner): @@ -1525,9 +1532,11 @@ class GridFSProxy(object): def __get__(self, instance, value): return self - def __nonzero__(self): + def __bool__(self): return bool(self.grid_id) + __nonzero__ = __bool__ # For Py2 support + def __getstate__(self): self_dict = self.__dict__ self_dict['_fs'] = None diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 6fddc381..0be48654 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -2,7 +2,6 @@ from __future__ import absolute_import import copy import itertools -import operator import pprint import re import warnings @@ -209,14 +208,12 @@ class BaseQuerySet(object): queryset = self.order_by() return False if queryset.first() is None else True - def __nonzero__(self): - """Avoid to open all records in an if stmt in Py2.""" - return self._has_data() - def __bool__(self): """Avoid to open all records in an if stmt in Py3.""" return self._has_data() + __nonzero__ = __bool__ # For Py2 support + # Core functions def all(self): @@ -269,13 +266,13 @@ class BaseQuerySet(object): queryset = queryset.filter(*q_objs, **query) try: - result = queryset.next() + result = six.next(queryset) except StopIteration: msg = ('%s matching query does not exist.' % queryset._document._class_name) raise queryset._document.DoesNotExist(msg) try: - queryset.next() + six.next(queryset) except StopIteration: return result @@ -1478,13 +1475,13 @@ class BaseQuerySet(object): # Iterator helpers - def next(self): + def __next__(self): """Wrap the result in a :class:`~mongoengine.Document` object. """ if self._limit == 0 or self._none: raise StopIteration - raw_doc = self._cursor.next() + raw_doc = six.next(self._cursor) if self._as_pymongo: return self._get_as_pymongo(raw_doc) @@ -1498,6 +1495,8 @@ class BaseQuerySet(object): return doc + next = __next__ # For Python2 support + def rewind(self): """Rewind the cursor to its unevaluated state. diff --git a/mongoengine/queryset/field_list.py b/mongoengine/queryset/field_list.py index 0524c3bb..dba724af 100644 --- a/mongoengine/queryset/field_list.py +++ b/mongoengine/queryset/field_list.py @@ -63,9 +63,11 @@ 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 = {field: self.value for field in self.fields} if self.slice: diff --git a/mongoengine/queryset/manager.py b/mongoengine/queryset/manager.py index 199205e9..f93dbb43 100644 --- a/mongoengine/queryset/manager.py +++ b/mongoengine/queryset/manager.py @@ -36,7 +36,7 @@ class QuerySetManager(object): 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: diff --git a/mongoengine/queryset/queryset.py b/mongoengine/queryset/queryset.py index 1aadfb76..f9fed7b7 100644 --- a/mongoengine/queryset/queryset.py +++ b/mongoengine/queryset/queryset.py @@ -115,7 +115,7 @@ class QuerySet(BaseQuerySet): # the result cache. try: for _ in six.moves.range(ITER_CHUNK_SIZE): - self._result_cache.append(self.next()) + 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 @@ -170,7 +170,7 @@ class QuerySetNoCache(BaseQuerySet): data = [] for _ in six.moves.range(REPR_OUTPUT_SIZE + 1): try: - data.append(self.next()) + data.append(six.next(self)) except StopIteration: break diff --git a/setup.py b/setup.py index 98964d19..c7632ce3 100644 --- a/setup.py +++ b/setup.py @@ -44,9 +44,8 @@ CLASSIFIERS = [ "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.3", - "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", + "Programming Language :: Python :: 3.6", "Programming Language :: Python :: Implementation :: CPython", "Programming Language :: Python :: Implementation :: PyPy", 'Topic :: Database', diff --git a/tests/__init__.py b/tests/__init__.py index eab0ddc7..08db7186 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,4 +1,4 @@ -from all_warnings import AllWarnings -from document import * -from queryset import * -from fields import * +from .all_warnings import AllWarnings +from .document import * +from .queryset import * +from .fields import * diff --git a/tests/document/__init__.py b/tests/document/__init__.py index f71376ea..dc35c969 100644 --- a/tests/document/__init__.py +++ b/tests/document/__init__.py @@ -1,13 +1,13 @@ 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() diff --git a/tests/fields/__init__.py b/tests/fields/__init__.py index 8e0640db..4994d0c6 100644 --- a/tests/fields/__init__.py +++ b/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 * diff --git a/tests/queryset/__init__.py b/tests/queryset/__init__.py index c36b2684..31016966 100644 --- a/tests/queryset/__init__.py +++ b/tests/queryset/__init__.py @@ -1,6 +1,6 @@ -from transform import * -from field_list import * -from queryset import * -from visitor import * -from geo import * -from modify import * \ No newline at end of file +from .transform import * +from .field_list import * +from .queryset import * +from .visitor import * +from .geo import * +from .modify import * From f83ae5789b26b09192b4bdbefedd5cfffa6cc04c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 16 Sep 2018 21:27:09 +0200 Subject: [PATCH 192/250] fix side effect from queryset's no_dereference #1677 --- mongoengine/base/document.py | 2 +- mongoengine/base/fields.py | 8 ++-- mongoengine/fields.py | 5 ++- tests/queryset/queryset.py | 84 +++++++++++++++++++++++++++++++----- 4 files changed, 83 insertions(+), 16 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 84acb5a2..c82d670e 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -700,7 +700,7 @@ class BaseDocument(object): fields = cls._fields if not _auto_dereference: - fields = copy.copy(fields) + fields = copy.deepcopy(fields) for field_name, field in fields.iteritems(): field._auto_dereference = _auto_dereference diff --git a/mongoengine/base/fields.py b/mongoengine/base/fields.py index a0726aa6..6c1bf4f1 100644 --- a/mongoengine/base/fields.py +++ b/mongoengine/base/fields.py @@ -266,13 +266,15 @@ class ComplexBaseField(BaseField): ReferenceField = _import_class('ReferenceField') GenericReferenceField = _import_class('GenericReferenceField') EmbeddedDocumentListField = _import_class('EmbeddedDocumentListField') - dereference = (self._auto_dereference and + + auto_dereference = instance._fields[self.name]._auto_dereference + + dereference = (auto_dereference and (self.field is None or isinstance(self.field, (GenericReferenceField, ReferenceField)))) _dereference = _import_class('DeReference')() - self._auto_dereference = instance._fields[self.name]._auto_dereference if instance._initialised and dereference and instance._data.get(self.name): instance._data[self.name] = _dereference( instance._data.get(self.name), max_depth=1, instance=instance, @@ -293,7 +295,7 @@ class ComplexBaseField(BaseField): value = BaseDict(value, instance, self.name) instance._data[self.name] = value - if (self._auto_dereference and instance._initialised and + if (auto_dereference and instance._initialised and isinstance(value, (BaseList, BaseDict)) and not value._dereferenced): value = _dereference( diff --git a/mongoengine/fields.py b/mongoengine/fields.py index f794edff..731ab06b 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1104,9 +1104,9 @@ class ReferenceField(BaseField): # Get value from document instance if available value = instance._data.get(self.name) - self._auto_dereference = instance._fields[self.name]._auto_dereference + auto_dereference = instance._fields[self.name]._auto_dereference # Dereference DBRefs - if self._auto_dereference and isinstance(value, DBRef): + if auto_dereference and isinstance(value, DBRef): if hasattr(value, 'cls'): # Dereference using the class type specified in the reference cls = get_document(value.cls) @@ -1267,6 +1267,7 @@ class CachedReferenceField(BaseField): # Get value from document instance if available value = instance._data.get(self.name) self._auto_dereference = instance._fields[self.name]._auto_dereference + # Dereference DBRefs if self._auto_dereference and isinstance(value, DBRef): dereferenced = self.document_type._get_db().dereference(value) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 0f2364f7..35ebe24d 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4674,11 +4674,69 @@ class QuerySetTest(unittest.TestCase): User(name="Bob Dole", organization=whitehouse).save() qs = User.objects() + qs_user = qs.first() + self.assertIsInstance(qs.first().organization, Organization) - self.assertNotIsInstance(qs.no_dereference().first().organization, Organization) - self.assertNotIsInstance(qs.no_dereference().get().organization, Organization) + + self.assertIsInstance(qs.no_dereference().first().organization, DBRef) + + self.assertIsInstance(qs_user.organization, Organization) self.assertIsInstance(qs.first().organization, Organization) + def test_no_dereference_internals(self): + # Test the internals on which queryset.no_dereference relies on + class Organization(Document): + name = StringField() + + class User(Document): + organization = ReferenceField(Organization) + + User.drop_collection() + Organization.drop_collection() + + cls_organization_field = User.organization + self.assertTrue(cls_organization_field._auto_dereference, True) # default + + org = Organization(name="whatever").save() + User(organization=org).save() + + qs_no_deref = User.objects().no_dereference() + user_no_deref = qs_no_deref.first() + self.assertFalse(qs_no_deref._auto_dereference) + + # Make sure the instance field is different from the class field + instance_org_field = user_no_deref._fields['organization'] + self.assertIsNot(instance_org_field, cls_organization_field) + self.assertFalse(instance_org_field._auto_dereference) + + self.assertIsInstance(user_no_deref.organization, DBRef) + self.assertTrue(cls_organization_field._auto_dereference, True) # Make sure the class Field wasn't altered + + def test_no_dereference_no_side_effect_on_existing_instance(self): + # Relates to issue #1677 - ensures no regression of the bug + + class Organization(Document): + name = StringField() + + class User(Document): + organization = ReferenceField(Organization) + + User.drop_collection() + Organization.drop_collection() + + org = Organization(name="whatever").save() + User(organization=org).save() + + qs = User.objects() + user = qs.first() + + qs_no_deref = User.objects().no_dereference() + user_no_deref = qs_no_deref.first() + + no_derf_org = user_no_deref.organization # was triggering the bug + self.assertIsInstance(no_derf_org, DBRef) + self.assertIsInstance(user.organization, Organization) + def test_no_dereference_embedded_doc(self): class User(Document): @@ -4693,7 +4751,7 @@ class QuerySetTest(unittest.TestCase): members = ListField(EmbeddedDocumentField(Member)) ceo = ReferenceField(User) member = EmbeddedDocumentField(Member) - admin = ListField(ReferenceField(User)) + admins = ListField(ReferenceField(User)) Organization.drop_collection() User.drop_collection() @@ -4703,16 +4761,22 @@ class QuerySetTest(unittest.TestCase): member = Member(name="Flash", user=user) - company = Organization(name="Mongo Inc", ceo=user, member=member) - company.admin.append(user) - company.members.append(member) + company = Organization(name="Mongo Inc", + ceo=user, + member=member, + admins=[user], + members=[member]) company.save() - result = Organization.objects().no_dereference().first() + org = Organization.objects().no_dereference().first() - self.assertIsInstance(result.admin[0], (DBRef, ObjectId)) - self.assertIsInstance(result.member.user, (DBRef, ObjectId)) - self.assertIsInstance(result.members[0].user, (DBRef, ObjectId)) + self.assertNotEqual(id(org._fields['admins']), id(Organization.admins)) + self.assertFalse(org._fields['admins']._auto_dereference) + + admin = org.admins[0] + self.assertIsInstance(admin, DBRef) + self.assertIsInstance(org.member.user, DBRef) + self.assertIsInstance(org.members[0].user, DBRef) def test_cached_queryset(self): class Person(Document): From 45c2151d0fe26d4d17ff671650f0028ffe5a1921 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 25 Sep 2018 22:56:57 +0200 Subject: [PATCH 193/250] Fix side effect of no_dereference on GenericReferenceField --- mongoengine/fields.py | 8 ++++---- tests/queryset/queryset.py | 10 +++++++++- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 648940d2..85602215 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1266,10 +1266,10 @@ class CachedReferenceField(BaseField): # Get value from document instance if available value = instance._data.get(self.name) - self._auto_dereference = instance._fields[self.name]._auto_dereference + auto_dereference = instance._fields[self.name]._auto_dereference # Dereference DBRefs - if self._auto_dereference and isinstance(value, DBRef): + if auto_dereference and isinstance(value, DBRef): dereferenced = self.document_type._get_db().dereference(value) if dereferenced is None: raise DoesNotExist('Trying to dereference unknown document %s' % value) @@ -1402,8 +1402,8 @@ class GenericReferenceField(BaseField): value = instance._data.get(self.name) - self._auto_dereference = instance._fields[self.name]._auto_dereference - if self._auto_dereference and isinstance(value, (dict, SON)): + auto_dereference = instance._fields[self.name]._auto_dereference + if auto_dereference and isinstance(value, (dict, SON)): dereferenced = self.dereference(value) if dereferenced is None: raise DoesNotExist('Trying to dereference unknown document %s' % value) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 35ebe24d..4706305f 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4720,12 +4720,14 @@ class QuerySetTest(unittest.TestCase): class User(Document): organization = ReferenceField(Organization) + organization_gen = GenericReferenceField() User.drop_collection() Organization.drop_collection() org = Organization(name="whatever").save() - User(organization=org).save() + User(organization=org, + organization_gen=org).save() qs = User.objects() user = qs.first() @@ -4733,10 +4735,16 @@ class QuerySetTest(unittest.TestCase): qs_no_deref = User.objects().no_dereference() user_no_deref = qs_no_deref.first() + # ReferenceField no_derf_org = user_no_deref.organization # was triggering the bug self.assertIsInstance(no_derf_org, DBRef) self.assertIsInstance(user.organization, Organization) + # GenericReferenceField + no_derf_org_gen = user_no_deref.organization_gen + self.assertIsInstance(no_derf_org_gen, dict) + self.assertIsInstance(user.organization_gen, Organization) + def test_no_dereference_embedded_doc(self): class User(Document): From 96f09196337718699e73d7e55679affec48304a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Fri, 28 Sep 2018 22:39:08 +0200 Subject: [PATCH 194/250] - Fixed tests to allow support of MongoDB 3.2 - Replaced MongoDB 2.4 tests in CI by MongoDB 3.2 --- .install_mongodb_on_travis.sh | 6 ++ .travis.yml | 12 ++-- README.rst | 4 +- mongoengine/context_managers.py | 6 +- tests/document/indexes.py | 39 +++++----- tests/queryset/queryset.py | 122 +++++++++++++++++--------------- tests/test_context_managers.py | 1 - tests/utils.py | 31 +++++--- 8 files changed, 126 insertions(+), 95 deletions(-) diff --git a/.install_mongodb_on_travis.sh b/.install_mongodb_on_travis.sh index f2018411..a4ff085b 100644 --- a/.install_mongodb_on_travis.sh +++ b/.install_mongodb_on_travis.sh @@ -18,6 +18,12 @@ elif [ "$MONGODB" = "3.0" ]; then sudo apt-get update sudo apt-get install mongodb-org-server=3.0.14 # service should be started automatically +elif [ "$MONGODB" = "3.2" ]; then + sudo apt-key adv --keyserver keyserver.ubuntu.com --recv EA312927 + echo "deb http://repo.mongodb.org/apt/ubuntu trusty/mongodb-org/3.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.2.list + sudo apt-get update + sudo apt-get install mongodb-org-server=3.2.20 + # service should be started automatically else echo "Invalid MongoDB version, expected 2.4, 2.6, or 3.0." exit 1 diff --git a/.travis.yml b/.travis.yml index 381f7385..f9c7db1e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -27,17 +27,17 @@ matrix: include: - python: 2.7 - env: MONGODB=2.4 PYMONGO=3.5 + env: MONGODB=3.0 PYMONGO=3.5 - python: 2.7 - env: MONGODB=3.0 PYMONGO=3.x + env: MONGODB=3.2 PYMONGO=3.x - python: 3.5 - env: MONGODB=2.4 PYMONGO=3.5 + env: MONGODB=3.0 PYMONGO=3.5 - python: 3.5 - env: MONGODB=3.0 PYMONGO=3.x + env: MONGODB=3.2 PYMONGO=3.x - python: 3.6 - env: MONGODB=2.4 PYMONGO=3.5 + env: MONGODB=3.0 PYMONGO=3.5 - python: 3.6 - env: MONGODB=3.0 PYMONGO=3.x + env: MONGODB=3.2 PYMONGO=3.x before_install: - bash .install_mongodb_on_travis.sh diff --git a/README.rst b/README.rst index e1e2aef6..17cb3e33 100644 --- a/README.rst +++ b/README.rst @@ -26,10 +26,10 @@ an `API reference `_. Supported MongoDB Versions ========================== -MongoEngine is currently tested against MongoDB v2.4, v2.6, and v3.0. Future +MongoEngine is currently tested against MongoDB v2.6, v3.0 and v3.2. 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 v3.2+. +problems with MongoDB v3.4+. Installation ============ diff --git a/mongoengine/context_managers.py b/mongoengine/context_managers.py index ee1f5e01..c26b0a79 100644 --- a/mongoengine/context_managers.py +++ b/mongoengine/context_managers.py @@ -182,8 +182,10 @@ class query_counter(object): self._ignored_query = { 'ns': {'$ne': '%s.system.indexes' % self.db.name}, - 'op': - {'$ne': 'killcursors'} + 'op': # MONGODB < 3.2 + {'$ne': 'killcursors'}, + 'command.killCursors': # MONGODB >= 3.2 + {'$exists': False} } def _turn_on_profiling(self): diff --git a/tests/document/indexes.py b/tests/document/indexes.py index 1cbb4ec3..b3129fc8 100644 --- a/tests/document/indexes.py +++ b/tests/document/indexes.py @@ -1,15 +1,14 @@ # -*- coding: utf-8 -*- import unittest -import sys +from datetime import datetime from nose.plugins.skip import SkipTest -from datetime import datetime +from pymongo.errors import OperationFailure import pymongo from mongoengine import * from mongoengine.connection import get_db - -from tests.utils import get_mongodb_version, needs_mongodb_v26 +from tests.utils import get_mongodb_version, needs_mongodb_v26, MONGODB_32, MONGODB_3 __all__ = ("IndexesTest", ) @@ -19,6 +18,7 @@ class IndexesTest(unittest.TestCase): def setUp(self): self.connection = connect(db='mongoenginetest') self.db = get_db() + self.mongodb_version = get_mongodb_version() class Person(Document): name = StringField() @@ -491,7 +491,7 @@ class IndexesTest(unittest.TestCase): obj = Test(a=1) obj.save() - IS_MONGODB_3 = get_mongodb_version()[0] >= 3 + IS_MONGODB_3 = get_mongodb_version() >= MONGODB_3 # Need to be explicit about covered indexes as mongoDB doesn't know if # the documents returned might have more keys in that here. @@ -541,19 +541,24 @@ class IndexesTest(unittest.TestCase): [('categories', 1), ('_id', 1)]) def test_hint(self): + MONGO_VER = self.mongodb_version + 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 range(0, 10): - tags = [("tag %i" % n) for n in range(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) @@ -563,18 +568,18 @@ class IndexesTest(unittest.TestCase): if pymongo.version != '3.0': self.assertEqual(BlogPost.objects.hint([('tags', 1)]).count(), 10) + if MONGO_VER == MONGODB_32: + # Mongo32 throws an error if an index exists (i.e `tags` in our case) + # and you use hint on an index name that does not exist + with self.assertRaises(OperationFailure): + BlogPost.objects.hint([('ZZ', 1)]).count() + else: self.assertEqual(BlogPost.objects.hint([('ZZ', 1)]).count(), 10) - if pymongo.version >= '2.8': - self.assertEqual(BlogPost.objects.hint('tags').count(), 10) - else: - def invalid_index(): - BlogPost.objects.hint('tags').next() - self.assertRaises(TypeError, invalid_index) + self.assertEqual(BlogPost.objects.hint(TAGS_INDEX_NAME ).count(), 10) - def invalid_index_2(): - return BlogPost.objects.hint(('tags', 1)).next() - self.assertRaises(Exception, invalid_index_2) + with self.assertRaises(Exception): + BlogPost.objects.hint(('tags', 1)).next() def test_unique(self): """Ensure that uniqueness constraints are applied to fields. diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 35ebe24d..050f65d9 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -21,8 +21,7 @@ from mongoengine.python_support import IS_PYMONGO_3 from mongoengine.queryset import (DoesNotExist, MultipleObjectsReturned, QuerySet, QuerySetManager, queryset_manager) -from tests.utils import needs_mongodb_v26, skip_pymongo3 - +from tests.utils import needs_mongodb_v26, skip_pymongo3, get_mongodb_version, MONGODB_32 __all__ = ("QuerySetTest",) @@ -30,10 +29,8 @@ __all__ = ("QuerySetTest",) class db_ops_tracker(query_counter): def get_ops(self): - ignore_query = { - 'ns': {'$ne': '%s.system.indexes' % self.db.name}, - 'command.count': {'$ne': 'system.profile'} - } + ignore_query = dict(self._ignored_query) + ignore_query['command.count'] = {'$ne': 'system.profile'} # Ignore the query issued by query_counter return list(self.db.system.profile.find(ignore_query)) @@ -56,6 +53,8 @@ class QuerySetTest(unittest.TestCase): self.PersonMeta = PersonMeta self.Person = Person + self.mongodb_version = get_mongodb_version() + def test_initialisation(self): """Ensure that a QuerySet is correctly initialised by QuerySetManager. """ @@ -813,8 +812,8 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(record.embed.field, 2) def test_bulk_insert(self): - """Ensure that bulk insert works - """ + """Ensure that bulk insert works""" + MONGO_VER = self.mongodb_version class Comment(EmbeddedDocument): name = StringField() @@ -832,35 +831,41 @@ class QuerySetTest(unittest.TestCase): # get MongoDB version info connection = get_connection() info = connection.test.command('buildInfo') - mongodb_version = tuple([int(i) for i in info['version'].split('.')]) # Recreates the collection self.assertEqual(0, Blog.objects.count()) + comment1 = Comment(name='testa') + comment2 = Comment(name='testb') + post1 = Post(comments=[comment1, comment2]) + post2 = Post(comments=[comment2, comment2]) + blogs = [Blog(title="post %s" % i, posts=[post1, post2]) + for i in range(99)] + + # Check bulk insert using load_bulk=False with query_counter() as q: self.assertEqual(q, 0) - - comment1 = Comment(name='testa') - comment2 = Comment(name='testb') - post1 = Post(comments=[comment1, comment2]) - post2 = Post(comments=[comment2, comment2]) - - blogs = [] - for i in range(1, 100): - blogs.append(Blog(title="post %s" % i, posts=[post1, post2])) - Blog.objects.insert(blogs, load_bulk=False) - # profiling logs each doc now in the bulk op - self.assertEqual(q, 99) + + if MONGO_VER == MONGODB_32: + self.assertEqual(q, 1) # 1 entry containing the list of inserts + else: + self.assertEqual(q, len(blogs)) # 1 entry per doc inserted + + self.assertEqual(Blog.objects.count(), len(blogs)) Blog.drop_collection() Blog.ensure_indexes() + # Check bulk insert using load_bulk=True with query_counter() as q: self.assertEqual(q, 0) - Blog.objects.insert(blogs) - self.assertEqual(q, 100) # 99 for insert 1 for fetch + + if MONGO_VER == MONGODB_32: + self.assertEqual(q, 2) # 1 for insert 1 for fetch + else: + self.assertEqual(q, len(blogs)+1) # + 1 to fetch all docs Blog.drop_collection() @@ -1262,6 +1267,9 @@ class QuerySetTest(unittest.TestCase): """Ensure that the default ordering can be cleared by calling order_by() w/o any arguments. """ + MONGO_VER = self.mongodb_version + ORDER_BY_KEY = 'sort' if MONGO_VER == MONGODB_32 else '$orderby' + class BlogPost(Document): title = StringField() published_date = DateTimeField() @@ -1277,7 +1285,7 @@ class QuerySetTest(unittest.TestCase): BlogPost.objects.filter(title='whatever').first() self.assertEqual(len(q.get_ops()), 1) self.assertEqual( - q.get_ops()[0]['query']['$orderby'], + q.get_ops()[0]['query'][ORDER_BY_KEY], {'published_date': -1} ) @@ -1285,14 +1293,14 @@ class QuerySetTest(unittest.TestCase): with db_ops_tracker() as q: BlogPost.objects.filter(title='whatever').order_by().first() self.assertEqual(len(q.get_ops()), 1) - self.assertNotIn('$orderby', q.get_ops()[0]['query']) + self.assertNotIn(ORDER_BY_KEY, q.get_ops()[0]['query']) # calling an explicit order_by should use a specified sort with db_ops_tracker() as q: BlogPost.objects.filter(title='whatever').order_by('published_date').first() self.assertEqual(len(q.get_ops()), 1) self.assertEqual( - q.get_ops()[0]['query']['$orderby'], + q.get_ops()[0]['query'][ORDER_BY_KEY], {'published_date': 1} ) @@ -1301,11 +1309,14 @@ class QuerySetTest(unittest.TestCase): qs = BlogPost.objects.filter(title='whatever').order_by('published_date') qs.order_by().first() self.assertEqual(len(q.get_ops()), 1) - self.assertNotIn('$orderby', q.get_ops()[0]['query']) + self.assertNotIn(ORDER_BY_KEY, q.get_ops()[0]['query']) def test_no_ordering_for_get(self): """ Ensure that Doc.objects.get doesn't use any ordering. """ + MONGO_VER = self.mongodb_version + ORDER_BY_KEY = 'sort' if MONGO_VER == MONGODB_32 else '$orderby' + class BlogPost(Document): title = StringField() published_date = DateTimeField() @@ -1320,13 +1331,13 @@ class QuerySetTest(unittest.TestCase): with db_ops_tracker() as q: BlogPost.objects.get(title='whatever') self.assertEqual(len(q.get_ops()), 1) - self.assertNotIn('$orderby', q.get_ops()[0]['query']) + self.assertNotIn(ORDER_BY_KEY, q.get_ops()[0]['query']) # Ordering should be ignored for .get even if we set it explicitly with db_ops_tracker() as q: BlogPost.objects.order_by('-title').get(title='whatever') self.assertEqual(len(q.get_ops()), 1) - self.assertNotIn('$orderby', q.get_ops()[0]['query']) + self.assertNotIn(ORDER_BY_KEY, q.get_ops()[0]['query']) def test_find_embedded(self): """Ensure that an embedded document is properly returned from @@ -2450,7 +2461,11 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(names, ['User A', 'User B', 'User C']) def test_comment(self): - """Make sure adding a comment to the query works.""" + """Make sure adding a comment to the query gets added to the query""" + MONGO_VER = self.mongodb_version + QUERY_KEY = 'filter' if MONGO_VER == MONGODB_32 else '$query' + COMMENT_KEY = 'comment' if MONGO_VER == MONGODB_32 else '$comment' + class User(Document): age = IntField() @@ -2466,8 +2481,8 @@ class QuerySetTest(unittest.TestCase): ops = q.get_ops() self.assertEqual(len(ops), 2) for op in ops: - self.assertEqual(op['query']['$query'], {'age': {'$gte': 18}}) - self.assertEqual(op['query']['$comment'], 'looking for an adult') + self.assertEqual(op['query'][QUERY_KEY], {'age': {'$gte': 18}}) + self.assertEqual(op['query'][COMMENT_KEY], 'looking for an adult') def test_map_reduce(self): """Ensure map/reduce is both mapping and reducing. @@ -4817,27 +4832,18 @@ class QuerySetTest(unittest.TestCase): for i in range(100): Person(name="No: %s" % i).save() - with query_counter() as q: - try: - self.assertEqual(q, 0) - people = Person.objects.no_cache() + with query_counter() as q: + self.assertEqual(q, 0) + people = Person.objects.no_cache() - [x for x in people] - self.assertEqual(q, 1) + [x for x in people] + self.assertEqual(q, 1) - list(people) - self.assertEqual(q, 2) - - people.count() - self.assertEqual(q, 3) - except AssertionError as exc: - db = get_db() - msg = '' - for q in list(db.system.profile.find())[-50:]: - msg += str([q['ts'], q['ns'], q.get('query'), q['op']])+'\n' - msg += str(q) - raise AssertionError(str(exc) + '\n'+msg) + list(people) + self.assertEqual(q, 2) + people.count() + self.assertEqual(q, 3) def test_cache_not_cloned(self): @@ -5111,35 +5117,39 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(op['nreturned'], 1) def test_bool_with_ordering(self): + MONGO_VER = self.mongodb_version + ORDER_BY_KEY = 'sort' if MONGO_VER == MONGODB_32 else '$orderby' class Person(Document): name = StringField() Person.drop_collection() + Person(name="Test").save() + # Check that bool(queryset) does not uses the orderby qs = Person.objects.order_by('name') - with query_counter() as q: - if qs: + if bool(qs): pass op = q.db.system.profile.find({"ns": {"$ne": "%s.system.indexes" % q.db.name}})[0] - self.assertNotIn('$orderby', op['query'], - 'BaseQuerySet cannot use orderby in if stmt') + self.assertNotIn(ORDER_BY_KEY, op['query']) + # Check that normal query uses orderby + qs2 = Person.objects.order_by('name') with query_counter() as p: - for x in qs: + for x in qs2: pass op = p.db.system.profile.find({"ns": {"$ne": "%s.system.indexes" % q.db.name}})[0] - self.assertIn('$orderby', op['query'], 'BaseQuerySet cannot remove orderby in for loop') + self.assertIn(ORDER_BY_KEY, op['query']) def test_bool_with_ordering_from_meta_dict(self): diff --git a/tests/test_context_managers.py b/tests/test_context_managers.py index df5e5212..8fb7bc78 100644 --- a/tests/test_context_managers.py +++ b/tests/test_context_managers.py @@ -299,7 +299,6 @@ class ContextManagersTest(unittest.TestCase): cursor.close() # issues a `killcursors` query that is ignored by the context self.assertEqual(q, 1) - _ = db.system.indexes.find_one() # queries on db.system.indexes are ignored as well self.assertEqual(q, 1) diff --git a/tests/utils.py b/tests/utils.py index acd318c5..39d3681e 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -10,6 +10,13 @@ from mongoengine.python_support import IS_PYMONGO_3 MONGO_TEST_DB = 'mongoenginetest' # standard name for the test database +# Constant that can be used to compare the version retrieved with +# get_mongodb_version() +MONGODB_26 = (2, 6) +MONGODB_3 = (3,0) +MONGODB_32 = (3, 2) + + class MongoDBTestCase(unittest.TestCase): """Base class for tests that need a mongodb connection It ensures that the db is clean at the beginning and dropped at the end automatically @@ -27,24 +34,26 @@ class MongoDBTestCase(unittest.TestCase): def get_mongodb_version(): - """Return the version tuple of the MongoDB server that the default - connection is connected to. + """Return the version of the connected mongoDB (first 2 digits) + + :return: tuple(int, int) """ - return tuple(get_connection().server_info()['versionArray']) + version_list = get_connection().server_info()['versionArray'][:2] # e.g: (3, 2) + return tuple(version_list) -def _decorated_with_ver_requirement(func, ver_tuple): +def _decorated_with_ver_requirement(func, version): """Return a given function decorated with the version requirement for a particular MongoDB version tuple. + + :param version: The version required (tuple(int, int)) """ def _inner(*args, **kwargs): - mongodb_ver = get_mongodb_version() - if mongodb_ver >= ver_tuple: + MONGODB_V = get_mongodb_version() + if MONGODB_V >= version: return func(*args, **kwargs) - raise SkipTest('Needs MongoDB v{}+'.format( - '.'.join([str(v) for v in ver_tuple]) - )) + raise SkipTest('Needs MongoDB v{}+'.format('.'.join(str(n) for n in version))) _inner.__name__ = func.__name__ _inner.__doc__ = func.__doc__ @@ -56,14 +65,14 @@ def needs_mongodb_v26(func): """Raise a SkipTest exception if we're working with MongoDB version lower than v2.6. """ - return _decorated_with_ver_requirement(func, (2, 6)) + return _decorated_with_ver_requirement(func, MONGODB_26) def needs_mongodb_v3(func): """Raise a SkipTest exception if we're working with MongoDB version lower than v3.0. """ - return _decorated_with_ver_requirement(func, (3, 0)) + return _decorated_with_ver_requirement(func, MONGODB_3) def skip_pymongo3(f): From 9b6c972e0f177e1ce049034588fb4c43fa3c0fa7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 2 Oct 2018 22:03:55 +0200 Subject: [PATCH 195/250] renamed decorator needs_mongodb_x in test + fixes ref to mongo 2.4 from travis files --- .install_mongodb_on_travis.sh | 9 ++------- .travis.yml | 8 +++----- mongoengine/queryset/visitor.py | 2 +- tests/document/class_methods.py | 4 ++-- tests/document/indexes.py | 6 +++--- tests/document/instance.py | 6 +++--- tests/queryset/geo.py | 8 ++++---- tests/queryset/modify.py | 4 ++-- tests/queryset/queryset.py | 18 +++++++++--------- tests/utils.py | 4 ++-- 10 files changed, 31 insertions(+), 38 deletions(-) diff --git a/.install_mongodb_on_travis.sh b/.install_mongodb_on_travis.sh index a4ff085b..057ccf74 100644 --- a/.install_mongodb_on_travis.sh +++ b/.install_mongodb_on_travis.sh @@ -3,12 +3,7 @@ sudo apt-get remove mongodb-org-server sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10 -if [ "$MONGODB" = "2.4" ]; then - echo "deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen" | sudo tee /etc/apt/sources.list.d/mongodb.list - sudo apt-get update - sudo apt-get install mongodb-10gen=2.4.14 - sudo service mongodb start -elif [ "$MONGODB" = "2.6" ]; then +if [ "$MONGODB" = "2.6" ]; then echo "deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen" | sudo tee /etc/apt/sources.list.d/mongodb.list sudo apt-get update sudo apt-get install mongodb-org-server=2.6.12 @@ -25,7 +20,7 @@ elif [ "$MONGODB" = "3.2" ]; then sudo apt-get install mongodb-org-server=3.2.20 # service should be started automatically else - echo "Invalid MongoDB version, expected 2.4, 2.6, or 3.0." + echo "Invalid MongoDB version, expected 2.6, 3.0, or 3.2" exit 1 fi; diff --git a/.travis.yml b/.travis.yml index f9c7db1e..4f77f4e0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -2,12 +2,10 @@ # 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 v2.4 & v3.0 are only tested against Python v2.7 & v3.5. -# * MongoDB v2.4 is tested against PyMongo v2.7 & v3.x. -# * MongoDB v3.0 is tested against PyMongo v3.x. # * MongoDB v2.6 is currently the "main" version tested against Python v2.7, -# v3.5, PyPy & PyPy3, and PyMongo v2.7, v2.8 & v3.x. -# +# v3.5, v3.6, PyPy, and PyMongo v3.x. +# * MongoDB v3.0 & v3.2 are tested against Python v2.7, v3.5 & v3.6 +# and Pymongo v3.5 & v3.x # Reminder: Update README.rst if you change MongoDB versions we test. language: python diff --git a/mongoengine/queryset/visitor.py b/mongoengine/queryset/visitor.py index bcf93a13..dbe3bf2f 100644 --- a/mongoengine/queryset/visitor.py +++ b/mongoengine/queryset/visitor.py @@ -3,7 +3,7 @@ import copy from mongoengine.errors import InvalidQueryError from mongoengine.queryset import transform -__all__ = ('Q',) +__all__ = ('Q', 'QNode') class QNodeVisitor(object): diff --git a/tests/document/class_methods.py b/tests/document/class_methods.py index 5289e483..2632d38f 100644 --- a/tests/document/class_methods.py +++ b/tests/document/class_methods.py @@ -5,7 +5,7 @@ from mongoengine import * from mongoengine.queryset import NULLIFY, PULL from mongoengine.connection import get_db -from tests.utils import needs_mongodb_v26 +from tests.utils import requires_mongodb_gte_26 __all__ = ("ClassMethodsTest", ) @@ -188,7 +188,7 @@ class ClassMethodsTest(unittest.TestCase): self.assertEqual(BlogPostWithTags.compare_indexes(), { 'missing': [], 'extra': [] }) self.assertEqual(BlogPostWithCustomField.compare_indexes(), { 'missing': [], 'extra': [] }) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_compare_indexes_for_text_indexes(self): """ Ensure that compare_indexes behaves correctly for text indexes """ diff --git a/tests/document/indexes.py b/tests/document/indexes.py index b3129fc8..757d8037 100644 --- a/tests/document/indexes.py +++ b/tests/document/indexes.py @@ -8,7 +8,7 @@ import pymongo from mongoengine import * from mongoengine.connection import get_db -from tests.utils import get_mongodb_version, needs_mongodb_v26, MONGODB_32, MONGODB_3 +from tests.utils import get_mongodb_version, requires_mongodb_gte_26, MONGODB_32, MONGODB_3 __all__ = ("IndexesTest", ) @@ -754,7 +754,7 @@ class IndexesTest(unittest.TestCase): except NotUniqueError: pass - def test_unique_and_primary(self): + 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. """ @@ -872,7 +872,7 @@ class IndexesTest(unittest.TestCase): info['provider_ids.foo_1_provider_ids.bar_1']['key']) self.assertTrue(info['provider_ids.foo_1_provider_ids.bar_1']['sparse']) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_text_indexes(self): class Book(Document): title = DictField() diff --git a/tests/document/instance.py b/tests/document/instance.py index e637b3e6..f432fab1 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -25,7 +25,7 @@ from mongoengine.queryset import NULLIFY, Q from mongoengine.context_managers import switch_db, query_counter from mongoengine import signals -from tests.utils import needs_mongodb_v26 +from tests.utils import requires_mongodb_gte_26 TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__), '../fields/mongoengine.png') @@ -840,7 +840,7 @@ class InstanceTest(MongoDBTestCase): self.assertDbEqual([dict(other_doc.to_mongo()), dict(doc.to_mongo())]) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_modify_with_positional_push(self): class BlogPost(Document): tags = ListField(StringField()) @@ -3272,7 +3272,7 @@ class InstanceTest(MongoDBTestCase): person.update(set__height=2.0) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_push_with_position(self): """Ensure that push with position works properly for an instance.""" class BlogPost(Document): diff --git a/tests/queryset/geo.py b/tests/queryset/geo.py index fea225b2..fd8c9b0f 100644 --- a/tests/queryset/geo.py +++ b/tests/queryset/geo.py @@ -3,7 +3,7 @@ import unittest from mongoengine import * -from tests.utils import MongoDBTestCase, needs_mongodb_v3 +from tests.utils import MongoDBTestCase, requires_mongodb_gte_3 __all__ = ("GeoQueriesTest",) @@ -72,7 +72,7 @@ class GeoQueriesTest(MongoDBTestCase): # $minDistance was added in MongoDB v2.6, but continued being buggy # until v3.0; skip for older versions - @needs_mongodb_v3 + @requires_mongodb_gte_3 def test_near_and_min_distance(self): """Ensure the "min_distance" operator works alongside the "near" operator. @@ -245,7 +245,7 @@ class GeoQueriesTest(MongoDBTestCase): # $minDistance was added in MongoDB v2.6, but continued being buggy # until v3.0; skip for older versions - @needs_mongodb_v3 + @requires_mongodb_gte_3 def test_2dsphere_near_and_min_max_distance(self): """Ensure "min_distace" and "max_distance" operators work well together with the "near" operator in a 2dsphere index. @@ -329,7 +329,7 @@ class GeoQueriesTest(MongoDBTestCase): self._test_embedded(point_field_class=PointField) # Needs MongoDB > 2.6.4 https://jira.mongodb.org/browse/SERVER-14039 - @needs_mongodb_v3 + @requires_mongodb_gte_3 def test_spherical_geospatial_operators(self): """Ensure that spherical geospatial queries are working.""" class Point(Document): diff --git a/tests/queryset/modify.py b/tests/queryset/modify.py index b37f9b73..4b7c3da2 100644 --- a/tests/queryset/modify.py +++ b/tests/queryset/modify.py @@ -2,7 +2,7 @@ import unittest from mongoengine import connect, Document, IntField, StringField, ListField -from tests.utils import needs_mongodb_v26 +from tests.utils import requires_mongodb_gte_26 __all__ = ("FindAndModifyTest",) @@ -96,7 +96,7 @@ class FindAndModifyTest(unittest.TestCase): self.assertEqual(old_doc.to_mongo(), {"_id": 1}) self.assertDbEqual([{"_id": 0, "value": 0}, {"_id": 1, "value": -1}]) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_modify_with_push(self): class BlogPost(Document): tags = ListField(StringField()) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 1d062853..c5004ed2 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -21,7 +21,7 @@ from mongoengine.python_support import IS_PYMONGO_3 from mongoengine.queryset import (DoesNotExist, MultipleObjectsReturned, QuerySet, QuerySetManager, queryset_manager) -from tests.utils import needs_mongodb_v26, skip_pymongo3, get_mongodb_version, MONGODB_32 +from tests.utils import requires_mongodb_gte_26, skip_pymongo3, get_mongodb_version, MONGODB_32 __all__ = ("QuerySetTest",) @@ -576,7 +576,7 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(post.comments[0].by, 'joe') self.assertEqual(post.comments[0].votes.score, 4) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_update_min_max(self): class Scores(Document): high_score = IntField() @@ -594,7 +594,7 @@ class QuerySetTest(unittest.TestCase): Scores.objects(id=scores.id).update(max__high_score=500) self.assertEqual(Scores.objects.get(id=scores.id).high_score, 1000) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_update_multiple(self): class Product(Document): item = StringField() @@ -1007,7 +1007,7 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(person.name, "User A") self.assertEqual(person.age, 20) - @needs_mongodb_v26 + @requires_mongodb_gte_26 @skip_pymongo3 def test_cursor_args(self): """Ensures the cursor args can be set as expected @@ -1986,7 +1986,7 @@ class QuerySetTest(unittest.TestCase): pymongo_doc = BlogPost.objects.as_pymongo().first() self.assertNotIn('title', pymongo_doc) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_update_push_with_position(self): """Ensure that the 'push' update with position works properly. """ @@ -3278,7 +3278,7 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(Foo.objects.distinct("bar"), [bar]) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_text_indexes(self): class News(Document): title = StringField() @@ -3365,7 +3365,7 @@ class QuerySetTest(unittest.TestCase): 'brasil').order_by('$text_score').first() self.assertEqual(item.get_text_score(), max_text_score) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_distinct_handles_references_to_alias(self): register_connection('testdb', 'mongoenginetest2') @@ -4494,7 +4494,7 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(bars._cursor._Cursor__read_preference, ReadPreference.SECONDARY_PREFERRED) - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_read_preference_aggregation_framework(self): class Bar(Document): txt = StringField() @@ -5188,7 +5188,7 @@ class QuerySetTest(unittest.TestCase): self.assertTrue(Person.objects._has_data(), 'Cursor has data and returned False') - @needs_mongodb_v26 + @requires_mongodb_gte_26 def test_queryset_aggregation_framework(self): class Person(Document): name = StringField() diff --git a/tests/utils.py b/tests/utils.py index 39d3681e..5345f75e 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -61,14 +61,14 @@ def _decorated_with_ver_requirement(func, version): return _inner -def needs_mongodb_v26(func): +def requires_mongodb_gte_26(func): """Raise a SkipTest exception if we're working with MongoDB version lower than v2.6. """ return _decorated_with_ver_requirement(func, MONGODB_26) -def needs_mongodb_v3(func): +def requires_mongodb_gte_3(func): """Raise a SkipTest exception if we're working with MongoDB version lower than v3.0. """ From 89416d9856a2233b8f0c309720d9d746f2ac1e47 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Fri, 5 Oct 2018 14:16:22 +0200 Subject: [PATCH 196/250] Fix deprecation warning about Hashable in py3.7 --- mongoengine/base/document.py | 2 +- mongoengine/python_support.py | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index c82d670e..ccbfa3d6 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -1,6 +1,5 @@ import copy import numbers -from collections import Hashable from functools import partial from bson import ObjectId, json_util @@ -19,6 +18,7 @@ from mongoengine.base.fields import ComplexBaseField from mongoengine.common import _import_class from mongoengine.errors import (FieldDoesNotExist, InvalidDocumentError, LookUpError, OperationError, ValidationError) +from mongoengine.python_support import Hashable __all__ = ('BaseDocument', 'NON_FIELD_ERRORS') diff --git a/mongoengine/python_support.py b/mongoengine/python_support.py index e884b4ea..7e8e108f 100644 --- a/mongoengine/python_support.py +++ b/mongoengine/python_support.py @@ -19,3 +19,10 @@ if not six.PY3: pass else: StringIO = cStringIO.StringIO + + +if six.PY3: + from collections.abc import Hashable +else: + # raises DeprecationWarnings in Python >=3.7 + from collections import Hashable From adfb039ba636202ce034e6104dc27f5bf74601c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sat, 6 Oct 2018 21:44:25 +0200 Subject: [PATCH 197/250] Improve overall code quality (based on pylint findings) --- docs/upgrade.rst | 5 ++++ mongoengine/base/common.py | 2 +- mongoengine/base/datastructures.py | 19 ++++++--------- mongoengine/base/document.py | 3 --- mongoengine/base/metaclasses.py | 39 ++++++++++++++---------------- mongoengine/base/utils.py | 2 +- mongoengine/document.py | 4 +-- mongoengine/errors.py | 1 + mongoengine/fields.py | 25 +++++++++---------- mongoengine/queryset/base.py | 15 +++++------- mongoengine/queryset/queryset.py | 7 ------ mongoengine/queryset/transform.py | 1 - 12 files changed, 53 insertions(+), 70 deletions(-) diff --git a/docs/upgrade.rst b/docs/upgrade.rst index 65d13359..082dbadc 100644 --- a/docs/upgrade.rst +++ b/docs/upgrade.rst @@ -6,6 +6,11 @@ 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 diff --git a/mongoengine/base/common.py b/mongoengine/base/common.py index dd177920..d747c8cc 100644 --- a/mongoengine/base/common.py +++ b/mongoengine/base/common.py @@ -19,7 +19,7 @@ def get_document(name): # 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) diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index 0197ad10..17da7a2c 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -1,4 +1,3 @@ -import itertools import weakref from bson import DBRef @@ -18,10 +17,9 @@ class BaseDict(dict): _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 super(BaseDict, self).__init__(dict_items) @@ -32,11 +30,11 @@ class BaseDict(dict): EmbeddedDocument = _import_class('EmbeddedDocument') if isinstance(value, EmbeddedDocument) and value._instance is None: value._instance = self._instance - elif not isinstance(value, BaseDict) and isinstance(value, dict): + 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 not isinstance(value, BaseList) and isinstance(value, list): + 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 @@ -103,10 +101,9 @@ class BaseList(list): _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 super(BaseList, self).__init__(list_items) @@ -117,11 +114,11 @@ class BaseList(list): EmbeddedDocument = _import_class('EmbeddedDocument') if isinstance(value, EmbeddedDocument) and value._instance is None: value._instance = self._instance - elif not isinstance(value, BaseDict) and isinstance(value, dict): + elif isinstance(value, dict) and not isinstance(value, BaseDict): value = BaseDict(value, None, '%s.%s' % (self._name, key)) super(BaseList, self).__setitem__(key, value) value._instance = self._instance - elif not isinstance(value, BaseList) and isinstance(value, list): + elif isinstance(value, list) and not isinstance(value, BaseList): value = BaseList(value, None, '%s.%s' % (self._name, key)) super(BaseList, self).__setitem__(key, value) value._instance = self._instance diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index c82d670e..b3b6c974 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -91,9 +91,6 @@ class BaseDocument(object): value = getattr(self, key, None) setattr(self, key, value) - if '_cls' not in values: - self._cls = self._class_name - # Set passed values after initialisation if self._dynamic: dynamic_data = {} diff --git a/mongoengine/base/metaclasses.py b/mongoengine/base/metaclasses.py index 481408bf..a3220c6c 100644 --- a/mongoengine/base/metaclasses.py +++ b/mongoengine/base/metaclasses.py @@ -18,14 +18,14 @@ class DocumentMetaclass(type): """Metaclass for all documents.""" # TODO lower complexity of this method - def __new__(cls, name, bases, attrs): - flattened_bases = cls._get_bases(bases) - super_new = super(DocumentMetaclass, cls).__new__ + 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'] = [] @@ -138,7 +138,7 @@ 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: @@ -147,7 +147,7 @@ class DocumentMetaclass(type): base._types = base._subclasses # TODO depreciate _types (Document, EmbeddedDocument, DictField, - CachedReferenceField) = cls._import_classes() + CachedReferenceField) = mcs._import_classes() if issubclass(new_class, Document): new_class._collection = None @@ -219,29 +219,26 @@ class DocumentMetaclass(type): 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') @@ -254,9 +251,9 @@ 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: @@ -319,7 +316,7 @@ class TopLevelDocumentMetaclass(DocumentMetaclass): 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 @@ -360,7 +357,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 @@ -394,7 +391,7 @@ class TopLevelDocumentMetaclass(DocumentMetaclass): '_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 = cls.get_auto_id_names(new_class) + id_name, id_db_name = mcs.get_auto_id_names(new_class) new_class._auto_id_field = True new_class._meta['id_field'] = id_name new_class._fields[id_name] = ObjectIdField(db_field=id_db_name) @@ -419,7 +416,7 @@ class TopLevelDocumentMetaclass(DocumentMetaclass): return new_class @classmethod - def get_auto_id_names(cls, new_class): + 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()): diff --git a/mongoengine/base/utils.py b/mongoengine/base/utils.py index 288c2f3e..8f27ee14 100644 --- a/mongoengine/base/utils.py +++ b/mongoengine/base/utils.py @@ -15,7 +15,7 @@ class LazyRegexCompiler(object): self._compiled_regex = re.compile(self._pattern, self._flags) return self._compiled_regex - def __get__(self, obj, objtype): + def __get__(self, instance, owner): return self.compiled_regex def __set__(self, instance, value): diff --git a/mongoengine/document.py b/mongoengine/document.py index cdeed4c6..0b07cfa2 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -170,8 +170,8 @@ class Document(six.with_metaclass(TopLevelDocumentMetaclass, BaseDocument)): """ if self.pk is None: return super(BaseDocument, self).__hash__() - else: - return hash(self.pk) + + return hash(self.pk) @classmethod def _get_db(cls): diff --git a/mongoengine/errors.py b/mongoengine/errors.py index 131596d1..986ebf73 100644 --- a/mongoengine/errors.py +++ b/mongoengine/errors.py @@ -71,6 +71,7 @@ class ValidationError(AssertionError): _message = None 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 diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 85602215..e4e8ee2c 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -140,8 +140,7 @@ class URLField(StringField): r'(?:/?|[/?]\S+)$', re.IGNORECASE) _URL_SCHEMES = ['http', 'https', 'ftp', 'ftps'] - def __init__(self, verify_exists=False, url_regex=None, schemes=None, **kwargs): - self.verify_exists = verify_exists + def __init__(self, url_regex=None, schemes=None, **kwargs): self.url_regex = url_regex or self._URL_REGEX self.schemes = schemes or self._URL_SCHEMES super(URLField, self).__init__(**kwargs) @@ -274,14 +273,14 @@ class IntField(BaseField): def to_python(self, value): try: value = int(value) - except ValueError: + except (TypeError, ValueError): pass return value def validate(self, value): try: value = int(value) - except Exception: + except (TypeError, ValueError): self.error('%s could not be converted to int' % value) if self.min_value is not None and value < self.min_value: @@ -307,7 +306,7 @@ class LongField(BaseField): def to_python(self, value): try: value = long(value) - except ValueError: + except (TypeError, ValueError): pass return value @@ -317,7 +316,7 @@ class LongField(BaseField): def validate(self, value): try: value = long(value) - except Exception: + except (TypeError, ValueError): self.error('%s could not be converted to long' % value) if self.min_value is not None and value < self.min_value: @@ -416,7 +415,7 @@ class DecimalField(BaseField): # Convert to string for python 2.6 before casting to Decimal try: value = decimal.Decimal('%s' % value) - except decimal.InvalidOperation: + except (TypeError, ValueError, decimal.InvalidOperation): return value return value.quantize(decimal.Decimal('.%s' % ('0' * self.precision)), rounding=self.rounding) @@ -433,7 +432,7 @@ class DecimalField(BaseField): value = six.text_type(value) try: value = decimal.Decimal(value) - except Exception as exc: + except (TypeError, ValueError, decimal.InvalidOperation) as exc: self.error('Could not convert value to decimal: %s' % exc) if self.min_value is not None and value < self.min_value: @@ -852,8 +851,7 @@ class ListField(ComplexBaseField): def validate(self, value): """Make sure that a list of valid fields is being used.""" - if (not isinstance(value, (list, tuple, QuerySet)) or - isinstance(value, six.string_types)): + if not isinstance(value, (list, tuple, QuerySet)): self.error('Only lists and tuples may be used in a list field') super(ListField, self).validate(value) @@ -1953,8 +1951,7 @@ class SequenceField(BaseField): self.collection_name = collection_name or self.COLLECTION_NAME self.db_alias = db_alias or DEFAULT_CONNECTION_NAME self.sequence_name = sequence_name - self.value_decorator = (callable(value_decorator) and - value_decorator or self.VALUE_DECORATOR) + self.value_decorator = value_decorator if callable(value_decorator) else self.VALUE_DECORATOR super(SequenceField, self).__init__(*args, **kwargs) def generate(self): @@ -2063,7 +2060,7 @@ class UUIDField(BaseField): if not isinstance(value, six.string_types): value = six.text_type(value) return uuid.UUID(value) - except Exception: + except (ValueError, TypeError, AttributeError): return original_value return value @@ -2085,7 +2082,7 @@ class UUIDField(BaseField): value = str(value) try: uuid.UUID(value) - except Exception as exc: + except (ValueError, TypeError, AttributeError) as exc: self.error('Could not convert to UUID: %s' % exc) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 0be48654..d3a5f050 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -38,8 +38,6 @@ CASCADE = 2 DENY = 3 PULL = 4 -RE_TYPE = type(re.compile('')) - class BaseQuerySet(object): """A set of results returned from a query. Wraps a MongoDB cursor, @@ -356,7 +354,7 @@ class BaseQuerySet(object): try: inserted_result = insert_func(raw) - ids = return_one and [inserted_result.inserted_id] or inserted_result.inserted_ids + ids = [inserted_result.inserted_id] if return_one else inserted_result.inserted_ids except pymongo.errors.DuplicateKeyError as err: message = 'Could not save document (%s)' raise NotUniqueError(message % six.text_type(err)) @@ -377,14 +375,14 @@ class BaseQuerySet(object): if not load_bulk: signals.post_bulk_insert.send( self._document, documents=docs, loaded=False, **signal_kwargs) - return return_one and ids[0] or ids + return ids[0] if return_one else ids documents = self.in_bulk(ids) results = [] for obj_id in ids: results.append(documents.get(obj_id)) signals.post_bulk_insert.send( self._document, documents=results, loaded=True, **signal_kwargs) - return return_one and results[0] or results + return results[0] if return_one else results def count(self, with_limit_and_skip=False): """Count the selected elements in the query. @@ -974,11 +972,10 @@ class BaseQuerySet(object): # explicitly included, and then more complicated operators such as # $slice. def _sort_key(field_tuple): - key, value = field_tuple - if isinstance(value, (int)): + _, value = field_tuple + if isinstance(value, int): return value # 0 for exclusion, 1 for inclusion - else: - return 2 # so that complex values appear last + return 2 # so that complex values appear last fields = sorted(cleaned_fields, key=_sort_key) diff --git a/mongoengine/queryset/queryset.py b/mongoengine/queryset/queryset.py index f9fed7b7..c7c593b1 100644 --- a/mongoengine/queryset/queryset.py +++ b/mongoengine/queryset/queryset.py @@ -186,10 +186,3 @@ class QuerySetNoCache(BaseQuerySet): queryset = self.clone() queryset.rewind() return queryset - - -class QuerySetNoDeRef(QuerySet): - """Special no_dereference QuerySet""" - - def __dereference(items, max_depth=1, instance=None, name=None): - return items diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index 2effa249..41f99bbc 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -429,7 +429,6 @@ def _infer_geometry(value): '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? - # TODO: should both TypeError and IndexError be alike interpreted? try: value[0][0][0] From 68c7764c63e3c7c5b854271cbdac29c748c55249 Mon Sep 17 00:00:00 2001 From: Luca Di Gaspero Date: Mon, 8 Oct 2018 17:06:08 +0200 Subject: [PATCH 198/250] Small fix to ensure to use the right document after pre_save_post_validation hook, which might modify the document itself (e.g., for adding a etag). --- mongoengine/document.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/mongoengine/document.py b/mongoengine/document.py index cdeed4c6..220047d8 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -368,6 +368,8 @@ class Document(six.with_metaclass(TopLevelDocumentMetaclass, BaseDocument)): signals.pre_save_post_validation.send(self.__class__, document=self, created=created, **signal_kwargs) + # it might be refreshed by the pre_save_post_validation hook, e.g., for etag generation + doc = self.to_mongo() if self._meta.get('auto_create_index', True): self.ensure_indexes() From 3c5c3b50261e92fb94e3573e8d301c843a49615b Mon Sep 17 00:00:00 2001 From: Arto Jantunen Date: Wed, 3 Oct 2018 09:56:59 +0300 Subject: [PATCH 199/250] Fix invalid isinstance check in ListField.validate Using QuerySet directly would fail if QuerySetNoCache was used. Sadly the test suite does not have a case where QuerySet would appear here, so adding a test for this special case is not trivial. --- mongoengine/fields.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index e4e8ee2c..04e89256 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -34,7 +34,8 @@ from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db from mongoengine.document import Document, EmbeddedDocument from mongoengine.errors import DoesNotExist, InvalidQueryError, ValidationError from mongoengine.python_support import StringIO -from mongoengine.queryset import DO_NOTHING, QuerySet +from mongoengine.queryset import DO_NOTHING +from mongoengine.queryset.base import BaseQuerySet try: from PIL import Image, ImageOps @@ -851,7 +852,7 @@ class ListField(ComplexBaseField): def validate(self, value): """Make sure that a list of valid fields is being used.""" - if not isinstance(value, (list, tuple, QuerySet)): + if not isinstance(value, (list, tuple, BaseQuerySet)): self.error('Only lists and tuples may be used in a list field') super(ListField, self).validate(value) From 556f7e85fce9703bb3325af1534f861a01867f25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Wed, 10 Oct 2018 23:13:34 +0200 Subject: [PATCH 200/250] Improve the error message that mentions that Document cant be subclassed --- mongoengine/base/metaclasses.py | 3 ++- tests/document/inheritance.py | 8 +++++--- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/mongoengine/base/metaclasses.py b/mongoengine/base/metaclasses.py index 481408bf..ae191706 100644 --- a/mongoengine/base/metaclasses.py +++ b/mongoengine/base/metaclasses.py @@ -121,7 +121,8 @@ class DocumentMetaclass(type): # inheritance of classes where inheritance is set to False 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' % + 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 diff --git a/tests/document/inheritance.py b/tests/document/inheritance.py index b2ab1b52..2789ad8e 100644 --- a/tests/document/inheritance.py +++ b/tests/document/inheritance.py @@ -258,9 +258,10 @@ class InheritanceTest(unittest.TestCase): name = StringField() # can't inherit because Animal didn't explicitly allow inheritance - with self.assertRaises(ValueError): + with self.assertRaises(ValueError) as cm: class Dog(Animal): pass + 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() @@ -277,9 +278,10 @@ class InheritanceTest(unittest.TestCase): name = StringField() meta = {'allow_inheritance': True} - with self.assertRaises(ValueError): + with self.assertRaises(ValueError) as cm: class Mammal(Animal): meta = {'allow_inheritance': False} + 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 @@ -292,7 +294,7 @@ class InheritanceTest(unittest.TestCase): class Animal(FinalDocument): name = StringField() - with self.assertRaises(ValueError): + with self.assertRaises(ValueError) as cm: class Mammal(Animal): pass From 59a06a242d5d7681bac6280291ba1c97f5f2b621 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Mon, 15 Oct 2018 22:32:11 +0200 Subject: [PATCH 201/250] Fix a bug when using a ReferenceField(AbstractClass) #1920 --- mongoengine/fields.py | 9 ------- tests/document/inheritance.py | 48 +++++++++++++++++++++++++++++------ 2 files changed, 40 insertions(+), 17 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 04e89256..284c614d 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1176,15 +1176,6 @@ class ReferenceField(BaseField): self.error('You can only reference documents once they have been ' 'saved to the database') - if ( - self.document_type._meta.get('abstract') and - not isinstance(value, self.document_type) - ): - self.error( - '%s is not an instance of abstract reference type %s' % ( - value, self.document_type._class_name) - ) - def lookup_member(self, member_name): return self.document_type._fields.get(member_name) diff --git a/tests/document/inheritance.py b/tests/document/inheritance.py index b2ab1b52..735c68da 100644 --- a/tests/document/inheritance.py +++ b/tests/document/inheritance.py @@ -2,14 +2,11 @@ import unittest import warnings -from datetime import datetime - from tests.fixtures import Base -from mongoengine import Document, EmbeddedDocument, connect +from mongoengine import Document, EmbeddedDocument, connect, ReferenceField,\ + BooleanField, GenericReferenceField, IntField, StringField from mongoengine.connection import get_db -from mongoengine.fields import (BooleanField, GenericReferenceField, - IntField, StringField) __all__ = ('InheritanceTest', ) @@ -300,6 +297,41 @@ class InheritanceTest(unittest.TestCase): doc = Animal(name='dog') 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): @@ -358,11 +390,11 @@ class InheritanceTest(unittest.TestCase): meta = {'abstract': True, 'allow_inheritance': False} - bkk = City(continent='asia') - self.assertEqual(None, bkk.pk) + 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(bkk, 'pk', 1) + setattr(city, 'pk', 1) def test_allow_inheritance_embedded_document(self): """Ensure embedded documents respect inheritance.""" From 0fa6610fdb3ceec259d28598903ce8363074c156 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Fri, 5 Oct 2018 14:13:46 +0200 Subject: [PATCH 202/250] Fix complex combinations of DictField(ListField(ReferenceField)) (#1453) --- mongoengine/base/document.py | 4 +-- mongoengine/dereference.py | 50 +++++++++++++++++++++++------------- tests/fields/fields.py | 47 +++++++++++++++++++++++++++++++-- 3 files changed, 78 insertions(+), 23 deletions(-) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index c82d670e..fd8fec80 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -3,9 +3,7 @@ import numbers from collections import Hashable from functools import partial -from bson import ObjectId, json_util -from bson.dbref import DBRef -from bson.son import SON +from bson import DBRef, ObjectId, SON, json_util import pymongo import six diff --git a/mongoengine/dereference.py b/mongoengine/dereference.py index 6c993223..dbcbc036 100644 --- a/mongoengine/dereference.py +++ b/mongoengine/dereference.py @@ -52,26 +52,40 @@ class DeReference(object): [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 items.iteritems(): + 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'): - - def _get_items(items): - new_items = [] - for v in items: - if isinstance(v, list): - new_items.append(_get_items(v)) - elif not isinstance(v, (DBRef, Document)): - new_items.append(field.to_python(v)) - else: - new_items.append(v) - return new_items - - items = _get_items(items) + items = _get_items_from_list(items) else: - items = { - k: (v if isinstance(v, (DBRef, Document)) - else field.to_python(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) diff --git a/tests/fields/fields.py b/tests/fields/fields.py index b375822e..8abe32fc 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -1187,7 +1187,7 @@ class FieldTest(MongoDBTestCase): # aka 'del list[index]' # aka 'operator.delitem(list, index)' reset_post() - del post.info[2] # del from middle ('2') + del post.info[2] # del from middle ('2') self.assertEqual(post.info, ['0', '1', '3', '4', '5']) post.save() post.reload() @@ -1197,7 +1197,7 @@ class FieldTest(MongoDBTestCase): # aka 'del list[i:j]' # aka 'operator.delitem(list, slice(i,j))' reset_post() - del post.info[1:3] # removes '1', '2' + del post.info[1:3] # removes '1', '2' self.assertEqual(post.info, ['0', '3', '4', '5']) post.save() post.reload() @@ -1826,6 +1826,48 @@ class FieldTest(MongoDBTestCase): 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) + def test_mapfield(self): """Ensure that the MapField handles the declared type.""" class Simple(Document): @@ -4348,6 +4390,7 @@ class TestEmbeddedDocumentField(MongoDBTestCase): class MyFailingdoc2(Document): emb = EmbeddedDocumentField('MyDoc') + class CachedReferenceFieldTest(MongoDBTestCase): def test_cached_reference_field_get_and_save(self): From 4939a7dd7cee37d90b1d257129c9db7072cbc0ac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 16 Oct 2018 22:19:41 +0200 Subject: [PATCH 203/250] update input document ids during bulk insert #1919 --- docs/changelog.rst | 2 + mongoengine/queryset/base.py | 9 ++- tests/queryset/queryset.py | 142 +++++++++++++++++++++++------------ 3 files changed, 100 insertions(+), 53 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index edc0fb1a..1757be3e 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -5,12 +5,14 @@ Changelog Development =========== - 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 #1919 - (Fill this out as you fix issues and develop your features). ======= Changes in 0.15.4 ================= - Added `DateField` #513 + Changes in 0.15.3 ================= - Subfield resolve error in generic_emdedded_document query #1651 #1652 diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index d3a5f050..9ea214cc 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -372,14 +372,17 @@ class BaseQuerySet(object): raise NotUniqueError(message % six.text_type(err)) raise OperationError(message % six.text_type(err)) + # Apply inserted_ids to documents + for doc, doc_id in zip(docs, ids): + doc.pk = doc_id + if not load_bulk: signals.post_bulk_insert.send( self._document, documents=docs, loaded=False, **signal_kwargs) return ids[0] if return_one else ids + documents = self.in_bulk(ids) - results = [] - for obj_id in ids: - results.append(documents.get(obj_id)) + results = [documents.get(obj_id) for obj_id in ids] signals.post_bulk_insert.send( self._document, documents=results, loaded=True, **signal_kwargs) return results[0] if return_one else results diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index c5004ed2..ad405bb1 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -704,38 +704,38 @@ class QuerySetTest(unittest.TestCase): self.assertRaises(ValidationError, Doc.objects().update, ed_f__str_f=1, upsert=True) def test_update_related_models(self): - class TestPerson(Document): - name = StringField() + class TestPerson(Document): + name = StringField() - class TestOrganization(Document): - name = StringField() - owner = ReferenceField(TestPerson) + class TestOrganization(Document): + name = StringField() + owner = ReferenceField(TestPerson) - TestPerson.drop_collection() - TestOrganization.drop_collection() + TestPerson.drop_collection() + TestOrganization.drop_collection() - p = TestPerson(name='p1') - p.save() - o = TestOrganization(name='o1') - o.save() + p = TestPerson(name='p1') + p.save() + o = TestOrganization(name='o1') + o.save() - o.owner = p - p.name = 'p2' + o.owner = p + p.name = 'p2' - self.assertEqual(o._get_changed_fields(), ['owner']) - self.assertEqual(p._get_changed_fields(), ['name']) + self.assertEqual(o._get_changed_fields(), ['owner']) + self.assertEqual(p._get_changed_fields(), ['name']) - o.save() + o.save() - self.assertEqual(o._get_changed_fields(), []) - self.assertEqual(p._get_changed_fields(), ['name']) # Fails; it's empty + self.assertEqual(o._get_changed_fields(), []) + self.assertEqual(p._get_changed_fields(), ['name']) # Fails; it's empty - # This will do NOTHING at all, even though we changed the name - p.save() + # This will do NOTHING at all, even though we changed the name + p.save() - p.reload() + p.reload() - self.assertEqual(p.name, 'p2') # Fails; it's still `p1` + self.assertEqual(p.name, 'p2') # Fails; it's still `p1` def test_upsert(self): self.Person.drop_collection() @@ -839,18 +839,18 @@ class QuerySetTest(unittest.TestCase): comment2 = Comment(name='testb') post1 = Post(comments=[comment1, comment2]) post2 = Post(comments=[comment2, comment2]) - blogs = [Blog(title="post %s" % i, posts=[post1, post2]) - for i in range(99)] # Check bulk insert using load_bulk=False + blogs = [Blog(title="%s" % i, posts=[post1, post2]) + for i in range(99)] with query_counter() as q: self.assertEqual(q, 0) Blog.objects.insert(blogs, load_bulk=False) if MONGO_VER == MONGODB_32: - self.assertEqual(q, 1) # 1 entry containing the list of inserts + self.assertEqual(q, 1) # 1 entry containing the list of inserts else: - self.assertEqual(q, len(blogs)) # 1 entry per doc inserted + self.assertEqual(q, len(blogs)) # 1 entry per doc inserted self.assertEqual(Blog.objects.count(), len(blogs)) @@ -858,14 +858,16 @@ class QuerySetTest(unittest.TestCase): Blog.ensure_indexes() # Check bulk insert using load_bulk=True + blogs = [Blog(title="%s" % i, posts=[post1, post2]) + for i in range(99)] with query_counter() as q: self.assertEqual(q, 0) Blog.objects.insert(blogs) if MONGO_VER == MONGODB_32: - self.assertEqual(q, 2) # 1 for insert 1 for fetch + self.assertEqual(q, 2) # 1 for insert 1 for fetch else: - self.assertEqual(q, len(blogs)+1) # + 1 to fetch all docs + self.assertEqual(q, len(blogs)+1) # + 1 to fetch all docs Blog.drop_collection() @@ -886,26 +888,10 @@ class QuerySetTest(unittest.TestCase): blog = Blog.objects.first() Blog.objects.insert(blog) - # test inserting a query set - with self.assertRaises(OperationError): - blogs = Blog.objects - Blog.objects.insert(blogs) - - # insert a new doc + # insert 1 new doc new_post = Blog(title="code123", id=ObjectId()) Blog.objects.insert(new_post) - class Author(Document): - pass - - # try inserting a different document class - with self.assertRaises(OperationError): - Blog.objects.insert(Author()) - - # try inserting a non-document - with self.assertRaises(OperationError): - Blog.objects.insert("HELLO WORLD") - Blog.drop_collection() blog1 = Blog(title="code", posts=[post1, post2]) @@ -916,20 +902,76 @@ class QuerySetTest(unittest.TestCase): Blog.drop_collection() blog1 = Blog(title="code", posts=[post1, post2]) obj_id = Blog.objects.insert(blog1, load_bulk=False) - self.assertEqual(obj_id.__class__.__name__, 'ObjectId') + self.assertIsInstance(obj_id, ObjectId) Blog.drop_collection() post3 = Post(comments=[comment1, comment1]) blog1 = Blog(title="foo", posts=[post1, post2]) blog2 = Blog(title="bar", posts=[post2, post3]) - blog3 = Blog(title="baz", posts=[post1, post2]) Blog.objects.insert([blog1, blog2]) with self.assertRaises(NotUniqueError): - Blog.objects.insert([blog2, blog3]) + Blog.objects.insert(Blog(title=blog2.title)) self.assertEqual(Blog.objects.count(), 2) + def test_bulk_insert_different_class_fails(self): + class Blog(Document): + pass + + class Author(Document): + pass + + # try inserting a different document class + with self.assertRaises(OperationError): + Blog.objects.insert(Author()) + + def test_bulk_insert_with_wrong_type(self): + class Blog(Document): + name = StringField() + + Blog.drop_collection() + Blog(name='test').save() + + with self.assertRaises(OperationError): + Blog.objects.insert("HELLO WORLD") + + with self.assertRaises(OperationError): + Blog.objects.insert({'name': 'garbage'}) + + # test inserting a query set + with self.assertRaises(OperationError) as cm: + blogs_qs = Blog.objects + Blog.objects.insert(blogs_qs) + self.assertEqual(cm.exception.message, 'Some documents have ObjectIds use doc.update() instead') + + def test_bulk_insert_update_input_document_ids(self): + class Comment(Document): + idx = IntField() + + Comment.drop_collection() + + # Test with bulk + comments = [Comment(idx=idx) for idx in range(20)] + for com in comments: + self.assertIsNone(com.id) + + returned_comments = Comment.objects.insert(comments, load_bulk=True) + + for com in comments: + self.assertIsInstance(com.id, ObjectId) + + input_mapping = {com.id: com.idx for com in comments} + saved_mapping = {com.id: com.idx for com in returned_comments} + self.assertEqual(input_mapping, saved_mapping) + + Comment.drop_collection() + + # Test with just one + comment = Comment(idx=0) + inserted_comment_id = Comment.objects.insert(comment, load_bulk=False) + self.assertEqual(comment.id, inserted_comment_id) + def test_get_changed_fields_query_count(self): """Make sure we don't perform unnecessary db operations when none of document's fields were updated. @@ -2007,7 +2049,7 @@ class QuerySetTest(unittest.TestCase): post.reload() self.assertEqual(post.tags, ['mongodb', 'python', 'java']) - #test push with singular value + # test push with singular value BlogPost.objects.filter(id=post.id).update(push__tags__0='scala') post.reload() self.assertEqual(post.tags, ['scala', 'mongodb', 'python', 'java']) @@ -2286,7 +2328,7 @@ class QuerySetTest(unittest.TestCase): class User(Document): username = StringField() - bar = GenericEmbeddedDocumentField(choices=[Bar,]) + bar = GenericEmbeddedDocumentField(choices=[Bar, ]) User.drop_collection() From a1a93a4bdda7b5ab59072b2484a39f9a00fa4d3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 16 Oct 2018 22:35:58 +0200 Subject: [PATCH 204/250] minor additions --- docs/changelog.rst | 1 - tests/queryset/queryset.py | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 1757be3e..69581a4b 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -12,7 +12,6 @@ Changes in 0.15.4 ================= - Added `DateField` #513 - Changes in 0.15.3 ================= - Subfield resolve error in generic_emdedded_document query #1651 #1652 diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index ad405bb1..0eed3e47 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -2328,7 +2328,7 @@ class QuerySetTest(unittest.TestCase): class User(Document): username = StringField() - bar = GenericEmbeddedDocumentField(choices=[Bar, ]) + bar = GenericEmbeddedDocumentField(choices=[Bar]) User.drop_collection() From 26b70e9ed3a169fab4127404f93597631bdc5aa4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 16 Oct 2018 22:55:55 +0200 Subject: [PATCH 205/250] fix test --- tests/queryset/queryset.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 0eed3e47..f4bc1dcd 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -884,9 +884,16 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(Blog.objects.count(), 2) # test inserting an existing document (shouldn't be allowed) - with self.assertRaises(OperationError): + with self.assertRaises(OperationError) as cm: blog = Blog.objects.first() Blog.objects.insert(blog) + self.assertEqual(str(cm.exception), 'Some documents have ObjectIds use doc.update() instead') + + # test inserting a query set + with self.assertRaises(OperationError) as cm: + blogs_qs = Blog.objects + Blog.objects.insert(blogs_qs) + self.assertEqual(str(cm.exception), 'Some documents have ObjectIds use doc.update() instead') # insert 1 new doc new_post = Blog(title="code123", id=ObjectId()) @@ -939,12 +946,6 @@ class QuerySetTest(unittest.TestCase): with self.assertRaises(OperationError): Blog.objects.insert({'name': 'garbage'}) - # test inserting a query set - with self.assertRaises(OperationError) as cm: - blogs_qs = Blog.objects - Blog.objects.insert(blogs_qs) - self.assertEqual(cm.exception.message, 'Some documents have ObjectIds use doc.update() instead') - def test_bulk_insert_update_input_document_ids(self): class Comment(Document): idx = IntField() From 598d6bf4c5e75ad78a8562efda1aa7e4f7c1b3ba Mon Sep 17 00:00:00 2001 From: __ROLLER__ Date: Sun, 21 Oct 2018 12:47:23 -0600 Subject: [PATCH 206/250] Update README.rst Added information on using pipenv to the Installation section --- README.rst | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/README.rst b/README.rst index 17cb3e33..4e186a85 100644 --- a/README.rst +++ b/README.rst @@ -36,9 +36,11 @@ Installation We recommend the use of `virtualenv `_ and of `pip `_. You can then use ``pip install -U mongoengine``. You may also have `setuptools `_ -and thus you can use ``easy_install -U mongoengine``. Otherwise, you can download the -source from `GitHub `_ and run ``python -setup.py install``. +and thus you can use ``easy_install -U mongoengine``. Another option is +`pipenv `_. 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 `_ and +run ``python setup.py install``. Dependencies ============ From 83fe7f7eefba10e2ad71fa68b25235d226860811 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Mon, 22 Oct 2018 21:54:46 +0200 Subject: [PATCH 207/250] Document the index option and the fact that additional options gets forwarded to pymongo's create_index method --- docs/guide/defining-documents.rst | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index bf74ad8c..be8d9a15 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -492,7 +492,9 @@ the field name with a **#**:: ] } -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. @@ -516,8 +518,12 @@ If a dictionary is passed then the following options are available: :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 @@ -736,7 +742,7 @@ document.:: .. 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 From f23b0faf4189a820827c4cc9efd75503b49a276a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 23 Oct 2018 22:10:34 +0200 Subject: [PATCH 208/250] fix some asserts in no_dereference doc --- docs/guide/querying.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/guide/querying.rst b/docs/guide/querying.rst index f1594dd2..08987835 100644 --- a/docs/guide/querying.rst +++ b/docs/guide/querying.rst @@ -456,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)) From c685ace32795fad8a320707e178581a90f642887 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 23 Oct 2018 23:55:55 +0200 Subject: [PATCH 209/250] minor improvement to index doc --- docs/guide/defining-documents.rst | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index be8d9a15..14f2ff1b 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -544,7 +544,7 @@ There are a few top level defaults for all indexes that can be set:: :attr:`index_opts` (Optional) - Set any default index options - see the `full options list `_ + Set any default index options - see the `full options list `_ :attr:`index_background` (Optional) Set the default value for if an index should be indexed in the background @@ -560,8 +560,7 @@ There are a few top level defaults for all indexes that can be set:: :attr:`index_drop_dups` (Optional) Set the default value for if an index should drop duplicates - -.. note:: Since MongoDB 3.0 drop_dups is not supported anymore. Raises a Warning + Since MongoDB 3.0 drop_dups is not supported anymore. Raises a Warning and has no effect From f6cd349a1698efe85f9501e369d26d8f6ec0b7a5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 30 Oct 2018 22:52:50 +0100 Subject: [PATCH 210/250] Fix bug when using GenericReferenceField, modifications to the referenced document are tracked in the parent #1934 --- docs/changelog.rst | 2 ++ mongoengine/base/document.py | 3 ++- tests/fields/fields.py | 32 +++++++++++++++++++++++++++++--- 3 files changed, 33 insertions(+), 4 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 69581a4b..255d3743 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -6,6 +6,8 @@ Development =========== - 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 #1919 +- Fix an harmless bug related to GenericReferenceField where modifications in the generic-referenced document + were tracked in the parent (#1934) - (Fill this out as you fix issues and develop your features). ======= Changes in 0.15.4 diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 66217921..aad027e5 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -528,6 +528,7 @@ class BaseDocument(object): EmbeddedDocument = _import_class('EmbeddedDocument') DynamicEmbeddedDocument = _import_class('DynamicEmbeddedDocument') ReferenceField = _import_class('ReferenceField') + GenericReferenceField = _import_class('GenericReferenceField') SortedListField = _import_class('SortedListField') changed_fields = [] @@ -560,7 +561,7 @@ class BaseDocument(object): elif (isinstance(data, (list, tuple, dict)) and db_field_name not in changed_fields): if (hasattr(field, 'field') and - isinstance(field.field, ReferenceField)): + isinstance(field.field, (ReferenceField, GenericReferenceField))): continue elif isinstance(field, SortedListField) and field._ordering: # if ordering is affected whole list is changed diff --git a/tests/fields/fields.py b/tests/fields/fields.py index b375822e..084be71f 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -1187,7 +1187,7 @@ class FieldTest(MongoDBTestCase): # aka 'del list[index]' # aka 'operator.delitem(list, index)' reset_post() - del post.info[2] # del from middle ('2') + del post.info[2] # del from middle ('2') self.assertEqual(post.info, ['0', '1', '3', '4', '5']) post.save() post.reload() @@ -1197,7 +1197,7 @@ class FieldTest(MongoDBTestCase): # aka 'del list[i:j]' # aka 'operator.delitem(list, slice(i,j))' reset_post() - del post.info[1:3] # removes '1', '2' + del post.info[1:3] # removes '1', '2' self.assertEqual(post.info, ['0', '3', '4', '5']) post.save() post.reload() @@ -2816,7 +2816,32 @@ class FieldTest(MongoDBTestCase): doc = Doc.objects.get(ref=DBRef('doc', doc1.pk)) self.assertEqual(doc, doc2) - def test_generic_reference_filter_by_objectid(self): + def test_generic_reference_is_not_tracked_in_parent_doc(self): + """Ensure that modifications of related documents (through generic reference) don't influence + the owner changed fields (#1934) + """ + class Doc1(Document): + name = StringField() + + class Doc2(Document): + ref = GenericReferenceField() + refs = ListField(GenericReferenceField()) + + Doc1.drop_collection() + Doc2.drop_collection() + + doc1 = Doc1(name='garbage1').save() + doc11 = Doc1(name='garbage11').save() + doc2 = Doc2(ref=doc1, refs=[doc11]).save() + + doc2.ref.name = 'garbage2' + self.assertEqual(doc2._get_changed_fields(), []) + + doc2.refs[0].name = 'garbage3' + self.assertEqual(doc2._get_changed_fields(), []) + self.assertEqual(doc2._delta(), ({}, {})) + + def test_generic_reference_field(self): """Ensure we can search for a specific generic reference by providing its DBRef. """ @@ -4348,6 +4373,7 @@ class TestEmbeddedDocumentField(MongoDBTestCase): class MyFailingdoc2(Document): emb = EmbeddedDocumentField('MyDoc') + class CachedReferenceFieldTest(MongoDBTestCase): def test_cached_reference_field_get_and_save(self): From 983474b2bdc33cc5550d8c9e2c45b166c64bd029 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 30 Oct 2018 23:40:46 +0100 Subject: [PATCH 211/250] Ignore 2 more flake8 warnings (introduced in latest flake8 3.6.0 release) --- mongoengine/queryset/base.py | 4 ++-- setup.cfg | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 9ea214cc..6c36d984 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -1872,8 +1872,8 @@ class BaseQuerySet(object): # Substitute the correct name for the field into the javascript return '.'.join([f.db_field for f in fields]) - code = re.sub(u'\[\s*~([A-z_][A-z_0-9.]+?)\s*\]', field_sub, code) - code = re.sub(u'\{\{\s*~([A-z_][A-z_0-9.]+?)\s*\}\}', field_path_sub, + code = re.sub(r'\[\s*~([A-z_][A-z_0-9.]+?)\s*\]', field_sub, code) + code = re.sub(r'\{\{\s*~([A-z_][A-z_0-9.]+?)\s*\}\}', field_path_sub, code) return code diff --git a/setup.cfg b/setup.cfg index fd6192b8..84086601 100644 --- a/setup.cfg +++ b/setup.cfg @@ -5,7 +5,7 @@ detailed-errors=1 cover-package=mongoengine [flake8] -ignore=E501,F401,F403,F405,I201,I202 +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 From 8e18484898d15ddefd9f74c9ff5aaef2e80e0b7e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Thu, 1 Nov 2018 22:28:12 +0100 Subject: [PATCH 212/250] Add a comment on a suspicious line (#1322) --- mongoengine/fields.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index d035ff01..dca4e84b 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -991,7 +991,7 @@ class DictField(ComplexBaseField): if op in match_operators and isinstance(value, six.string_types): return StringField().prepare_query_value(op, value) - if hasattr(self.field, 'field'): + if hasattr(self.field, 'field'): # Used for instance when using DictField(ListField(IntField())) if op in ('set', 'unset') and isinstance(value, dict): return { k: self.field.prepare_query_value(op, v) From 424b3ca30806772021e888fe7214d9eb67c095bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sat, 27 Oct 2018 23:01:14 +0200 Subject: [PATCH 213/250] update changelog with changes since 0.15.3 --- docs/changelog.rst | 40 ++++++++++++++++++++++++++++++++------ mongoengine/dereference.py | 2 +- 2 files changed, 35 insertions(+), 7 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 255d3743..222c6ea8 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -4,15 +4,43 @@ Changelog Development =========== -- 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 #1919 -- Fix an harmless bug related to GenericReferenceField where modifications in the generic-referenced document - were tracked in the parent (#1934) - (Fill this out as you fix issues and develop your features). ======= -Changes in 0.15.4 +Changes in 0.16.0 ================= -- Added `DateField` #513 +- 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 ================= diff --git a/mongoengine/dereference.py b/mongoengine/dereference.py index 6c993223..44266613 100644 --- a/mongoengine/dereference.py +++ b/mongoengine/dereference.py @@ -134,7 +134,7 @@ class DeReference(object): object_map = {} for collection, dbrefs in self.reference_map.iteritems(): - # we use getattr instead of hasattr because as hasattr swallows any exception under python2 + # 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) From 17fa9a3b7707fa5071cc0a13c21e0cdc60d4c663 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sat, 3 Nov 2018 21:48:12 +0100 Subject: [PATCH 214/250] bump version to 0.16.0 --- mongoengine/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/__init__.py b/mongoengine/__init__.py index e6dc6b9d..6e15d8b9 100644 --- a/mongoengine/__init__.py +++ b/mongoengine/__init__.py @@ -23,7 +23,7 @@ __all__ = (list(document.__all__) + list(fields.__all__) + list(signals.__all__) + list(errors.__all__)) -VERSION = (0, 15, 3) +VERSION = (0, 16, 0) def get_version(): From 23324f0f8767b9fa268f7cf37f5f62d605074f7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 4 Nov 2018 22:13:54 +0100 Subject: [PATCH 215/250] minor fix in ImageField docstring --- mongoengine/fields.py | 9 +++------ tests/fields/fields.py | 3 ++- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index dca4e84b..e9a5e4b2 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1867,12 +1867,9 @@ class ImageField(FileField): """ A Image File storage field. - @size (width, height, force): - max size to store images, if larger will be automatically resized - ex: size=(800, 600, True) - - @thumbnail (width, height, force): - size to generate a thumbnail + :param size: max size to store images, provided as (width, height, force) + if larger, it will be automatically resized (ex: size=(800, 600, True)) + :param thumbnail_size: size to generate a thumbnail, provided as (width, height, force) .. versionadded:: 0.6 """ diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 7500bbad..ccf67031 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -618,6 +618,8 @@ class FieldTest(MongoDBTestCase): self.assertRaises(ValidationError, person.validate) person.admin = 'Yes' self.assertRaises(ValidationError, person.validate) + person.admin = 'False' + self.assertRaises(ValidationError, person.validate) def test_uuid_field_string(self): """Test UUID fields storing as String @@ -2905,7 +2907,6 @@ class FieldTest(MongoDBTestCase): for invalid_data in (2, u'Im_a_unicode', ['some_str']): self.assertRaises(ValidationError, Attachment(blob=invalid_data).validate) - def test_binary_field_primary(self): class Attachment(Document): id = BinaryField(primary_key=True) From 34e3e45843ef0475824b79b3405285a2d75d7648 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Thu, 8 Nov 2018 23:47:12 +0800 Subject: [PATCH 216/250] Use insert_one instead of deprecated one #1899 --- mongoengine/document.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index fc379b61..37d60628 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -12,7 +12,11 @@ from mongoengine.base import (BaseDict, BaseDocument, BaseList, TopLevelDocumentMetaclass, get_document) from mongoengine.common import _import_class from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db -from mongoengine.context_managers import switch_collection, switch_db +from mongoengine.context_managers import ( + set_write_concern, + switch_collection, + switch_db +) from mongoengine.errors import (InvalidDocumentError, InvalidQueryError, SaveConditionError) from mongoengine.python_support import IS_PYMONGO_3 @@ -429,11 +433,11 @@ class Document(six.with_metaclass(TopLevelDocumentMetaclass, BaseDocument)): Helper method, should only be used inside save(). """ collection = self._get_collection() + with set_write_concern(collection, write_concern) as wc_collection: + if force_insert: + return wc_collection.insert_one(doc).inserted_id - if force_insert: - return collection.insert(doc, **write_concern) - - object_id = collection.save(doc, **write_concern) + object_id = wc_collection.insert_one(doc).inserted_id # In PyMongo 3.0, the save() call calls internally the _update() call # but they forget to return the _id value passed back, therefore getting it back here From 47577f2f47cfc6974baa795ff217f29351f919e8 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Fri, 9 Nov 2018 01:44:30 +0800 Subject: [PATCH 217/250] Update existing document #1899 --- mongoengine/document.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/mongoengine/document.py b/mongoengine/document.py index 37d60628..4abecaa9 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -436,6 +436,13 @@ class Document(six.with_metaclass(TopLevelDocumentMetaclass, BaseDocument)): with set_write_concern(collection, write_concern) as wc_collection: if force_insert: return wc_collection.insert_one(doc).inserted_id + # insert_one will provoke UniqueError alongside save does not + # therefore, it need to catch and call replace_one. + if '_id' in doc: + raw_object = wc_collection.find_one_and_replace( + {'_id': doc['_id']}, doc) + if raw_object: + return doc['_id'] object_id = wc_collection.insert_one(doc).inserted_id From 2a8579a6a50b88bbd5507746a93376f7c032b3fe Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Fri, 9 Nov 2018 09:12:29 +0800 Subject: [PATCH 218/250] Update changelog #1899 --- docs/changelog.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 222c6ea8..47af2b1b 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -5,7 +5,9 @@ Changelog Development =========== - (Fill this out as you fix issues and develop your features). -======= +- Remove deprecated `save()` method and used `insert_one()` #1899 + +================= Changes in 0.16.0 ================= - Various improvements to the doc From 611094e92e7994c03ba54e68ded8a9a2d7db9175 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Fri, 9 Nov 2018 09:20:55 +0800 Subject: [PATCH 219/250] Refactor write_concern #1945 --- mongoengine/document.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index fc379b61..f2e3664c 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -297,7 +297,7 @@ class Document(six.with_metaclass(TopLevelDocumentMetaclass, BaseDocument)): return True def save(self, force_insert=False, validate=True, clean=True, - write_concern=None, cascade=None, cascade_kwargs=None, + write_concern={'w': 1}, cascade=None, cascade_kwargs=None, _refs=None, save_condition=None, signal_kwargs=None, **kwargs): """Save the :class:`~mongoengine.Document` to the database. If the document already exists, it will be updated, otherwise it will be @@ -359,9 +359,6 @@ class Document(six.with_metaclass(TopLevelDocumentMetaclass, BaseDocument)): if validate: self.validate(clean=clean) - if write_concern is None: - write_concern = {'w': 1} - doc = self.to_mongo() created = ('_id' not in doc or self._created or force_insert) From b47c5b5bfcad03d2b64ef8161f60dc288e28fd72 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Mon, 12 Nov 2018 09:53:39 +0800 Subject: [PATCH 220/250] Adhere imports into existing one #1899 --- mongoengine/document.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index 4abecaa9..0945a8ed 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -12,11 +12,9 @@ from mongoengine.base import (BaseDict, BaseDocument, BaseList, TopLevelDocumentMetaclass, get_document) from mongoengine.common import _import_class from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db -from mongoengine.context_managers import ( - set_write_concern, - switch_collection, - switch_db -) +from mongoengine.context_managers import (set_write_concern, + switch_collection, + switch_db) from mongoengine.errors import (InvalidDocumentError, InvalidQueryError, SaveConditionError) from mongoengine.python_support import IS_PYMONGO_3 From e31558318e48a5734818360e9632239efdb1a762 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Mon, 12 Nov 2018 23:12:35 +0100 Subject: [PATCH 221/250] BugFix - _cls not set in constructor #1950 --- docs/changelog.rst | 1 + mongoengine/base/document.py | 3 +++ tests/document/inheritance.py | 29 +++++++++++++++++++++++++---- 3 files changed, 29 insertions(+), 4 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 47af2b1b..1e223aa1 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -5,6 +5,7 @@ Changelog Development =========== - (Fill this out as you fix issues and develop your features). +- Fix `_cls` that is not set properly in Document constructor (regression) #1950 - Remove deprecated `save()` method and used `insert_one()` #1899 ================= diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 348ab24b..11b3a49a 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -91,6 +91,9 @@ class BaseDocument(object): value = getattr(self, key, None) setattr(self, key, value) + if '_cls' not in values: + self._cls = self._class_name + # Set passed values after initialisation if self._dynamic: dynamic_data = {} diff --git a/tests/document/inheritance.py b/tests/document/inheritance.py index b4ba6058..32e3ed29 100644 --- a/tests/document/inheritance.py +++ b/tests/document/inheritance.py @@ -2,11 +2,11 @@ import unittest import warnings -from tests.fixtures import Base - -from mongoengine import Document, EmbeddedDocument, connect, ReferenceField,\ - BooleanField, GenericReferenceField, IntField, StringField +from mongoengine import (BooleanField, Document, EmbeddedDocument, + EmbeddedDocumentField, GenericReferenceField, + IntField, ReferenceField, StringField, connect) from mongoengine.connection import get_db +from tests.fixtures import Base __all__ = ('InheritanceTest', ) @@ -23,6 +23,27 @@ class InheritanceTest(unittest.TestCase): continue 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')) + assert test_doc._cls == 'DataDoc' + assert test_doc.embed._cls == 'EmbedData' + test_doc.save() + saved_doc = DataDoc.objects.with_id(test_doc.id) + assert test_doc._cls == saved_doc._cls + assert test_doc.embed._cls == saved_doc.embed._cls + test_doc.delete() + def test_superclasses(self): """Ensure that the correct list of superclasses is assembled. """ From c306d42d08cce474fa4f46070404c221255150e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 11 Nov 2018 22:42:15 +0100 Subject: [PATCH 222/250] Fix bug #1733 of _delta method (Issue with DynamicDocument and default value) + add test case --- docs/changelog.rst | 1 + mongoengine/base/document.py | 34 +++++++++++++++------------------- tests/fields/fields.py | 25 +++++++++++++++++++++++++ 3 files changed, 41 insertions(+), 19 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 47af2b1b..7fdf5e9c 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -5,6 +5,7 @@ Changelog Development =========== - (Fill this out as you fix issues and develop your features). +- 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 ================= diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 348ab24b..c2f83932 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -579,7 +579,6 @@ class BaseDocument(object): set_fields = self._get_changed_fields() unset_data = {} - parts = [] if hasattr(self, '_changed_fields'): set_data = {} # Fetch each set item from its path @@ -589,15 +588,13 @@ class BaseDocument(object): new_path = [] for p in parts: if isinstance(d, (ObjectId, DBRef)): + # Don't dig in the references break - elif isinstance(d, list) and p.lstrip('-').isdigit(): - if p[0] == '-': - p = str(len(d) + int(p)) - try: - d = d[int(p)] - except IndexError: - d = None + elif isinstance(d, list) and p.isdigit(): + # An item of a list (identified by its index) is updated + d = d[int(p)] elif hasattr(d, 'get'): + # dict-like (dict, embedded document) d = d.get(p) new_path.append(p) path = '.'.join(new_path) @@ -609,26 +606,26 @@ class BaseDocument(object): # Determine if any changed items were actually unset. for path, value in set_data.items(): - if value or isinstance(value, (numbers.Number, bool)): + if value or isinstance(value, (numbers.Number, bool)): # Account for 0 and True that are truthy continue - # If we've set a value that ain't the default value don't unset it. - default = None + parts = path.split('.') + if (self._dynamic and len(parts) and parts[0] in self._dynamic_fields): del set_data[path] unset_data[path] = 1 continue - elif path in self._fields: + + # If we've set a value that ain't the default value don't unset it. + default = None + if path in self._fields: default = self._fields[path].default else: # Perform a full lookup for lists / embedded lookups d = self - parts = path.split('.') db_field_name = parts.pop() for p in parts: - if isinstance(d, list) and p.lstrip('-').isdigit(): - if p[0] == '-': - p = str(len(d) + int(p)) + if isinstance(d, list) and p.isdigit(): d = d[int(p)] elif (hasattr(d, '__getattribute__') and not isinstance(d, dict)): @@ -646,10 +643,9 @@ class BaseDocument(object): default = None if default is not None: - if callable(default): - default = default() + default = default() if callable(default) else default - if default != value: + if value != default: continue del set_data[path] diff --git a/tests/fields/fields.py b/tests/fields/fields.py index ccf67031..a1b586ce 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -186,6 +186,31 @@ class FieldTest(MongoDBTestCase): data_to_be_saved = sorted(person.to_mongo().keys()) self.assertEqual(data_to_be_saved, ['age', 'created', 'userid']) + def test_default_value_is_not_used_when_changing_value_to_empty_list_for_strict_doc(self): + """List field with default can be set to the empty list (strict)""" + # Issue #1733 + class Doc(Document): + x = ListField(IntField(), default=lambda: [42]) + + doc = Doc(x=[1]).save() + doc.x = [] + doc.save() + reloaded = Doc.objects.get(id=doc.id) + self.assertEqual(reloaded.x, []) + + def test_default_value_is_not_used_when_changing_value_to_empty_list_for_dyn_doc(self): + """List field with default can be set to the empty list (dynamic)""" + # Issue #1733 + class Doc(DynamicDocument): + x = ListField(IntField(), default=lambda: [42]) + + doc = Doc(x=[1]).save() + doc.x = [] + doc.y = 2 # Was triggering the bug + doc.save() + reloaded = Doc.objects.get(id=doc.id) + self.assertEqual(reloaded.x, []) + def test_default_values_when_deleting_value(self): """Ensure that default field values are used after non-default values are explicitly deleted. From 8807c0dbef50abafbcbdfa0cc27b5864369b89a3 Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Wed, 14 Nov 2018 17:10:17 +0800 Subject: [PATCH 223/250] bump version 0.16.1 --- docs/changelog.rst | 4 ++++ mongoengine/__init__.py | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 33578f01..20252039 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -5,6 +5,10 @@ Changelog Development =========== - (Fill this out as you fix issues and develop your features). + +================= +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 diff --git a/mongoengine/__init__.py b/mongoengine/__init__.py index 6e15d8b9..2a7019a3 100644 --- a/mongoengine/__init__.py +++ b/mongoengine/__init__.py @@ -23,7 +23,7 @@ __all__ = (list(document.__all__) + list(fields.__all__) + list(signals.__all__) + list(errors.__all__)) -VERSION = (0, 16, 0) +VERSION = (0, 16, 1) def get_version(): From fcbabbe35721669d3d954565a79b1787bffa31bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Tue, 20 Nov 2018 23:56:39 +0100 Subject: [PATCH 224/250] Fix but with save(write_concern=None) - introduced in 0.16.1 --- docs/changelog.rst | 5 +++++ mongoengine/document.py | 5 ++++- tests/queryset/queryset.py | 8 ++++++-- 3 files changed, 15 insertions(+), 3 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 20252039..d9742d6f 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -6,6 +6,11 @@ Development =========== - (Fill this out as you fix issues and develop your features). +================= +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 ================= diff --git a/mongoengine/document.py b/mongoengine/document.py index 53814961..0945a8ed 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -299,7 +299,7 @@ class Document(six.with_metaclass(TopLevelDocumentMetaclass, BaseDocument)): return True def save(self, force_insert=False, validate=True, clean=True, - write_concern={'w': 1}, cascade=None, cascade_kwargs=None, + write_concern=None, cascade=None, cascade_kwargs=None, _refs=None, save_condition=None, signal_kwargs=None, **kwargs): """Save the :class:`~mongoengine.Document` to the database. If the document already exists, it will be updated, otherwise it will be @@ -361,6 +361,9 @@ class Document(six.with_metaclass(TopLevelDocumentMetaclass, BaseDocument)): if validate: self.validate(clean=clean) + if write_concern is None: + write_concern = {'w': 1} + doc = self.to_mongo() created = ('_id' not in doc or self._created or force_insert) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index f4bc1dcd..9e251af7 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -400,13 +400,17 @@ class QuerySetTest(unittest.TestCase): self.Person.drop_collection() write_concern = {"fsync": True} - author = self.Person.objects.create(name='Test User') author.save(write_concern=write_concern) + # Ensure no regression of #1958 + author = self.Person(name='Test User2') + author.save(write_concern=None) # will default to {w: 1} + result = self.Person.objects.update( set__name='Ross', write_concern={"w": 1}) - self.assertEqual(result, 1) + + self.assertEqual(result, 2) result = self.Person.objects.update( set__name='Ross', write_concern={"w": 0}) self.assertEqual(result, None) From 1894003f8a704f516a1f246fd463f78a1bcc0bf6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Wed, 21 Nov 2018 12:37:42 +0100 Subject: [PATCH 225/250] bump version to 0.16.2 --- mongoengine/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/__init__.py b/mongoengine/__init__.py index 2a7019a3..4b4dddc9 100644 --- a/mongoengine/__init__.py +++ b/mongoengine/__init__.py @@ -23,7 +23,7 @@ __all__ = (list(document.__all__) + list(fields.__all__) + list(signals.__all__) + list(errors.__all__)) -VERSION = (0, 16, 1) +VERSION = (0, 16, 2) def get_version(): From 352b23331b8486761415a117f9c017efb90569c6 Mon Sep 17 00:00:00 2001 From: Trevor Hall Date: Wed, 5 Dec 2018 20:18:48 -0600 Subject: [PATCH 226/250] Fix bug #1965 of $position and $push operators do not work with list in an EmbeddedDocument. Set key value to joined parts excluding the index at the end. Added test case --- AUTHORS | 1 + mongoengine/queryset/transform.py | 2 +- tests/document/instance.py | 18 +++++++++++++++++- 3 files changed, 19 insertions(+), 2 deletions(-) diff --git a/AUTHORS b/AUTHORS index b38825dc..5998520a 100644 --- a/AUTHORS +++ b/AUTHORS @@ -247,3 +247,4 @@ that much better: * 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) diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index 41f99bbc..2d22c350 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -345,7 +345,7 @@ def update(_doc_cls=None, **update): value = {key: {'$each': value}} elif op in ('push', 'pushAll'): if parts[-1].isdigit(): - key = parts[0] + key = '.'.join(parts[0:-1]) position = int(parts[-1]) # $position expects an iterable. If pushing a single value, # wrap it in a list. diff --git a/tests/document/instance.py b/tests/document/instance.py index ad22c086..5319ace4 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -842,10 +842,16 @@ class InstanceTest(MongoDBTestCase): @requires_mongodb_gte_26 def test_modify_with_positional_push(self): + class Content(EmbeddedDocument): + keywords = ListField(StringField()) + class BlogPost(Document): tags = ListField(StringField()) + content = EmbeddedDocumentField(Content) + + post = BlogPost.objects.create( + tags=['python'], content=Content(keywords=['ipsum'])) - post = BlogPost.objects.create(tags=['python']) self.assertEqual(post.tags, ['python']) post.modify(push__tags__0=['code', 'mongo']) self.assertEqual(post.tags, ['code', 'mongo', 'python']) @@ -856,6 +862,16 @@ class InstanceTest(MongoDBTestCase): ['code', 'mongo', 'python'] ) + self.assertEqual(post.content.keywords, ['ipsum']) + post.modify(push__content__keywords__0=['lorem']) + self.assertEqual(post.content.keywords, ['lorem', 'ipsum']) + + # Assert same order of the list items is maintained in the db + self.assertEqual( + BlogPost._get_collection().find_one({'_id': post.pk})['content']['keywords'], + ['lorem', 'ipsum'] + ) + def test_save(self): """Ensure that a document may be saved in the database.""" From d3b4af116eb9bdc0f1ec280b79a9be0a9920b22a Mon Sep 17 00:00:00 2001 From: Trevor Hall Date: Wed, 5 Dec 2018 23:35:36 -0600 Subject: [PATCH 227/250] Add fix to changelog.rst #1965 --- docs/changelog.rst | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index d9742d6f..30b88165 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -6,6 +6,11 @@ Development =========== - (Fill this out as you fix issues and develop your features). +================= +Changes in 0.16.3 +================= +- Fix $push with $position operator not working with lists in embedded document #1965 + ================= Changes in 0.16.2 ================= From a03fe234d0cd5b1f4054536b074b14e0a8e7488e Mon Sep 17 00:00:00 2001 From: Erdenezul Batmunkh Date: Thu, 6 Dec 2018 16:22:00 +0800 Subject: [PATCH 228/250] bump version 0.16.3 --- mongoengine/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/__init__.py b/mongoengine/__init__.py index 4b4dddc9..2b78d4e6 100644 --- a/mongoengine/__init__.py +++ b/mongoengine/__init__.py @@ -23,7 +23,7 @@ __all__ = (list(document.__all__) + list(fields.__all__) + list(signals.__all__) + list(errors.__all__)) -VERSION = (0, 16, 2) +VERSION = (0, 16, 3) def get_version(): From 48a691e722460a3bfb130a08a3c863c9fd7170ef Mon Sep 17 00:00:00 2001 From: amir-almusawi Date: Fri, 7 Dec 2018 22:08:05 -0600 Subject: [PATCH 229/250] fixed small typographical error --- docs/guide/defining-documents.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index 14f2ff1b..4449b00b 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -155,7 +155,7 @@ arguments can be set on all fields: 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'), From 72ebaa52e9330a063d7d45a72ce65710498ef99f Mon Sep 17 00:00:00 2001 From: Tom Floyer Date: Sat, 8 Dec 2018 22:10:10 +0300 Subject: [PATCH 230/250] Ensure that QuerySet.only() works correctly after QuerySet.count() This test checks if .only() method of QuerySet instance works after using .count() method. --- tests/queryset/queryset.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 9e251af7..b44c36df 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4720,6 +4720,28 @@ class QuerySetTest(unittest.TestCase): 'password_salt').only('email').to_json() self.assertEqual('[{"email": "ross@example.com"}]', serialized_user) + def test_only_after_count(self): + """Test that only() works after count()""" + + class User(Document): + name = StringField() + age = IntField() + address = StringField() + User.drop_collection() + User(name="User", age=50, + address="Moscow, Russia").save() + + user_queryset = User.objects(age=50) + + result = user_queryset.only("name", "age").as_pymongo().first() + self.assertEqual(result, {"name": "User", "age": 50}) + + result = user_queryset.count() + self.assertEqual(result, 1) + + result = user_queryset.only("name", "age").as_pymongo().first() + self.assertEqual(result, {"name": "User", "age": 50}) + def test_no_dereference(self): class Organization(Document): From 3194a37fcb9654458373ffe0a738038003f7e521 Mon Sep 17 00:00:00 2001 From: Tom Floyer Date: Sat, 8 Dec 2018 22:14:43 +0300 Subject: [PATCH 231/250] Reset cursor object after .count() This change fixes incorrect result of .only() method of QuerySet instance after using .count(). --- mongoengine/queryset/base.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 6c36d984..862a1826 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -396,7 +396,9 @@ class BaseQuerySet(object): """ if self._limit == 0 and with_limit_and_skip is False or self._none: return 0 - return self._cursor.count(with_limit_and_skip=with_limit_and_skip) + count = self._cursor.count(with_limit_and_skip=with_limit_and_skip) + self._cursor_obj = None + return count def delete(self, write_concern=None, _from_doc_delete=False, cascade_refs=None): From c88ea40b576157d6e886b1d26ef99ea09502f0c3 Mon Sep 17 00:00:00 2001 From: Tom Floyer Date: Sat, 8 Dec 2018 22:32:46 +0300 Subject: [PATCH 232/250] Updated AUTHORS --- AUTHORS | 1 + 1 file changed, 1 insertion(+) diff --git a/AUTHORS b/AUTHORS index 5998520a..880dfad1 100644 --- a/AUTHORS +++ b/AUTHORS @@ -248,3 +248,4 @@ that much better: * 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) \ No newline at end of file From 1319e422ea236d914b72c4a90835e6f4e18d80d8 Mon Sep 17 00:00:00 2001 From: Tom Floyer Date: Sat, 8 Dec 2018 22:33:17 +0300 Subject: [PATCH 233/250] Updated docs/changelog.rst --- docs/changelog.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/changelog.rst b/docs/changelog.rst index 30b88165..def5cc34 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -5,6 +5,7 @@ Changelog Development =========== - (Fill this out as you fix issues and develop your features). +- Fix .only() working improperly after using .count() of the same instance of QuerySet ================= Changes in 0.16.3 From a32c89307828c49958cfed75ddcf2d24b9055ebc Mon Sep 17 00:00:00 2001 From: Hendri Karisma Date: Thu, 22 Mar 2018 20:07:52 +0700 Subject: [PATCH 234/250] in the mid DictField key can accept dollar sign --- mongoengine/fields.py | 4 +- tags | 6449 ++++++++++++++++++++++++++++++++++++++++ tests/fields/fields.py | 9 +- 3 files changed, 6459 insertions(+), 3 deletions(-) create mode 100644 tags diff --git a/mongoengine/fields.py b/mongoengine/fields.py index e9a5e4b2..9062333e 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -944,7 +944,7 @@ def key_has_dot_or_dollar(d): dictionary contains a dot or a dollar sign. """ for k, v in d.items(): - if ('.' in k or '$' in k) or (isinstance(v, dict) and key_has_dot_or_dollar(v)): + if ('.' in k or k.startswith('$')) or (isinstance(v, dict) and key_has_dot_or_dollar(v)): return True @@ -977,7 +977,7 @@ class DictField(ComplexBaseField): self.error(msg) if key_has_dot_or_dollar(value): self.error('Invalid dictionary key name - keys may not contain "."' - ' or "$" characters') + ' or startswith "$" characters') super(DictField, self).validate(value) def lookup_member(self, member_name): diff --git a/tags b/tags new file mode 100644 index 00000000..88c92b07 --- /dev/null +++ b/tags @@ -0,0 +1,6449 @@ +!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/ +!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/ +!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/ +!_TAG_PROGRAM_NAME Exuberant Ctags // +!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/ +!_TAG_PROGRAM_VERSION 5.9~svn20110310 // +A mongoengine/tests/document/indexes.py /^ class A(Document):$/;" c function:IndexesTest.test_index_no_cls +A mongoengine/tests/document/indexes.py /^ class A(Document):$/;" c function:IndexesTest.test_inherited_index +A mongoengine/tests/document/inheritance.py /^ class A(Document):$/;" c function:InheritanceTest.test_indexes_and_multiple_inheritance +A mongoengine/tests/document/inheritance.py /^ class A(EmbeddedDocument):$/;" c function:InheritanceTest.test_abstract_embedded_documents +A mongoengine/tests/document/instance.py /^ class A(Document):$/;" c function:InstanceTest.subclasses_and_unique_keys_works +A mongoengine/tests/document/instance.py /^ class A(Document):$/;" c function:InstanceTest.test_db_alias_overrides +A mongoengine/tests/document/instance.py /^ class A(Document):$/;" c function:InstanceTest.test_db_alias_propagates +A mongoengine/tests/document/instance.py /^ class A(Document):$/;" c function:InstanceTest.test_list_iter +A mongoengine/tests/document/instance.py /^ class A(Document):$/;" c function:InstanceTest.test_mutating_documents +A mongoengine/tests/fields/fields.py /^ class A(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field +A mongoengine/tests/fields/fields.py /^ class A(Document):$/;" c function:FieldTest.test_double_embedded_db_field +A mongoengine/tests/fields/fields.py /^ class A(Document):$/;" c function:FieldTest.test_double_embedded_db_field_from_son +A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_batch_size +A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_chaining +A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_count_list_embedded +A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_no_sub_classes +A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_none +A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_query_reference_to_custom_pk_doc +A mongoengine/tests/queryset/queryset.py /^ class A(EmbeddedDocument):$/;" c function:QuerySetTest.test_query_generic_embedded_document +A mongoengine/tests/queryset/transform.py /^ class A(Document):$/;" c function:TransformTest.test_chaining +A mongoengine/tests/test_context_managers.py /^ class A(Document):$/;" c function:ContextManagersTest.test_no_sub_classes +A tests/fields/fields.py /^ class A(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field +A tests/fields/fields.py /^ class A(Document):$/;" c function:FieldTest.test_double_embedded_db_field +A tests/fields/fields.py /^ class A(Document):$/;" c function:FieldTest.test_double_embedded_db_field_from_son +ALLSPHINXOPTS mongoengine/docs/Makefile /^ALLSPHINXOPTS = -d $(BUILDDIR)\/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .$/;" m +AND mongoengine/mongoengine/queryset/visitor.py /^ AND = 0$/;" v class:QNode +AbstractBlogPost mongoengine/tests/queryset/queryset.py /^ class AbstractBlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_on_abstract_document +AbstractBlogPost mongoengine/tests/queryset/queryset.py /^ class AbstractBlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_deny_on_abstract_document +AbstractBlogPost mongoengine/tests/queryset/queryset.py /^ class AbstractBlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_nullify_on_abstract_document +AbstractBlogPost mongoengine/tests/queryset/queryset.py /^ class AbstractBlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents +AbstractDoc mongoengine/tests/fields/fields.py /^ class AbstractDoc(Document):$/;" c function:FieldTest.test_drop_abstract_document +AbstractDoc tests/fields/fields.py /^ class AbstractDoc(Document):$/;" c function:FieldTest.test_drop_abstract_document +Account mongoengine/tests/document/instance.py /^ class Account(Document):$/;" c function:InstanceTest.test_instance_is_set_on_setattr +Account mongoengine/tests/document/instance.py /^ class Account(Document):$/;" c function:InstanceTest.test_instance_is_set_on_setattr_on_embedded_document_list +AcloholicDrink mongoengine/tests/document/inheritance.py /^ class AcloholicDrink(Drink):$/;" c class:InheritanceTest.test_inherited_collections.Drinker +Action mongoengine/tests/fields/fields.py /^ class Action(EmbeddedDocument):$/;" c function:FieldTest.test_map_field_lookup +Action tests/fields/fields.py /^ class Action(EmbeddedDocument):$/;" c function:FieldTest.test_map_field_lookup +Actor mongoengine/tests/document/instance.py /^ class Actor(self.Person):$/;" c function:InstanceTest.test_queryset_resurrects_dropped_collection +Address mongoengine/tests/document/dynamic.py /^ class Address(DynamicEmbeddedDocument):$/;" c function:DynamicTest.test_dynamic_embedded_works_with_only +Address mongoengine/tests/document/dynamic.py /^ class Address(EmbeddedDocument):$/;" c function:DynamicTest.test_dynamic_and_embedded +Address mongoengine/tests/document/dynamic.py /^ class Address(EmbeddedDocument):$/;" c function:DynamicTest.test_dynamic_and_embedded_dict_access +AlcoholicDrink mongoengine/tests/document/inheritance.py /^ class AlcoholicDrink(Drink):$/;" c class:InheritanceTest.test_inherited_collections.Drinker +AllWarnings mongoengine/tests/all_warnings/__init__.py /^class AllWarnings(unittest.TestCase):$/;" c +Animal mongoengine/tests/document/class_methods.py /^ class Animal(Document):$/;" c function:ClassMethodsTest.test_register_delete_rule_inherited +Animal mongoengine/tests/document/inheritance.py /^ class Animal(Base): pass$/;" c function:InheritanceTest.test_external_subclasses +Animal mongoengine/tests/document/inheritance.py /^ class Animal(Base): pass$/;" c function:InheritanceTest.test_external_superclasses +Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_abstract_documents +Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_allow_inheritance +Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_cant_turn_off_inheritance_on_subclass +Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_dynamic_declarations +Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_polymorphic_queries +Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_subclasses +Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_superclasses +Animal mongoengine/tests/document/inheritance.py /^ class Animal(FinalDocument):$/;" c function:InheritanceTest.test_allow_inheritance_abstract_document +Animal mongoengine/tests/document/instance.py /^ class Animal(Document):$/;" c function:InstanceTest.test_polymorphic_references +Animal mongoengine/tests/document/instance.py /^ class Animal(Document):$/;" c function:InstanceTest.test_reload_sharded +Animal mongoengine/tests/document/instance.py /^ class Animal(Document):$/;" c function:InstanceTest.test_reload_sharded_nested +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_get_and_save +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_cls_field +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_multiple_sequence_fields_on_docs +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_sequence_fields_reload +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_equality +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_not_set +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_passthrough +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set +Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_simple +Animal mongoengine/tests/fields/file_tests.py /^ class Animal(Document):$/;" c function:FileTest.test_complex_field_filefield +Animal mongoengine/tests/fields/file_tests.py /^ class Animal(Document):$/;" c function:FileTest.test_file_saving +Animal mongoengine/tests/queryset/queryset.py /^ class Animal(Document):$/;" c function:QuerySetTest.test_cls_query_in_subclassed_docs +Animal mongoengine/tests/queryset/queryset.py /^ class Animal(Document):$/;" c function:QuerySetTest.test_subclass_field_query +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_get_and_save +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_cls_field +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_multiple_sequence_fields_on_docs +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_sequence_fields_reload +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_equality +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_not_set +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_passthrough +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set +Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_simple +Anon mongoengine/tests/queryset/field_list.py /^ class Anon(Base):$/;" c function:OnlyExcludeAllTest.test_exclude_from_subclasses_docs +Another mongoengine/tests/test_signals.py /^ class Another(Document):$/;" c function:SignalTests.setUp +Area mongoengine/tests/document/instance.py /^ class Area(Location):$/;" c function:InstanceTest.test_document_registry_regressions +Article mongoengine/tests/document/instance.py /^ class Article(Document):$/;" c function:InstanceTest.test_repr +Article mongoengine/tests/document/instance.py /^ class Article(Document):$/;" c function:InstanceTest.test_repr_none +Asset mongoengine/tests/test_dereference.py /^ class Asset(Document):$/;" c function:FieldTest.test_multidirectional_lists +Attachment mongoengine/tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_field_primary +Attachment mongoengine/tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_field_primary_filter_by_binary_pk_as_str +Attachment mongoengine/tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_fields +Attachment mongoengine/tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_validation +Attachment mongoengine/tests/queryset/field_list.py /^ class Attachment(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_exclude_only_combining +Attachment tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_field_primary +Attachment tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_field_primary_filter_by_binary_pk_as_str +Attachment tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_fields +Attachment tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_validation +AttachmentRequired mongoengine/tests/fields/fields.py /^ class AttachmentRequired(Document):$/;" c function:FieldTest.test_binary_validation +AttachmentRequired tests/fields/fields.py /^ class AttachmentRequired(Document):$/;" c function:FieldTest.test_binary_validation +AttachmentSizeLimit mongoengine/tests/fields/fields.py /^ class AttachmentSizeLimit(Document):$/;" c function:FieldTest.test_binary_validation +AttachmentSizeLimit tests/fields/fields.py /^ class AttachmentSizeLimit(Document):$/;" c function:FieldTest.test_binary_validation +Author mongoengine/tests/fields/fields.py /^ class Author(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_validation +Author mongoengine/tests/queryset/queryset.py /^ class Author(Document):$/;" c function:QuerySetTest.test_bulk_insert +Author mongoengine/tests/queryset/queryset.py /^ class Author(Document):$/;" c function:QuerySetTest.test_confirm_order_by_reference_wont_work +Author mongoengine/tests/queryset/queryset.py /^ class Author(EmbeddedDocument):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField +Author mongoengine/tests/queryset/queryset.py /^ class Author(EmbeddedDocument):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField +Author mongoengine/tests/queryset/queryset.py /^ class Author(EmbeddedDocument):$/;" c function:QuerySetTest.test_set_list_embedded_documents +Author mongoengine/tests/test_signals.py /^ class Author(Document):$/;" c function:SignalTests.setUp +Author tests/fields/fields.py /^ class Author(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_validation +AuthorBooks mongoengine/tests/document/instance.py /^ class AuthorBooks(Document):$/;" c function:InstanceTest.test_db_alias_tests +B mongoengine/tests/document/indexes.py /^ class B(A):$/;" c function:IndexesTest.test_index_no_cls +B mongoengine/tests/document/indexes.py /^ class B(A):$/;" c function:IndexesTest.test_inherited_index +B mongoengine/tests/document/inheritance.py /^ class B(A):$/;" c function:InheritanceTest.test_abstract_embedded_documents +B mongoengine/tests/document/inheritance.py /^ class B(Document):$/;" c function:InheritanceTest.test_indexes_and_multiple_inheritance +B mongoengine/tests/document/instance.py /^ class B(A):$/;" c function:InstanceTest.subclasses_and_unique_keys_works +B mongoengine/tests/document/instance.py /^ class B(A):$/;" c function:InstanceTest.test_db_alias_overrides +B mongoengine/tests/document/instance.py /^ class B(A):$/;" c function:InstanceTest.test_db_alias_propagates +B mongoengine/tests/document/instance.py /^ class B(EmbeddedDocument):$/;" c function:InstanceTest.test_list_iter +B mongoengine/tests/document/instance.py /^ class B(EmbeddedDocument):$/;" c function:InstanceTest.test_mutating_documents +B mongoengine/tests/fields/fields.py /^ class B(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field +B mongoengine/tests/fields/fields.py /^ class B(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field +B mongoengine/tests/fields/fields.py /^ class B(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field_from_son +B mongoengine/tests/queryset/queryset.py /^ class B(A):$/;" c function:QuerySetTest.test_no_sub_classes +B mongoengine/tests/queryset/queryset.py /^ class B(Document):$/;" c function:QuerySetTest.test_chaining +B mongoengine/tests/queryset/queryset.py /^ class B(Document):$/;" c function:QuerySetTest.test_query_reference_to_custom_pk_doc +B mongoengine/tests/queryset/queryset.py /^ class B(Document):$/;" c function:QuerySetTest.test_save_and_only_on_fields_with_default +B mongoengine/tests/queryset/queryset.py /^ class B(EmbeddedDocument):$/;" c function:QuerySetTest.test_count_list_embedded +B mongoengine/tests/queryset/queryset.py /^ class B(EmbeddedDocument):$/;" c function:QuerySetTest.test_query_generic_embedded_document +B mongoengine/tests/queryset/transform.py /^ class B(Document):$/;" c function:TransformTest.test_chaining +B mongoengine/tests/test_context_managers.py /^ class B(A):$/;" c function:ContextManagersTest.test_no_sub_classes +B tests/fields/fields.py /^ class B(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field +B tests/fields/fields.py /^ class B(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field +B tests/fields/fields.py /^ class B(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field_from_son +BUILDDIR mongoengine/docs/Makefile /^BUILDDIR = _build$/;" m +BadDoc mongoengine/tests/fields/fields.py /^ class BadDoc(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set +BadDoc mongoengine/tests/fields/fields.py /^ class BadDoc(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set +BadDoc tests/fields/fields.py /^ class BadDoc(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set +BadDoc tests/fields/fields.py /^ class BadDoc(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set +Bar mongoengine/tests/document/instance.py /^ class Bar(Document):$/;" c function:InstanceTest.test_shard_key_in_embedded_document +Bar mongoengine/tests/document/instance.py /^ class Bar(Document):$/;" c function:InstanceTest.test_two_way_reverse_delete_rule +Bar mongoengine/tests/document/instance.py /^ class Bar(Document, NameMixin):$/;" c function:InstanceTest.test_object_mixins +Bar mongoengine/tests/fields/fields.py /^ class Bar(Base):$/;" c function:FieldTest.test_inherited_sequencefield +Bar mongoengine/tests/fields/fields.py /^ class Bar(Base):$/;" c function:FieldTest.test_no_inherited_sequencefield +Bar mongoengine/tests/fields/fields.py /^ class Bar(Document):$/;" c function:FieldTest.test_list_field_passed_in_value +Bar mongoengine/tests/fields/fields.py /^ class Bar(Document):$/;" c function:FieldTest.test_reference_miss +Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_distinct_ListField_ReferenceField +Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_distinct_handles_references +Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_distinct_handles_references_to_alias +Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_elem_match +Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_pull_in_genericembedded_field +Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_read_preference +Bar mongoengine/tests/queryset/queryset.py /^ class Bar(EmbeddedDocument):$/;" c function:QuerySetTest.test_set_generic_embedded_documents +Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Foo):$/;" c function:QuerySetTest.test_inherit_objects +Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Foo):$/;" c function:QuerySetTest.test_inherit_objects_override +Bar mongoengine/tests/test_dereference.py /^ class Bar(Document):$/;" c function:FieldTest.test_document_reload_no_inheritance +Bar tests/fields/fields.py /^ class Bar(Base):$/;" c function:FieldTest.test_inherited_sequencefield +Bar tests/fields/fields.py /^ class Bar(Base):$/;" c function:FieldTest.test_no_inherited_sequencefield +Bar tests/fields/fields.py /^ class Bar(Document):$/;" c function:FieldTest.test_list_field_passed_in_value +Bar tests/fields/fields.py /^ class Bar(Document):$/;" c function:FieldTest.test_reference_miss +Base mongoengine/tests/fields/fields.py /^ class Base(Document):$/;" c function:FieldTest.test_inherited_sequencefield +Base mongoengine/tests/fields/fields.py /^ class Base(Document):$/;" c function:FieldTest.test_no_inherited_sequencefield +Base mongoengine/tests/fixtures.py /^class Base(Document):$/;" c +Base mongoengine/tests/queryset/field_list.py /^ class Base(Document):$/;" c function:OnlyExcludeAllTest.test_exclude_from_subclasses_docs +Base mongoengine/tests/queryset/queryset.py /^ class Base(Document):$/;" c function:QuerySetTest.test_custom_querysets_inherited +Base mongoengine/tests/queryset/queryset.py /^ class Base(Document):$/;" c function:QuerySetTest.test_custom_querysets_inherited_direct +Base tests/fields/fields.py /^ class Base(Document):$/;" c function:FieldTest.test_inherited_sequencefield +Base tests/fields/fields.py /^ class Base(Document):$/;" c function:FieldTest.test_no_inherited_sequencefield +BaseDict mongoengine/mongoengine/base/datastructures.py /^class BaseDict(dict):$/;" c +BaseDocument mongoengine/mongoengine/base/document.py /^class BaseDocument(object):$/;" c +BaseDocument mongoengine/tests/document/class_methods.py /^ class BaseDocument(Document):$/;" c function:ClassMethodsTest.test_collection_naming +BaseDocument mongoengine/tests/document/class_methods.py /^ class BaseDocument(Document, BaseMixin):$/;" c function:ClassMethodsTest.test_collection_naming +BaseField mongoengine/mongoengine/base/fields.py /^class BaseField(object):$/;" c +BaseList mongoengine/mongoengine/base/datastructures.py /^class BaseList(list):$/;" c +BaseMixIn mongoengine/tests/document/instance.py /^ class BaseMixIn(object):$/;" c function:InstanceTest.test_mixin_inheritance +BaseMixin mongoengine/tests/document/class_methods.py /^ class BaseMixin(object):$/;" c function:ClassMethodsTest.test_collection_naming +BasePerson mongoengine/tests/document/validation.py /^ class BasePerson(Document):$/;" c function:ValidatorErrorTest.test_fields_rewrite +BaseQuerySet mongoengine/mongoengine/queryset/base.py /^class BaseQuerySet(object):$/;" c +Basedoc mongoengine/tests/fields/fields.py /^ class Basedoc(Document):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list +Basedoc tests/fields/fields.py /^ class Basedoc(Document):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list +BasesTuple mongoengine/mongoengine/base/metaclasses.py /^class BasesTuple(tuple):$/;" c +Basket mongoengine/tests/fields/fields.py /^ class Basket(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields +Basket tests/fields/fields.py /^ class Basket(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields +Baz mongoengine/tests/test_dereference.py /^ class Baz(Document):$/;" c function:FieldTest.test_document_reload_no_inheritance +BigPerson mongoengine/tests/fields/fields.py /^ class BigPerson(Document):$/;" c function:FieldTest.test_float_validation +BigPerson tests/fields/fields.py /^ class BigPerson(Document):$/;" c function:FieldTest.test_float_validation +BinaryField mongoengine/fields.py /^class BinaryField(BaseField):$/;" c +BinaryField mongoengine/mongoengine/fields.py /^class BinaryField(BaseField):$/;" c +Blog mongoengine/tests/document/instance.py /^ class Blog(Document):$/;" c function:InstanceTest.test_invalid_reverse_delete_rule_raise_errors +Blog mongoengine/tests/document/instance.py /^ class Blog(Document):$/;" c function:InstanceTest.test_override_method_with_field +Blog mongoengine/tests/queryset/queryset.py /^ class Blog(Document):$/;" c function:QuerySetTest.test_bulk_insert +Blog mongoengine/tests/queryset/queryset.py /^ class Blog(Document):$/;" c function:QuerySetTest.test_filter_chaining +Blog mongoengine/tests/queryset/queryset.py /^ class Blog(Document):$/;" c function:QuerySetTest.test_find_array_position +Blog mongoengine/tests/queryset/queryset.py /^ class Blog(Document):$/;" c function:QuerySetTest.test_update_array_position +BlogPost mongoengine/tests/document/class_methods.py /^ class BlogPost(Document):$/;" c function:ClassMethodsTest.test_compare_indexes +BlogPost mongoengine/tests/document/class_methods.py /^ class BlogPost(Document):$/;" c function:ClassMethodsTest.test_compare_indexes_inheritance +BlogPost mongoengine/tests/document/class_methods.py /^ class BlogPost(Document):$/;" c function:ClassMethodsTest.test_compare_indexes_multiple_subclasses +BlogPost mongoengine/tests/document/class_methods.py /^ class BlogPost(Document):$/;" c function:ClassMethodsTest.test_list_indexes_inheritance +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c class:IndexesTest.test_index_with_pk.Comment +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_dictionary_indexes +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_embedded_document_index +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_hint +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_index_on_id +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_indexes_after_database_drop +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_list_embedded_document_index +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_unique +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_unique_embedded_document +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_unique_embedded_document_in_list +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_unique_with +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_unique_with_embedded_document_and_embedded_unique +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(InheritFrom):$/;" c function:IndexesTest._index_test +BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(InheritFrom):$/;" c function:IndexesTest._index_test_inheritance +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_document_hash +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_modify_with_positional_push +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_push_nested_list +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_push_with_position +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_and_nullify +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_and_nullify_complex_field +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_recurs +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_deny +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_with_document_inheritance +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_save_list +BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_save_reference +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.setUp +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents_inheritance +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents_invalid +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_dict_field +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_embedded_document_inheritance +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_assignment +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_invalid_operators +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_lexicographic_operators +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_manipulative_operators +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_validation +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_map_field_unicode +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_query_conversion +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_query_conversion_dbref +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_validation +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_sorted_list_sorting +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion +BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref +BlogPost mongoengine/tests/queryset/field_list.py /^ class BlogPost(Document):$/;" c function:OnlyExcludeAllTest.test_exclude +BlogPost mongoengine/tests/queryset/field_list.py /^ class BlogPost(Document):$/;" c function:OnlyExcludeAllTest.test_only_with_subfields +BlogPost mongoengine/tests/queryset/modify.py /^ class BlogPost(Document):$/;" c function:FindAndModifyTest.test_modify_with_push +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(AbstractBlogPost):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_on_abstract_document +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(AbstractBlogPost):$/;" c function:QuerySetTest.test_reverse_delete_rule_deny_on_abstract_document +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(AbstractBlogPost):$/;" c function:QuerySetTest.test_reverse_delete_rule_nullify_on_abstract_document +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(AbstractBlogPost):$/;" c function:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_bulk +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_cannot_perform_joins_references +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_clear_ordering +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_custom_manager +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_delete_with_limit_handles_delete_rules +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_editting_embedded_objects +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_exec_js_field_sub +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_exec_js_query +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_filter_chaining +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_find_dict_item +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_find_embedded +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_find_empty_embedded +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_in_operator_on_non_iterable +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_item_frequencies +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_map_reduce +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_map_reduce_with_custom_object_ids +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_no_ordering_for_get +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_order_by_list +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_order_by_optional +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_ordering +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_query_value_conversion +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reference_field_find +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reference_field_find_dbref +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_deny +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_nullify +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_pull +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_one_pop_generic_reference +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_push_and_pull_add_to_set +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_push_list_of_list +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_push_with_position +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_using_positional_operator +BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_using_positional_operator_embedded_document +BlogPost mongoengine/tests/queryset/transform.py /^ class BlogPost(Document):$/;" c function:TransformTest.test_query_field_name +BlogPost mongoengine/tests/queryset/transform.py /^ class BlogPost(Document):$/;" c function:TransformTest.test_query_pk_field_name +BlogPost mongoengine/tests/queryset/visitor.py /^ class BlogPost(Document):$/;" c function:QTest.test_q +BlogPost mongoengine/tests/queryset/visitor.py /^ class BlogPost(Document):$/;" c function:QTest.test_q_lists +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.setUp +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents_inheritance +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents_invalid +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_dict_field +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_embedded_document_inheritance +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_assignment +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_invalid_operators +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_lexicographic_operators +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_manipulative_operators +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_validation +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_map_field_unicode +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_query_conversion +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_query_conversion_dbref +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_validation +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_sorted_list_sorting +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion +BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref +BlogPostWithCustomField mongoengine/tests/document/class_methods.py /^ class BlogPostWithCustomField(BlogPost):$/;" c function:ClassMethodsTest.test_compare_indexes_multiple_subclasses +BlogPostWithTags mongoengine/tests/document/class_methods.py /^ class BlogPostWithTags(BlogPost):$/;" c function:ClassMethodsTest.test_compare_indexes_inheritance +BlogPostWithTags mongoengine/tests/document/class_methods.py /^ class BlogPostWithTags(BlogPost):$/;" c function:ClassMethodsTest.test_compare_indexes_multiple_subclasses +BlogPostWithTags mongoengine/tests/document/class_methods.py /^ class BlogPostWithTags(BlogPost):$/;" c function:ClassMethodsTest.test_list_indexes_inheritance +BlogPostWithTagsAndExtraText mongoengine/tests/document/class_methods.py /^ class BlogPostWithTagsAndExtraText(BlogPostWithTags):$/;" c function:ClassMethodsTest.test_list_indexes_inheritance +BlogTag mongoengine/tests/queryset/queryset.py /^ class BlogTag(Document):$/;" c function:QuerySetTest.test_update_one_pop_generic_reference +BlogTag mongoengine/tests/queryset/queryset.py /^ class BlogTag(EmbeddedDocument):$/;" c function:QuerySetTest.test_editting_embedded_objects +Book mongoengine/tests/document/indexes.py /^ class Book(Document):$/;" c function:IndexesTest.test_hashed_indexes +Book mongoengine/tests/document/indexes.py /^ class Book(Document):$/;" c function:IndexesTest.test_text_indexes +Book mongoengine/tests/document/instance.py /^ class Book(Document):$/;" c function:InstanceTest.test_db_alias_tests +Book mongoengine/tests/document/instance.py /^ class Book(Document):$/;" c function:InstanceTest.test_db_ref_usage +Book mongoengine/tests/document/instance.py /^ class Book(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_with_custom_id_field +Book mongoengine/tests/document/instance.py /^ class Book(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_with_shared_id_among_collections +Book mongoengine/tests/queryset/queryset.py /^ class Book(Document):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField +Book mongoengine/tests/queryset/queryset.py /^ class Book(Document):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField +Book mongoengine/tests/test_dereference.py /^ class Book(Document):$/;" c function:FieldTest.test_objectid_reference_across_databases +Bookmark mongoengine/tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference +Bookmark mongoengine/tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_choices +Bookmark mongoengine/tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_choices_no_dereference +Bookmark mongoengine/tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_string_choices +Bookmark tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference +Bookmark tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_choices +Bookmark tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_choices_no_dereference +Bookmark tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_string_choices +BooleanField mongoengine/fields.py /^class BooleanField(BaseField):$/;" c +BooleanField mongoengine/mongoengine/fields.py /^class BooleanField(BaseField):$/;" c +Brand mongoengine/tests/test_dereference.py /^ class Brand(Document):$/;" c function:FieldTest.test_non_ascii_pk +BrandGroup mongoengine/tests/test_dereference.py /^ class BrandGroup(Document):$/;" c function:FieldTest.test_non_ascii_pk +Brother mongoengine/tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_abstract_reference_base_type +Brother mongoengine/tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_reference_abstract_class +Brother mongoengine/tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_reference_class_with_abstract_parent +Brother tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_abstract_reference_base_type +Brother tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_reference_abstract_class +Brother tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_reference_class_with_abstract_parent +C mongoengine/tests/document/inheritance.py /^ class C(A, B):$/;" c function:InheritanceTest.test_indexes_and_multiple_inheritance +C mongoengine/tests/document/instance.py /^ class C(EmbeddedDocument):$/;" c function:InstanceTest.test_mutating_documents +C mongoengine/tests/fields/fields.py /^ class C(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field +C mongoengine/tests/fields/fields.py /^ class C(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field_from_son +C mongoengine/tests/queryset/queryset.py /^ class C(B):$/;" c function:QuerySetTest.test_no_sub_classes +C mongoengine/tests/test_context_managers.py /^ class C(B):$/;" c function:ContextManagersTest.test_no_sub_classes +C tests/fields/fields.py /^ class C(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field +C tests/fields/fields.py /^ class C(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field_from_son +CASCADE mongoengine/mongoengine/queryset/base.py /^CASCADE = 2$/;" v +CLASSIFIERS mongoengine/setup.py /^CLASSIFIERS = [$/;" v +COLLECTION_NAME mongoengine/fields.py /^ COLLECTION_NAME = 'mongoengine.counters'$/;" v class:SequenceField +COLLECTION_NAME mongoengine/mongoengine/fields.py /^ COLLECTION_NAME = 'mongoengine.counters'$/;" v class:SequenceField +COMPARISON_OPERATORS mongoengine/mongoengine/queryset/transform.py /^COMPARISON_OPERATORS = ('ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'mod',$/;" v +CONN_CLASS mongoengine/tests/test_replicaset_connection.py /^ CONN_CLASS = MongoClient$/;" v +CONN_CLASS mongoengine/tests/test_replicaset_connection.py /^ CONN_CLASS = ReplicaSetConnection$/;" v +CUSTOM_OPERATORS mongoengine/mongoengine/queryset/transform.py /^CUSTOM_OPERATORS = ('match',)$/;" v +CachedReferenceField mongoengine/fields.py /^class CachedReferenceField(BaseField):$/;" c +CachedReferenceField mongoengine/mongoengine/fields.py /^class CachedReferenceField(BaseField):$/;" c +CachedReferenceFieldTest mongoengine/tests/fields/fields.py /^class CachedReferenceFieldTest(MongoDBTestCase):$/;" c +CachedReferenceFieldTest tests/fields/fields.py /^class CachedReferenceFieldTest(MongoDBTestCase):$/;" c +Car mongoengine/tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document +Car mongoengine/tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document_choices +Car mongoengine/tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_list_embedded_document_choices +Car tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document +Car tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document_choices +Car tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_list_embedded_document_choices +Cat mongoengine/tests/document/class_methods.py /^ class Cat(Animal):$/;" c function:ClassMethodsTest.test_register_delete_rule_inherited +Cat mongoengine/tests/queryset/queryset.py /^ class Cat(Animal):$/;" c function:QuerySetTest.test_cls_query_in_subclassed_docs +Cat mongoengine/tests/queryset/queryset.py /^ class Cat(Animal):$/;" c function:QuerySetTest.test_subclass_field_query +Category mongoengine/tests/fields/fields.py /^ class Category(EmbeddedDocument):$/;" c function:FieldTest.test_reverse_list_sorting +Category mongoengine/tests/queryset/queryset.py /^ class Category(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_complex_cycle +Category mongoengine/tests/queryset/queryset.py /^ class Category(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing +Category mongoengine/tests/queryset/queryset.py /^ class Category(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_nullify +Category tests/fields/fields.py /^ class Category(EmbeddedDocument):$/;" c function:FieldTest.test_reverse_list_sorting +CategoryList mongoengine/tests/fields/fields.py /^ class CategoryList(Document):$/;" c function:FieldTest.test_reverse_list_sorting +CategoryList tests/fields/fields.py /^ class CategoryList(Document):$/;" c function:FieldTest.test_reverse_list_sorting +Child mongoengine/tests/document/validation.py /^ class Child(Parent):$/;" c function:ValidatorErrorTest.test_parent_reference_in_child_document +Child mongoengine/tests/document/validation.py /^ class Child(Parent):$/;" c function:ValidatorErrorTest.test_parent_reference_set_as_attribute_in_child_document +City mongoengine/tests/document/inheritance.py /^ class City(Document):$/;" c function:InheritanceTest.test_abstract_document_creation_does_not_fail +City mongoengine/tests/document/inheritance.py /^ class City(Document):$/;" c function:InheritanceTest.test_abstract_handle_ids_in_metaclass_properly +City mongoengine/tests/document/inheritance.py /^ class City(Document):$/;" c function:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class +City mongoengine/tests/document/inheritance.py /^ class City(Document):$/;" c function:InheritanceTest.test_auto_id_vs_non_pk_id_field +ClassMethodsTest mongoengine/tests/document/class_methods.py /^class ClassMethodsTest(unittest.TestCase):$/;" c +Club mongoengine/tests/queryset/queryset.py /^ class Club(Document):$/;" c function:QuerySetTest.test_dictfield_update +Club mongoengine/tests/queryset/queryset.py /^ class Club(Document):$/;" c function:QuerySetTest.test_mapfield_update +Collaborator mongoengine/tests/queryset/queryset.py /^ class Collaborator(EmbeddedDocument):$/;" c function:QuerySetTest.test_pull_from_nested_embedded +Collaborator mongoengine/tests/queryset/queryset.py /^ class Collaborator(EmbeddedDocument):$/;" c function:QuerySetTest.test_pull_from_nested_mapfield +Collaborator mongoengine/tests/queryset/queryset.py /^ class Collaborator(EmbeddedDocument):$/;" c function:QuerySetTest.test_pull_nested +Comment mongoengine/docs/code/tumblelog.py /^class Comment(EmbeddedDocument):$/;" c +Comment mongoengine/tests/document/indexes.py /^ class Comment(EmbeddedDocument):$/;" c function:IndexesTest.test_index_with_pk +Comment mongoengine/tests/document/inheritance.py /^ class Comment(EmbeddedDocument):$/;" c function:InheritanceTest.test_allow_inheritance_embedded_document +Comment mongoengine/tests/document/instance.py /^ class Comment(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_recurs +Comment mongoengine/tests/document/instance.py /^ class Comment(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document +Comment mongoengine/tests/document/instance.py /^ class Comment(EmbeddedDocument):$/;" c function:InstanceTest.test_list_search_by_embedded +Comment mongoengine/tests/document/instance.py /^ class Comment(EmbeddedDocument):$/;" c function:InstanceTest.test_save_list +Comment mongoengine/tests/document/instance.py /^ class Comment(EmbeddedDocument):$/;" c function:InstanceTest.test_save_only_changed_fields_recursive +Comment mongoengine/tests/document/validation.py /^ class Comment(EmbeddedDocument):$/;" c function:ValidatorErrorTest.test_embedded_document_validation +Comment mongoengine/tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_validation +Comment mongoengine/tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_sequence_field +Comment mongoengine/tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_list_validation +Comment mongoengine/tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_validation +Comment mongoengine/tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_sorted_list_sorting +Comment mongoengine/tests/queryset/field_list.py /^ class Comment(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_exclude +Comment mongoengine/tests/queryset/field_list.py /^ class Comment(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_only_with_subfields +Comment mongoengine/tests/queryset/queryset.py /^ class Comment(Document):$/;" c function:QuerySetTest.test_ensure_index +Comment mongoengine/tests/queryset/queryset.py /^ class Comment(Document):$/;" c function:QuerySetTest.test_unset_reference +Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_bulk_insert +Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_exec_js_field_sub +Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_find_array_position +Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_array_position +Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_using_positional_operator +Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_using_positional_operator_embedded_document +Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_updates_can_have_match_operators +Comment mongoengine/tests/queryset/transform.py /^ class Comment(EmbeddedDocument):$/;" c function:TransformTest.test_query_field_name +Comment mongoengine/tests/test_dereference.py /^ class Comment(Document):$/;" c function:FieldTest.test_list_lookup_not_checked_in_map +Comment tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_validation +Comment tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_sequence_field +Comment tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_list_validation +Comment tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_validation +Comment tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_sorted_list_sorting +Comments mongoengine/tests/fields/fields.py /^ class Comments(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.setUp +Comments mongoengine/tests/fields/fields.py /^ class Comments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_inheritance +Comments tests/fields/fields.py /^ class Comments(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.setUp +Comments tests/fields/fields.py /^ class Comments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_inheritance +Company mongoengine/tests/fields/fields.py /^ class Company(Document):$/;" c function:FieldTest.test_undefined_reference +Company tests/fields/fields.py /^ class Company(Document):$/;" c function:FieldTest.test_undefined_reference +CompareStats mongoengine/tests/document/instance.py /^ class CompareStats(Document):$/;" c function:InstanceTest.test_reference_inheritance +ComplexBaseField mongoengine/mongoengine/base/fields.py /^class ComplexBaseField(BaseField):$/;" c +ComplexDateTimeField mongoengine/fields.py /^class ComplexDateTimeField(StringField):$/;" c +ComplexDateTimeField mongoengine/mongoengine/fields.py /^class ComplexDateTimeField(StringField):$/;" c +CompoundKey mongoengine/tests/document/indexes.py /^ class CompoundKey(EmbeddedDocument):$/;" c function:IndexesTest.test_compound_key_embedded +ConnectionTest mongoengine/tests/test_connection.py /^class ConnectionTest(unittest.TestCase):$/;" c +ConnectionTest mongoengine/tests/test_replicaset_connection.py /^class ConnectionTest(unittest.TestCase):$/;" c +ContextManagersTest mongoengine/tests/test_context_managers.py /^class ContextManagersTest(unittest.TestCase):$/;" c +Continent mongoengine/tests/queryset/queryset.py /^ class Continent(EmbeddedDocument):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField +Country mongoengine/tests/queryset/queryset.py /^ class Country(EmbeddedDocument):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField +CustomData mongoengine/tests/fields/fields.py /^ class CustomData(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_custom_data +CustomData tests/fields/fields.py /^ class CustomData(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_custom_data +CustomNamingTest mongoengine/tests/document/class_methods.py /^ class CustomNamingTest(Document):$/;" c function:ClassMethodsTest.test_collection_naming +CustomQuerySet mongoengine/tests/queryset/queryset.py /^ class CustomQuerySet(QuerySet):$/;" c function:QuerySetTest.test_custom_querysets +CustomQuerySet mongoengine/tests/queryset/queryset.py /^ class CustomQuerySet(QuerySet):$/;" c function:QuerySetTest.test_custom_querysets_inherited +CustomQuerySet mongoengine/tests/queryset/queryset.py /^ class CustomQuerySet(QuerySet):$/;" c function:QuerySetTest.test_custom_querysets_inherited_direct +CustomQuerySet mongoengine/tests/queryset/queryset.py /^ class CustomQuerySet(QuerySet):$/;" c function:QuerySetTest.test_custom_querysets_set_manager_directly +CustomQuerySetManager mongoengine/tests/queryset/queryset.py /^ class CustomQuerySetManager(QuerySetManager):$/;" c function:QuerySetTest.test_custom_querysets_inherited_direct +CustomQuerySetManager mongoengine/tests/queryset/queryset.py /^ class CustomQuerySetManager(QuerySetManager):$/;" c function:QuerySetTest.test_custom_querysets_managers_directly +CustomQuerySetManager mongoengine/tests/queryset/queryset.py /^ class CustomQuerySetManager(QuerySetManager):$/;" c function:QuerySetTest.test_custom_querysets_set_manager_directly +Customer mongoengine/tests/document/indexes.py /^ class Customer(Document):$/;" c function:IndexesTest.test_unique_and_indexes +D mongoengine/tests/fields/fields.py /^ class D(Document):$/;" c function:FieldTest.test_ensure_unique_default_instances +D tests/fields/fields.py /^ class D(Document):$/;" c function:FieldTest.test_ensure_unique_default_instances +DEFAULT_CONNECTION_NAME mongoengine/mongoengine/connection.py /^DEFAULT_CONNECTION_NAME = 'default'$/;" v +DENY mongoengine/mongoengine/queryset/base.py /^DENY = 3$/;" v +DESCRIPTION mongoengine/setup.py /^DESCRIPTION = ($/;" v +DOMAIN_REGEX mongoengine/fields.py /^ DOMAIN_REGEX = re.compile($/;" v class:EmailField +DOMAIN_REGEX mongoengine/mongoengine/fields.py /^ DOMAIN_REGEX = re.compile($/;" v class:EmailField +DO_NOTHING mongoengine/mongoengine/queryset/base.py /^DO_NOTHING = 0$/;" v +Data mongoengine/tests/queryset/queryset.py /^ class Data(Document):$/;" c function:QuerySetTest.test_iteration_within_iteration +Data mongoengine/tests/queryset/queryset.py /^ class Data(Document):$/;" c function:QuerySetTest.test_len_during_iteration +Data mongoengine/tests/queryset/queryset.py /^ class Data(EmbeddedDocument):$/;" c function:QuerySetTest.test_item_frequencies_with_null_embedded +Date mongoengine/tests/document/indexes.py /^ class Date(EmbeddedDocument):$/;" c function:IndexesTest.test_embedded_document_index +Date mongoengine/tests/document/indexes.py /^ class Date(EmbeddedDocument):$/;" c function:IndexesTest.test_unique_with +DateCreatedDocument mongoengine/tests/document/inheritance.py /^ class DateCreatedDocument(Document):$/;" c function:InheritanceTest.test_document_inheritance +DateDoc mongoengine/tests/test_connection.py /^ class DateDoc(Document):$/;" c function:ConnectionTest.test_datetime +DateTimeField mongoengine/fields.py /^class DateTimeField(BaseField):$/;" c +DateTimeField mongoengine/mongoengine/fields.py /^class DateTimeField(BaseField):$/;" c +DateUpdatedDocument mongoengine/tests/document/inheritance.py /^ class DateUpdatedDocument(Document):$/;" c function:InheritanceTest.test_document_inheritance +DeReference mongoengine/mongoengine/dereference.py /^class DeReference(object):$/;" c +DecimalField mongoengine/fields.py /^class DecimalField(BaseField):$/;" c +DecimalField mongoengine/mongoengine/fields.py /^class DecimalField(BaseField):$/;" c +DefaultNamingTest mongoengine/tests/document/class_methods.py /^ class DefaultNamingTest(Document):$/;" c function:ClassMethodsTest.test_collection_naming +DeltaTest mongoengine/tests/document/delta.py /^class DeltaTest(unittest.TestCase):$/;" c +DemoFile mongoengine/tests/fields/file_tests.py /^ class DemoFile(Document):$/;" c function:FileTest.test_file_field_optional +DicDoc mongoengine/tests/queryset/transform.py /^ class DicDoc(Document):$/;" c function:TransformTest.test_transform_update +DictField mongoengine/fields.py /^class DictField(ComplexBaseField):$/;" c +DictField mongoengine/mongoengine/fields.py /^class DictField(ComplexBaseField):$/;" c +DictFieldTest mongoengine/tests/fields/fields.py /^ class DictFieldTest(Document):$/;" c function:FieldTest.test_invalid_dict_value +DictFieldTest tests/fields/fields.py /^ class DictFieldTest(Document):$/;" c function:FieldTest.test_invalid_dict_value +Dish mongoengine/tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document +Dish mongoengine/tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document_choices +Dish mongoengine/tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_list_embedded_document_choices +Dish tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document +Dish tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document_choices +Dish tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_list_embedded_document_choices +Doc mongoengine/tests/document/delta.py /^ class Doc(DocClass):$/;" c function:DeltaTest.delta +Doc mongoengine/tests/document/delta.py /^ class Doc(DocClass):$/;" c function:DeltaTest.delta_db_field +Doc mongoengine/tests/document/delta.py /^ class Doc(DocClass):$/;" c function:DeltaTest.delta_recursive +Doc mongoengine/tests/document/delta.py /^ class Doc(DocClass):$/;" c function:DeltaTest.delta_recursive_db_field +Doc mongoengine/tests/document/delta.py /^ class Doc(Document):$/;" c function:DeltaTest.test_delta_for_nested_map_fields +Doc mongoengine/tests/document/delta.py /^ class Doc(DynamicDocument):$/;" c function:DeltaTest.test_dynamic_delta +Doc mongoengine/tests/document/dynamic.py /^ class Doc(DynamicDocument):$/;" c function:DynamicTest.test_complex_embedded_document_validation +Doc mongoengine/tests/document/dynamic.py /^ class Doc(DynamicDocument):$/;" c function:DynamicTest.test_complex_embedded_documents +Doc mongoengine/tests/document/dynamic.py /^ class Doc(DynamicDocument):$/;" c function:DynamicTest.test_embedded_dynamic_document +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_can_save_false_values +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_can_save_if_not_included +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_embedded_document_complex_instance +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_embedded_document_complex_instance_no_use_db_field +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_embedded_document_instance +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_kwargs_complex +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_kwargs_simple +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_reload_referencing +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_save_abstract_document +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_update_list_field +Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_update_unique_field +Doc mongoengine/tests/document/instance.py /^ class Doc(DynamicDocument):$/;" c function:InstanceTest.test_can_save_false_values_dynamic +Doc mongoengine/tests/document/instance.py /^ class Doc(DynamicDocument):$/;" c function:InstanceTest.test_spaces_in_keys +Doc mongoengine/tests/document/json_serialisation.py /^ class Doc(Document):$/;" c function:TestJson.test_json_complex +Doc mongoengine/tests/document/json_serialisation.py /^ class Doc(Document):$/;" c function:TestJson.test_json_names +Doc mongoengine/tests/document/json_serialisation.py /^ class Doc(Document):$/;" c function:TestJson.test_json_simple +Doc mongoengine/tests/document/validation.py /^ class Doc(Document):$/;" c function:ValidatorErrorTest.test_embedded_db_field_validate +Doc mongoengine/tests/document/validation.py /^ class Doc(Document):$/;" c function:ValidatorErrorTest.test_embedded_weakref +Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dictfield_dump_document +Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamic_fields_class +Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamic_fields_embedded_class +Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document +Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_generic_reference_filter_by_dbref +Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_generic_reference_filter_by_objectid +Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_sparse_field +Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_undefined_field_exception +Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_undefined_field_exception_with_strict +Doc mongoengine/tests/queryset/modify.py /^class Doc(Document):$/;" c +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_array_average +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_array_sum +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_embedded_array_average +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_embedded_array_sum +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_embedded_average +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_embedded_sum +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_json_complex +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_json_simple +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_query_generic_embedded_document +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_reload_embedded_docs_instance +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_reload_list_embedded_docs_instance +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_repr +Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_update_validate +Doc mongoengine/tests/queryset/transform.py /^ class Doc(Document):$/;" c function:TransformTest.test_last_field_name_like_operator +Doc mongoengine/tests/queryset/transform.py /^ class Doc(Document):$/;" c function:TransformTest.test_raw_and_merging +Doc mongoengine/tests/queryset/transform.py /^ class Doc(Document):$/;" c function:TransformTest.test_transform_update +Doc mongoengine/tests/queryset/transform.py /^ class Doc(Document):$/;" c function:TransformTest.test_type +Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dictfield_dump_document +Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamic_fields_class +Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamic_fields_embedded_class +Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document +Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_generic_reference_filter_by_dbref +Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_generic_reference_filter_by_objectid +Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_sparse_field +Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_undefined_field_exception +Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_undefined_field_exception_with_strict +Doc2 mongoengine/tests/fields/fields.py /^ class Doc2(Document):$/;" c function:FieldTest.test_dynamic_fields_class +Doc2 tests/fields/fields.py /^ class Doc2(Document):$/;" c function:FieldTest.test_dynamic_fields_class +Document mongoengine/mongoengine/document.py /^class Document(BaseDocument):$/;" c +DocumentMetaclass mongoengine/mongoengine/base/metaclasses.py /^class DocumentMetaclass(type):$/;" c +DoesNotExist mongoengine/mongoengine/errors.py /^class DoesNotExist(Exception):$/;" c +Dog mongoengine/tests/document/inheritance.py /^ class Dog(Animal):$/;" c class:InheritanceTest.test_allow_inheritance.Animal +Dog mongoengine/tests/document/inheritance.py /^ class Dog(Mammal): pass$/;" c function:InheritanceTest.test_external_subclasses +Dog mongoengine/tests/document/inheritance.py /^ class Dog(Mammal): pass$/;" c function:InheritanceTest.test_external_superclasses +Dog mongoengine/tests/document/inheritance.py /^ class Dog(Mammal): pass$/;" c function:InheritanceTest.test_polymorphic_queries +Dog mongoengine/tests/document/inheritance.py /^ class Dog(Mammal): pass$/;" c function:InheritanceTest.test_subclasses +Dog mongoengine/tests/document/inheritance.py /^ class Dog(Mammal): pass$/;" c function:InheritanceTest.test_superclasses +Dog mongoengine/tests/document/instance.py /^ class Dog(Mammal):$/;" c function:InstanceTest.test_polymorphic_references +Dog mongoengine/tests/fields/fields.py /^ class Dog(Mammal):$/;" c function:FieldTest.test_cls_field +Dog mongoengine/tests/queryset/queryset.py /^ class Dog(Animal):$/;" c function:QuerySetTest.test_cls_query_in_subclassed_docs +Dog tests/fields/fields.py /^ class Dog(Mammal):$/;" c function:FieldTest.test_cls_field +DoubleMixIn mongoengine/tests/document/instance.py /^ class DoubleMixIn(BaseMixIn):$/;" c function:InstanceTest.test_mixin_inheritance +Drink mongoengine/tests/document/inheritance.py /^ class Drink(Document):$/;" c function:InheritanceTest.test_inherited_collections +Drinker mongoengine/tests/document/inheritance.py /^ class Drinker(Document):$/;" c function:InheritanceTest.test_inherited_collections +Dummy mongoengine/tests/queryset/queryset.py /^ class Dummy(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_complex_cycle +Dummy mongoengine/tests/queryset/queryset.py /^ class Dummy(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_cycle +DuplicateQueryConditionsError mongoengine/mongoengine/queryset/visitor.py /^class DuplicateQueryConditionsError(InvalidQueryError):$/;" c +DynamicDocument mongoengine/mongoengine/document.py /^class DynamicDocument(Document):$/;" c +DynamicEmbeddedDocument mongoengine/mongoengine/document.py /^class DynamicEmbeddedDocument(EmbeddedDocument):$/;" c +DynamicField mongoengine/fields.py /^class DynamicField(BaseField):$/;" c +DynamicField mongoengine/mongoengine/fields.py /^class DynamicField(BaseField):$/;" c +DynamicNamingTest mongoengine/tests/document/class_methods.py /^ class DynamicNamingTest(Document):$/;" c function:ClassMethodsTest.test_collection_naming +DynamicTest mongoengine/tests/document/dynamic.py /^class DynamicTest(unittest.TestCase):$/;" c +EXCLUDE mongoengine/mongoengine/queryset/field_list.py /^ EXCLUDE = 0$/;" v class:QueryFieldList +Editor mongoengine/tests/document/instance.py /^ class Editor(self.Person):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal +EmDoc mongoengine/tests/queryset/queryset.py /^ class EmDoc(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_validate +Email mongoengine/tests/document/instance.py /^ class Email(EmbeddedDocument):$/;" c function:InstanceTest.test_instance_is_set_on_setattr +Email mongoengine/tests/document/instance.py /^ class Email(EmbeddedDocument):$/;" c function:InstanceTest.test_instance_is_set_on_setattr_on_embedded_document_list +Email mongoengine/tests/queryset/field_list.py /^ class Email(Document):$/;" c function:OnlyExcludeAllTest.test_all_fields +Email mongoengine/tests/queryset/field_list.py /^ class Email(Document):$/;" c function:OnlyExcludeAllTest.test_exclude_only_combining +EmailField mongoengine/fields.py /^class EmailField(StringField):$/;" c +EmailField mongoengine/mongoengine/fields.py /^class EmailField(StringField):$/;" c +EmailUser mongoengine/tests/document/instance.py /^ class EmailUser(User):$/;" c class:InstanceTest.test_custom_id_field.User +EmailUser mongoengine/tests/document/instance.py /^ class EmailUser(User):$/;" c function:InstanceTest.test_custom_id_field +Embed mongoengine/tests/fields/fields.py /^ class Embed(EmbeddedDocument):$/;" c function:FieldTest.test_dynamic_fields_embedded_class +Embed mongoengine/tests/queryset/queryset.py /^ class Embed(EmbeddedDocument):$/;" c function:QuerySetTest.test_save_and_only_on_fields_with_default +Embed tests/fields/fields.py /^ class Embed(EmbeddedDocument):$/;" c function:FieldTest.test_dynamic_fields_embedded_class +Embedded mongoengine/tests/document/delta.py /^ class Embedded(EmbeddedClass):$/;" c function:DeltaTest.delta_recursive +Embedded mongoengine/tests/document/delta.py /^ class Embedded(EmbeddedClass):$/;" c function:DeltaTest.delta_recursive_db_field +Embedded mongoengine/tests/document/dynamic.py /^ class Embedded(DynamicEmbeddedDocument):$/;" c function:DynamicTest.test_complex_embedded_document_validation +Embedded mongoengine/tests/document/dynamic.py /^ class Embedded(DynamicEmbeddedDocument):$/;" c function:DynamicTest.test_complex_embedded_documents +Embedded mongoengine/tests/document/dynamic.py /^ class Embedded(DynamicEmbeddedDocument):$/;" c function:DynamicTest.test_embedded_dynamic_document +Embedded mongoengine/tests/document/instance.py /^ class Embedded(DynamicEmbeddedDocument):$/;" c function:InstanceTest.test_spaces_in_keys +Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_complex_instance +Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_complex_instance_no_use_db_field +Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_equality +Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_instance +Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_kwargs_complex +Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_kwargs_simple +Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_reload_referencing +Embedded mongoengine/tests/document/json_serialisation.py /^ class Embedded(EmbeddedDocument):$/;" c function:TestJson.test_json_names +Embedded mongoengine/tests/document/json_serialisation.py /^ class Embedded(EmbeddedDocument):$/;" c function:TestJson.test_json_simple +Embedded mongoengine/tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_db_field +Embedded mongoengine/tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_mapfield_db_field +Embedded mongoengine/tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_mapfield_numerical_index +Embedded mongoengine/tests/queryset/queryset.py /^ class Embedded(EmbeddedDocument):$/;" c function:QuerySetTest.test_json_simple +Embedded tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_db_field +Embedded tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_mapfield_db_field +Embedded tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_mapfield_numerical_index +EmbeddedDoc mongoengine/tests/document/delta.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:DeltaTest.test_lower_level_mark_as_changed +EmbeddedDoc mongoengine/tests/document/delta.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:DeltaTest.test_nested_nested_fields_mark_as_changed +EmbeddedDoc mongoengine/tests/document/delta.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:DeltaTest.test_upper_level_mark_as_changed +EmbeddedDoc mongoengine/tests/document/instance.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:InstanceTest.test_can_save_if_not_included +EmbeddedDoc mongoengine/tests/document/json_serialisation.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:TestJson.test_json_complex +EmbeddedDoc mongoengine/tests/queryset/queryset.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:QuerySetTest.test_json_complex +EmbeddedDocument mongoengine/mongoengine/document.py /^class EmbeddedDocument(BaseDocument):$/;" c +EmbeddedDocumentField mongoengine/fields.py /^class EmbeddedDocumentField(BaseField):$/;" c +EmbeddedDocumentField mongoengine/mongoengine/fields.py /^class EmbeddedDocumentField(BaseField):$/;" c +EmbeddedDocumentList mongoengine/mongoengine/base/datastructures.py /^class EmbeddedDocumentList(BaseList):$/;" c +EmbeddedDocumentListField mongoengine/fields.py /^class EmbeddedDocumentListField(ListField):$/;" c +EmbeddedDocumentListField mongoengine/mongoengine/fields.py /^class EmbeddedDocumentListField(ListField):$/;" c +EmbeddedDocumentListFieldTestCase mongoengine/tests/fields/fields.py /^class EmbeddedDocumentListFieldTestCase(MongoDBTestCase):$/;" c +EmbeddedDocumentListFieldTestCase tests/fields/fields.py /^class EmbeddedDocumentListFieldTestCase(MongoDBTestCase):$/;" c +EmbeddedItem mongoengine/tests/queryset/transform.py /^ class EmbeddedItem(EmbeddedDocument):$/;" c function:TransformTest.test_last_field_name_like_operator +EmbeddedLocation mongoengine/tests/document/indexes.py /^ class EmbeddedLocation(EmbeddedDocument):$/;" c function:IndexesTest.test_explicit_geo2d_index_embedded +EmbeddedNumber mongoengine/tests/queryset/field_list.py /^ class EmbeddedNumber(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_slicing_nested_fields +EmbeddedOcurrence mongoengine/tests/fields/fields.py /^ class EmbeddedOcurrence(EmbeddedDocument):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded +EmbeddedOcurrence mongoengine/tests/fields/fields.py /^ class EmbeddedOcurrence(EmbeddedDocument):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded +EmbeddedOcurrence tests/fields/fields.py /^ class EmbeddedOcurrence(EmbeddedDocument):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded +EmbeddedOcurrence tests/fields/fields.py /^ class EmbeddedOcurrence(EmbeddedDocument):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded +EmbeddedRole mongoengine/tests/document/delta.py /^ class EmbeddedRole(EmbeddedDocument):$/;" c function:DeltaTest.test_delta_for_nested_map_fields +EmbeddedUser mongoengine/tests/document/delta.py /^ class EmbeddedUser(EmbeddedDocument):$/;" c function:DeltaTest.test_delta_for_nested_map_fields +EmbeddedWithSparseUnique mongoengine/tests/fields/fields.py /^ class EmbeddedWithSparseUnique(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field +EmbeddedWithSparseUnique tests/fields/fields.py /^ class EmbeddedWithSparseUnique(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field +EmbeddedWithUnique mongoengine/tests/fields/fields.py /^ class EmbeddedWithUnique(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field +EmbeddedWithUnique tests/fields/fields.py /^ class EmbeddedWithUnique(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field +Employee mongoengine/tests/document/dynamic.py /^ class Employee(self.Person):$/;" c function:DynamicTest.test_inheritance +Employee mongoengine/tests/document/inheritance.py /^ class Employee(Person):$/;" c function:InheritanceTest.test_inheritance_meta_data +Employee mongoengine/tests/document/inheritance.py /^ class Employee(Person):$/;" c function:InheritanceTest.test_inheritance_to_mongo_keys +Employee mongoengine/tests/document/instance.py /^ class Employee(Person):$/;" c function:InstanceTest.test_embedded_document_to_mongo +Employee mongoengine/tests/document/instance.py /^ class Employee(self.Person):$/;" c function:InstanceTest.test_save_embedded_document +Employee mongoengine/tests/document/instance.py /^ class Employee(self.Person):$/;" c function:InstanceTest.test_updating_an_embedded_document +Employee mongoengine/tests/fields/fields.py /^ class Employee(Document):$/;" c function:FieldTest.test_recursive_reference +Employee mongoengine/tests/queryset/field_list.py /^ class Employee(self.Person):$/;" c function:OnlyExcludeAllTest.test_only +Employee mongoengine/tests/test_dereference.py /^ class Employee(Document):$/;" c function:FieldTest.test_recursive_reference +Employee tests/fields/fields.py /^ class Employee(Document):$/;" c function:FieldTest.test_recursive_reference +EmployeeDetails mongoengine/tests/document/instance.py /^ class EmployeeDetails(EmbeddedDocument):$/;" c function:InstanceTest.test_save_embedded_document +EmployeeDetails mongoengine/tests/document/instance.py /^ class EmployeeDetails(EmbeddedDocument):$/;" c function:InstanceTest.test_updating_an_embedded_document +EnumField mongoengine/tests/fields/fields.py /^ class EnumField(BaseField):$/;" c function:FieldTest.test_tuples_as_tuples +EnumField tests/fields/fields.py /^ class EnumField(BaseField):$/;" c function:FieldTest.test_tuples_as_tuples +EuropeanCity mongoengine/tests/document/inheritance.py /^ class EuropeanCity(City):$/;" c function:InheritanceTest.test_abstract_handle_ids_in_metaclass_properly +EuropeanCity mongoengine/tests/document/inheritance.py /^ class EuropeanCity(City):$/;" c function:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class +EuropeanCity mongoengine/tests/document/inheritance.py /^ class EuropeanCity(City):$/;" c function:InheritanceTest.test_auto_id_vs_non_pk_id_field +Event mongoengine/tests/fields/geo.py /^ class Event(Document):$/;" c function:GeoFieldTest.test_geopoint_embedded_indexes +Event mongoengine/tests/fields/geo.py /^ class Event(Document):$/;" c function:GeoFieldTest.test_indexes_2dsphere +Event mongoengine/tests/fields/geo.py /^ class Event(Document):$/;" c function:GeoFieldTest.test_indexes_2dsphere_embedded +Event mongoengine/tests/fields/geo.py /^ class Event(Document):$/;" c function:GeoFieldTest.test_indexes_geopoint +Event mongoengine/tests/queryset/geo.py /^ class Event(Document):$/;" c function:GeoQueriesTest._create_event_data +Event mongoengine/tests/queryset/geo.py /^ class Event(Document):$/;" c function:GeoQueriesTest._test_embedded +Event mongoengine/tests/queryset/transform.py /^ class Event(Document):$/;" c function:TransformTest.test_understandable_error_raised +EvilHuman mongoengine/tests/document/inheritance.py /^ class EvilHuman(Human):$/;" c class:InheritanceTest.test_abstract_documents.Human +Example mongoengine/tests/queryset/queryset.py /^ class Example(Document):$/;" c function:QuerySetTest.test_can_have_field_same_name_as_query_operator +ExplicitId mongoengine/tests/test_signals.py /^ class ExplicitId(Document):$/;" c function:SignalTests.setUp +ExtendedBlogPost mongoengine/tests/document/indexes.py /^ class ExtendedBlogPost(BlogPost):$/;" c function:IndexesTest._index_test_inheritance +Extensible mongoengine/tests/fields/fields.py /^ class Extensible(Document):$/;" c function:FieldTest.test_complex_mapfield +Extensible tests/fields/fields.py /^ class Extensible(Document):$/;" c function:FieldTest.test_complex_mapfield +Extra mongoengine/tests/queryset/queryset.py /^ class Extra(EmbeddedDocument):$/;" c function:QuerySetTest.test_item_frequencies_with_null_embedded +Family mongoengine/tests/queryset/queryset.py /^ class Family(Document):$/;" c function:QuerySetTest.test_map_reduce_custom_output +Feed mongoengine/tests/document/instance.py /^ class Feed(Document):$/;" c function:InstanceTest.test_query_count_when_saving +FieldDoesNotExist mongoengine/mongoengine/errors.py /^class FieldDoesNotExist(Exception):$/;" c +FieldTest mongoengine/tests/fields/fields.py /^class FieldTest(MongoDBTestCase):$/;" c +FieldTest mongoengine/tests/test_dereference.py /^class FieldTest(unittest.TestCase):$/;" c +FieldTest tests/fields/fields.py /^class FieldTest(MongoDBTestCase):$/;" c +FileField mongoengine/fields.py /^class FileField(BaseField):$/;" c +FileField mongoengine/mongoengine/fields.py /^class FileField(BaseField):$/;" c +FileTest mongoengine/tests/fields/file_tests.py /^class FileTest(MongoDBTestCase):$/;" c +FinalDocument mongoengine/tests/document/inheritance.py /^ class FinalDocument(Document):$/;" c function:InheritanceTest.test_allow_inheritance_abstract_document +FindAndModifyTest mongoengine/tests/queryset/modify.py /^class FindAndModifyTest(unittest.TestCase):$/;" c +Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_abstract_documents +Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_external_subclasses +Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_external_superclasses +Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_polymorphic_queries +Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_subclasses +Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_superclasses +Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal):$/;" c function:InheritanceTest.test_dynamic_declarations +Fish mongoengine/tests/document/instance.py /^ class Fish(Animal):$/;" c function:InstanceTest.test_polymorphic_references +Fish mongoengine/tests/fields/fields.py /^ class Fish(Animal):$/;" c function:FieldTest.test_cls_field +Fish tests/fields/fields.py /^ class Fish(Animal):$/;" c function:FieldTest.test_cls_field +FloatField mongoengine/fields.py /^class FloatField(BaseField):$/;" c +FloatField mongoengine/mongoengine/fields.py /^class FloatField(BaseField):$/;" c +Foo mongoengine/tests/document/instance.py /^ class Foo(Document):$/;" c function:InstanceTest.test_duplicate_db_fields_raise_invalid_document_error +Foo mongoengine/tests/document/instance.py /^ class Foo(Document):$/;" c function:InstanceTest.test_reload_doesnt_exist +Foo mongoengine/tests/document/instance.py /^ class Foo(Document):$/;" c function:InstanceTest.test_save_max_recursion_not_hit_with_file_field +Foo mongoengine/tests/document/instance.py /^ class Foo(Document):$/;" c function:InstanceTest.test_two_way_reverse_delete_rule +Foo mongoengine/tests/document/instance.py /^ class Foo(EmbeddedDocument):$/;" c function:InstanceTest.test_shard_key_in_embedded_document +Foo mongoengine/tests/document/instance.py /^ class Foo(EmbeddedDocument, NameMixin):$/;" c function:InstanceTest.test_object_mixins +Foo mongoengine/tests/fields/fields.py /^ class Foo(Base):$/;" c function:FieldTest.test_inherited_sequencefield +Foo mongoengine/tests/fields/fields.py /^ class Foo(Base):$/;" c function:FieldTest.test_no_inherited_sequencefield +Foo mongoengine/tests/fields/fields.py /^ class Foo(Document):$/;" c function:FieldTest.test_list_field_passed_in_value +Foo mongoengine/tests/fields/fields.py /^ class Foo(Document):$/;" c function:FieldTest.test_reference_miss +Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_custom_manager_overriding_objects_works +Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_distinct_ListField_ReferenceField +Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_distinct_handles_references +Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_distinct_handles_references_to_alias +Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_inherit_objects +Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_inherit_objects_override +Foo mongoengine/tests/queryset/queryset.py /^ class Foo(EmbeddedDocument):$/;" c function:QuerySetTest.test_elem_match +Foo mongoengine/tests/queryset/queryset.py /^ class Foo(EmbeddedDocument):$/;" c function:QuerySetTest.test_pull_in_genericembedded_field +Foo mongoengine/tests/queryset/transform.py /^ class Foo(Document):$/;" c function:TransformTest.test_raw_query_and_Q_objects +Foo mongoengine/tests/test_dereference.py /^ class Foo(Document):$/;" c function:FieldTest.test_document_reload_no_inheritance +Foo tests/fields/fields.py /^ class Foo(Base):$/;" c function:FieldTest.test_inherited_sequencefield +Foo tests/fields/fields.py /^ class Foo(Base):$/;" c function:FieldTest.test_no_inherited_sequencefield +Foo tests/fields/fields.py /^ class Foo(Document):$/;" c function:FieldTest.test_list_field_passed_in_value +Foo tests/fields/fields.py /^ class Foo(Document):$/;" c function:FieldTest.test_reference_miss +FooBar mongoengine/tests/document/instance.py /^ class FooBar(Document):$/;" c function:InstanceTest.test_set_unset_one_operation +GEO_OPERATORS mongoengine/mongoengine/queryset/transform.py /^GEO_OPERATORS = ('within_distance', 'within_spherical_distance',$/;" v +GenericEmbeddedDocumentField mongoengine/fields.py /^class GenericEmbeddedDocumentField(BaseField):$/;" c +GenericEmbeddedDocumentField mongoengine/mongoengine/fields.py /^class GenericEmbeddedDocumentField(BaseField):$/;" c +GenericLazyReferenceField mongoengine/fields.py /^class GenericLazyReferenceField(GenericReferenceField):$/;" c +GenericLazyReferenceField mongoengine/mongoengine/fields.py /^class GenericLazyReferenceField(GenericReferenceField):$/;" c +GenericLazyReferenceFieldTest mongoengine/tests/fields/fields.py /^class GenericLazyReferenceFieldTest(MongoDBTestCase):$/;" c +GenericLazyReferenceFieldTest tests/fields/fields.py /^class GenericLazyReferenceFieldTest(MongoDBTestCase):$/;" c +GenericReferenceField mongoengine/fields.py /^class GenericReferenceField(BaseField):$/;" c +GenericReferenceField mongoengine/mongoengine/fields.py /^class GenericReferenceField(BaseField):$/;" c +GeoFieldTest mongoengine/tests/fields/geo.py /^class GeoFieldTest(unittest.TestCase):$/;" c +GeoJsonBaseField mongoengine/mongoengine/base/fields.py /^class GeoJsonBaseField(BaseField):$/;" c +GeoPointField mongoengine/fields.py /^class GeoPointField(BaseField):$/;" c +GeoPointField mongoengine/mongoengine/fields.py /^class GeoPointField(BaseField):$/;" c +GeoQueriesTest mongoengine/tests/queryset/geo.py /^class GeoQueriesTest(MongoDBTestCase):$/;" c +GridDocument mongoengine/tests/fields/file_tests.py /^ class GridDocument(Document):$/;" c function:FileTest.test_file_field_no_default +GridFSError mongoengine/fields.py /^class GridFSError(Exception):$/;" c +GridFSError mongoengine/mongoengine/fields.py /^class GridFSError(Exception):$/;" c +GridFSProxy mongoengine/fields.py /^class GridFSProxy(object):$/;" c +GridFSProxy mongoengine/mongoengine/fields.py /^class GridFSProxy(object):$/;" c +Group mongoengine/tests/document/instance.py /^ class Group(Document):$/;" c function:InstanceTest.test_switch_db_instance +Group mongoengine/tests/fields/fields.py /^ class Group(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference +Group mongoengine/tests/fields/fields.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference +Group mongoengine/tests/fields/fields.py /^ class Group(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list +Group mongoengine/tests/queryset/queryset.py /^ class Group(Document):$/;" c function:QuerySetTest.test_update_value_conversion +Group mongoengine/tests/test_context_managers.py /^ class Group(Document):$/;" c function:ContextManagersTest.test_no_dereference_context_manager_dbref +Group mongoengine/tests/test_context_managers.py /^ class Group(Document):$/;" c function:ContextManagersTest.test_no_dereference_context_manager_object_id +Group mongoengine/tests/test_context_managers.py /^ class Group(Document):$/;" c function:ContextManagersTest.test_switch_collection_context_manager +Group mongoengine/tests/test_context_managers.py /^ class Group(Document):$/;" c function:ContextManagersTest.test_switch_db_context_manager +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_dict_field +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_dict_field_no_field_inheritance +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_generic_reference +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_generic_reference_map_field +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_handle_old_style_references +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_field_complex +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false_stores_as_type +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_map_field_reference +Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_migrate_references +Group tests/fields/fields.py /^ class Group(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference +Group tests/fields/fields.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference +Group tests/fields/fields.py /^ class Group(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list +Guppy mongoengine/tests/document/inheritance.py /^ class Guppy(Fish): pass$/;" c function:InheritanceTest.test_abstract_documents +Guppy mongoengine/tests/document/inheritance.py /^ class Guppy(Fish): pass$/;" c function:InheritanceTest.test_external_subclasses +Guppy mongoengine/tests/document/inheritance.py /^ class Guppy(Fish): pass$/;" c function:InheritanceTest.test_external_superclasses +Guppy mongoengine/tests/document/inheritance.py /^ class Guppy(Fish): pass$/;" c function:InheritanceTest.test_subclasses +Guppy mongoengine/tests/document/inheritance.py /^ class Guppy(Fish): pass$/;" c function:InheritanceTest.test_superclasses +HAS_PIL mongoengine/tests/fields/file_tests.py /^ HAS_PIL = False$/;" v +HAS_PIL mongoengine/tests/fields/file_tests.py /^ HAS_PIL = True$/;" v +HandleNoneFields mongoengine/tests/fields/fields.py /^ class HandleNoneFields(Document):$/;" c function:FieldTest.test_not_required_handles_none_from_database +HandleNoneFields mongoengine/tests/fields/fields.py /^ class HandleNoneFields(Document):$/;" c function:FieldTest.test_not_required_handles_none_in_update +HandleNoneFields tests/fields/fields.py /^ class HandleNoneFields(Document):$/;" c function:FieldTest.test_not_required_handles_none_from_database +HandleNoneFields tests/fields/fields.py /^ class HandleNoneFields(Document):$/;" c function:FieldTest.test_not_required_handles_none_in_update +Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_abstract_documents +Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_external_subclasses +Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_external_superclasses +Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_polymorphic_queries +Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_subclasses +Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_superclasses +Human mongoengine/tests/document/instance.py /^ class Human(Mammal):$/;" c function:InstanceTest.test_polymorphic_references +Human mongoengine/tests/fields/fields.py /^ class Human(Mammal):$/;" c function:FieldTest.test_cls_field +Human tests/fields/fields.py /^ class Human(Mammal):$/;" c function:FieldTest.test_cls_field +IS_PYMONGO_3 mongoengine/mongoengine/python_support.py /^ IS_PYMONGO_3 = False$/;" v +IS_PYMONGO_3 mongoengine/mongoengine/python_support.py /^ IS_PYMONGO_3 = True$/;" v +ITER_CHUNK_SIZE mongoengine/mongoengine/queryset/queryset.py /^ITER_CHUNK_SIZE = 100$/;" v +Image mongoengine/fields.py /^ Image = None$/;" v +Image mongoengine/mongoengine/fields.py /^ Image = None$/;" v +ImageField mongoengine/fields.py /^class ImageField(FileField):$/;" c +ImageField mongoengine/mongoengine/fields.py /^class ImageField(FileField):$/;" c +ImageGridFsProxy mongoengine/fields.py /^class ImageGridFsProxy(GridFSProxy):$/;" c +ImageGridFsProxy mongoengine/mongoengine/fields.py /^class ImageGridFsProxy(GridFSProxy):$/;" c +ImageOps mongoengine/fields.py /^ ImageOps = None$/;" v +ImageOps mongoengine/mongoengine/fields.py /^ ImageOps = None$/;" v +ImagePost mongoengine/docs/code/tumblelog.py /^class ImagePost(Post):$/;" c +ImproperlyConfigured mongoengine/fields.py /^class ImproperlyConfigured(Exception):$/;" c +ImproperlyConfigured mongoengine/mongoengine/fields.py /^class ImproperlyConfigured(Exception):$/;" c +IndexesTest mongoengine/tests/document/indexes.py /^class IndexesTest(unittest.TestCase):$/;" c +Info mongoengine/tests/fields/fields.py /^ class Info(EmbeddedDocument):$/;" c function:FieldTest.test_map_field_unicode +Info tests/fields/fields.py /^ class Info(EmbeddedDocument):$/;" c function:FieldTest.test_map_field_unicode +InheritanceTest mongoengine/tests/document/inheritance.py /^class InheritanceTest(unittest.TestCase):$/;" c +InheritedAbstractNamingTest mongoengine/tests/document/class_methods.py /^ class InheritedAbstractNamingTest(BaseDocument):$/;" c function:ClassMethodsTest.test_collection_naming +InheritedDocumentFailTest mongoengine/tests/all_warnings/__init__.py /^ class InheritedDocumentFailTest(NonAbstractBase):$/;" c function:AllWarnings.test_document_collection_syntax_warning +InstanceTest mongoengine/tests/document/instance.py /^class InstanceTest(unittest.TestCase):$/;" c +Int64 mongoengine/fields.py /^ Int64 = long$/;" v +Int64 mongoengine/mongoengine/fields.py /^ Int64 = long$/;" v +Int64 mongoengine/tests/fields/fields.py /^ Int64 = long$/;" v +Int64 tests/fields/fields.py /^ Int64 = long$/;" v +IntField mongoengine/fields.py /^class IntField(BaseField):$/;" c +IntField mongoengine/mongoengine/fields.py /^class IntField(BaseField):$/;" c +IntPair mongoengine/tests/queryset/queryset.py /^ class IntPair(Document):$/;" c function:QuerySetTest.test_where +IntegerSetting mongoengine/tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_complex_mapfield +IntegerSetting mongoengine/tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_dictfield_complex +IntegerSetting mongoengine/tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_list_field_complex +IntegerSetting tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_complex_mapfield +IntegerSetting tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_dictfield_complex +IntegerSetting tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_list_field_complex +InvalidCollectionError mongoengine/mongoengine/document.py /^class InvalidCollectionError(Exception):$/;" c +InvalidDocumentError mongoengine/mongoengine/errors.py /^class InvalidDocumentError(Exception):$/;" c +InvalidQueryError mongoengine/mongoengine/errors.py /^class InvalidQueryError(Exception):$/;" c +Item mongoengine/tests/queryset/queryset.py /^ class Item(Document):$/;" c function:QuerySetTest.test_add_to_set_each +Item mongoengine/tests/queryset/visitor.py /^ class Item(Document):$/;" c function:QTest.test_chained_q_or_filtering +Job mongoengine/tests/document/class_methods.py /^ class Job(Document):$/;" c function:ClassMethodsTest.test_register_delete_rule +Job mongoengine/tests/document/instance.py /^ class Job(Document):$/;" c function:InstanceTest.test_do_not_save_unchanged_references +Job mongoengine/tests/document/instance.py /^ class Job(EmbeddedDocument):$/;" c function:InstanceTest.setUp +LONG_DESCRIPTION mongoengine/setup.py /^ LONG_DESCRIPTION = fin.read()$/;" v +LONG_DESCRIPTION mongoengine/setup.py /^ LONG_DESCRIPTION = None$/;" v +LastLogin mongoengine/tests/queryset/queryset.py /^ class LastLogin(EmbeddedDocument):$/;" c function:QuerySetTest.test_as_pymongo +LazyReference mongoengine/mongoengine/base/datastructures.py /^class LazyReference(DBRef):$/;" c +LazyReferenceField mongoengine/fields.py /^class LazyReferenceField(BaseField):$/;" c +LazyReferenceField mongoengine/mongoengine/fields.py /^class LazyReferenceField(BaseField):$/;" c +LazyReferenceFieldTest mongoengine/tests/fields/fields.py /^class LazyReferenceFieldTest(MongoDBTestCase):$/;" c +LazyReferenceFieldTest tests/fields/fields.py /^class LazyReferenceFieldTest(MongoDBTestCase):$/;" c +LineStringField mongoengine/fields.py /^class LineStringField(GeoJsonBaseField):$/;" c +LineStringField mongoengine/mongoengine/fields.py /^class LineStringField(GeoJsonBaseField):$/;" c +Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference +Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_choices +Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_document_not_registered +Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_list +Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_list_choices +Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_string_choices +Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_unicode_url_validation +Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_url_scheme_validation +Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_url_validation +Link mongoengine/tests/queryset/queryset.py /^ class Link(Document):$/;" c function:QuerySetTest.test_map_reduce_finalize +Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference +Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_choices +Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_document_not_registered +Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_list +Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_list_choices +Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_string_choices +Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_unicode_url_validation +Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_url_scheme_validation +Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_url_validation +LinkPost mongoengine/docs/code/tumblelog.py /^class LinkPost(Post):$/;" c +LisDoc mongoengine/tests/queryset/transform.py /^ class LisDoc(Document):$/;" c function:TransformTest.test_transform_update +ListField mongoengine/fields.py /^class ListField(ComplexBaseField):$/;" c +ListField mongoengine/mongoengine/fields.py /^class ListField(ComplexBaseField):$/;" c +Locale mongoengine/tests/queryset/queryset.py /^ class Locale(EmbeddedDocument):$/;" c function:QuerySetTest.test_scalar_embedded +Location mongoengine/tests/document/instance.py /^ class Location(Document):$/;" c function:InstanceTest.test_document_registry_regressions +Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_geo_indexes_recursion +Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_geopoint_validation +Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_linestring_validation +Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_multilinestring_validation +Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_multipoint_validation +Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_multipolygon_validation +Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_point_validation +Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_polygon_validation +Location mongoengine/tests/queryset/geo.py /^ class Location(Document):$/;" c function:GeoQueriesTest.test_2dsphere_linestring_sets_correctly +Location mongoengine/tests/queryset/geo.py /^ class Location(Document):$/;" c function:GeoQueriesTest.test_2dsphere_point_sets_correctly +Location mongoengine/tests/queryset/geo.py /^ class Location(Document):$/;" c function:GeoQueriesTest.test_geojson_PolygonField +Location mongoengine/tests/queryset/transform.py /^ class Location(Document):$/;" c function:TransformTest.test_geojson_LineStringField +Location mongoengine/tests/queryset/transform.py /^ class Location(Document):$/;" c function:TransformTest.test_geojson_PointField +Location mongoengine/tests/queryset/transform.py /^ class Location(Document):$/;" c function:TransformTest.test_geojson_PolygonField +Log mongoengine/tests/document/indexes.py /^ class Log(Document):$/;" c function:IndexesTest.test_ttl_indexes +Log mongoengine/tests/document/instance.py /^ class Log(Document):$/;" c function:InstanceTest.test_capped_collection +Log mongoengine/tests/document/instance.py /^ class Log(Document):$/;" c function:InstanceTest.test_capped_collection_default +Log mongoengine/tests/document/instance.py /^ class Log(Document):$/;" c function:InstanceTest.test_capped_collection_no_max_size_problems +Log mongoengine/tests/fields/fields.py /^ class Log(Document):$/;" c function:FieldTest.test_map_field_lookup +Log mongoengine/tests/fields/geo.py /^ class Log(Document):$/;" c function:GeoFieldTest.test_geo_indexes_auto_index +Log mongoengine/tests/queryset/queryset.py /^ class Log(Document):$/;" c function:QuerySetTest.test_delete_with_limits +Log tests/fields/fields.py /^ class Log(Document):$/;" c function:FieldTest.test_map_field_lookup +LogEntry mongoengine/tests/document/instance.py /^ class LogEntry(Document):$/;" c function:InstanceTest.test_shard_key +LogEntry mongoengine/tests/document/instance.py /^ class LogEntry(Document):$/;" c function:InstanceTest.test_shard_key_primary +LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_complexdatetime_storage +LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_complexdatetime_usage +LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime +LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_tz_aware_mark_as_changed +LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_usage +LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_validation +LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_complexdatetime_storage +LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_complexdatetime_usage +LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime +LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_tz_aware_mark_as_changed +LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_usage +LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_validation +LongField mongoengine/fields.py /^class LongField(BaseField):$/;" c +LongField mongoengine/mongoengine/fields.py /^class LongField(BaseField):$/;" c +LookUpError mongoengine/mongoengine/errors.py /^class LookUpError(AttributeError):$/;" c +MATCH_OPERATORS mongoengine/mongoengine/queryset/transform.py /^MATCH_OPERATORS = (COMPARISON_OPERATORS + GEO_OPERATORS +$/;" v +MONGO_TEST_DB mongoengine/tests/utils.py /^MONGO_TEST_DB = 'mongoenginetest'$/;" v +Macro mongoengine/tests/document/instance.py /^ class Macro(EmbeddedDocument):$/;" c function:InstanceTest.test_complex_nesting_document_and_embedded_document +Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal):$/;" c class:InheritanceTest.test_allow_inheritance_abstract_document.Animal +Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal):$/;" c class:InheritanceTest.test_cant_turn_off_inheritance_on_subclass.Animal +Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal): pass$/;" c function:InheritanceTest.test_external_subclasses +Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal): pass$/;" c function:InheritanceTest.test_external_superclasses +Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal): pass$/;" c function:InheritanceTest.test_polymorphic_queries +Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal): pass$/;" c function:InheritanceTest.test_subclasses +Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal): pass$/;" c function:InheritanceTest.test_superclasses +Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal):$/;" c function:InheritanceTest.test_abstract_documents +Mammal mongoengine/tests/document/instance.py /^ class Mammal(Animal):$/;" c function:InstanceTest.test_polymorphic_references +Mammal mongoengine/tests/fields/fields.py /^ class Mammal(Animal):$/;" c function:FieldTest.test_cls_field +Mammal tests/fields/fields.py /^ class Mammal(Animal):$/;" c function:FieldTest.test_cls_field +MapField mongoengine/fields.py /^class MapField(DictField):$/;" c +MapField mongoengine/mongoengine/fields.py /^class MapField(DictField):$/;" c +MapReduceDocument mongoengine/mongoengine/document.py /^class MapReduceDocument(object):$/;" c +Member mongoengine/tests/fields/fields.py /^ class Member(Document):$/;" c function:FieldTest.test_reference_query_conversion +Member mongoengine/tests/fields/fields.py /^ class Member(Document):$/;" c function:FieldTest.test_reference_query_conversion_dbref +Member mongoengine/tests/fields/fields.py /^ class Member(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion +Member mongoengine/tests/fields/fields.py /^ class Member(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion +Member mongoengine/tests/fields/fields.py /^ class Member(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref +Member mongoengine/tests/queryset/queryset.py /^ class Member(EmbeddedDocument):$/;" c function:QuerySetTest.test_mapfield_update +Member mongoengine/tests/queryset/queryset.py /^ class Member(EmbeddedDocument):$/;" c function:QuerySetTest.test_no_dereference_embedded_doc +Member tests/fields/fields.py /^ class Member(Document):$/;" c function:FieldTest.test_reference_query_conversion +Member tests/fields/fields.py /^ class Member(Document):$/;" c function:FieldTest.test_reference_query_conversion_dbref +Member tests/fields/fields.py /^ class Member(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion +Member tests/fields/fields.py /^ class Member(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion +Member tests/fields/fields.py /^ class Member(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref +Message mongoengine/tests/queryset/queryset.py /^ class Message(Document):$/;" c function:QuerySetTest.test_set_list_embedded_documents +Message mongoengine/tests/test_dereference.py /^ class Message(Document):$/;" c function:FieldTest.test_document_reload_reference_integrity +Message mongoengine/tests/test_dereference.py /^ class Message(Document):$/;" c function:FieldTest.test_list_lookup_not_checked_in_map +MetaDict mongoengine/mongoengine/base/metaclasses.py /^class MetaDict(dict):$/;" c +Mineral mongoengine/tests/fields/fields.py /^ class Mineral(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices +Mineral tests/fields/fields.py /^ class Mineral(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices +Mixin mongoengine/tests/fixtures.py /^class Mixin(object):$/;" c +ModeratorComments mongoengine/tests/fields/fields.py /^ class ModeratorComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_invalid +ModeratorComments tests/fields/fields.py /^ class ModeratorComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_invalid +MongoDBTestCase mongoengine/tests/utils.py /^class MongoDBTestCase(unittest.TestCase):$/;" c +MongoEngineConnectionError mongoengine/mongoengine/connection.py /^class MongoEngineConnectionError(Exception):$/;" c +MongoUser mongoengine/tests/document/indexes.py /^ class MongoUser(User):$/;" c function:IndexesTest.test_disable_index_creation +Mother mongoengine/tests/fields/fields.py /^ class Mother(Document):$/;" c function:FieldTest.test_abstract_reference_base_type +Mother tests/fields/fields.py /^ class Mother(Document):$/;" c function:FieldTest.test_abstract_reference_base_type +MultiLineStringField mongoengine/fields.py /^class MultiLineStringField(GeoJsonBaseField):$/;" c +MultiLineStringField mongoengine/mongoengine/fields.py /^class MultiLineStringField(GeoJsonBaseField):$/;" c +MultiPointField mongoengine/fields.py /^class MultiPointField(GeoJsonBaseField):$/;" c +MultiPointField mongoengine/mongoengine/fields.py /^class MultiPointField(GeoJsonBaseField):$/;" c +MultiPolygonField mongoengine/fields.py /^class MultiPolygonField(GeoJsonBaseField):$/;" c +MultiPolygonField mongoengine/mongoengine/fields.py /^class MultiPolygonField(GeoJsonBaseField):$/;" c +MultipleObjectsReturned mongoengine/mongoengine/errors.py /^class MultipleObjectsReturned(Exception):$/;" c +MyDoc mongoengine/tests/document/delta.py /^ class MyDoc(Document):$/;" c function:DeltaTest.test_lower_level_mark_as_changed +MyDoc mongoengine/tests/document/delta.py /^ class MyDoc(Document):$/;" c function:DeltaTest.test_nested_nested_fields_mark_as_changed +MyDoc mongoengine/tests/document/delta.py /^ class MyDoc(Document):$/;" c function:DeltaTest.test_upper_level_mark_as_changed +MyDoc mongoengine/tests/document/indexes.py /^ class MyDoc(Document):$/;" c function:IndexesTest.test_build_index_spec_is_not_destructive +MyDoc mongoengine/tests/document/indexes.py /^ class MyDoc(Document):$/;" c function:IndexesTest.test_sparse_compound_indexes +MyDoc mongoengine/tests/document/indexes.py /^ class MyDoc(Document):$/;" c function:IndexesTest.test_string_indexes +MyDoc mongoengine/tests/fields/fields.py /^ class MyDoc(Document):$/;" c function:FieldTest.test_datetime_from_empty_string +MyDoc mongoengine/tests/fields/fields.py /^ class MyDoc(Document):$/;" c function:FieldTest.test_datetime_from_whitespace_string +MyDoc mongoengine/tests/queryset/field_list.py /^ class MyDoc(Document):$/;" c function:OnlyExcludeAllTest.test_mix_slice_with_other_fields +MyDoc mongoengine/tests/queryset/field_list.py /^ class MyDoc(Document):$/;" c function:OnlyExcludeAllTest.test_mixing_only_exclude +MyDoc mongoengine/tests/queryset/field_list.py /^ class MyDoc(Document):$/;" c function:OnlyExcludeAllTest.test_slicing +MyDoc mongoengine/tests/queryset/queryset.py /^ class MyDoc(Document):$/;" c function:QuerySetTest.test_count_and_none +MyDoc mongoengine/tests/queryset/queryset.py /^ class MyDoc(Document):$/;" c function:QuerySetTest.test_dictfield_key_looks_like_a_digit +MyDoc mongoengine/tests/queryset/queryset.py /^ class MyDoc(DynamicDocument):$/;" c function:QuerySetTest.test_update_upsert_looks_like_a_digit +MyDoc tests/fields/fields.py /^ class MyDoc(Document):$/;" c function:FieldTest.test_datetime_from_empty_string +MyDoc tests/fields/fields.py /^ class MyDoc(Document):$/;" c function:FieldTest.test_datetime_from_whitespace_string +MyDocument mongoengine/tests/document/class_methods.py /^ class MyDocument(BaseDocument):$/;" c function:ClassMethodsTest.test_collection_naming +MyDocument mongoengine/tests/document/inheritance.py /^ class MyDocument(DateCreatedDocument, DateUpdatedDocument):$/;" c class:InheritanceTest.test_document_inheritance.DateUpdatedDocument +MyPerson mongoengine/tests/document/instance.py /^ class MyPerson(self.Person):$/;" c function:InstanceTest.test_from_son +NON_FIELD_ERRORS mongoengine/mongoengine/base/document.py /^NON_FIELD_ERRORS = '__all__'$/;" v +NULLIFY mongoengine/mongoengine/queryset/base.py /^NULLIFY = 1$/;" v +NameMixin mongoengine/tests/document/instance.py /^ class NameMixin(object):$/;" c function:InstanceTest.test_object_mixins +Namespace mongoengine/mongoengine/signals.py /^ class Namespace(object):$/;" c +NewDocumentPickleTest mongoengine/tests/fixtures.py /^class NewDocumentPickleTest(Document):$/;" c +News mongoengine/tests/queryset/queryset.py /^ class News(Document):$/;" c function:QuerySetTest.test_text_indexes +NicePlace mongoengine/tests/document/instance.py /^ class NicePlace(Place):$/;" c function:InstanceTest.test_document_not_registered +NoDeclaredType mongoengine/tests/fields/fields.py /^ class NoDeclaredType(Document):$/;" c class:FieldTest.test_mapfield.Simple +NoDeclaredType tests/fields/fields.py /^ class NoDeclaredType(Document):$/;" c class:FieldTest.test_mapfield.Simple +Noddy mongoengine/tests/queryset/queryset.py /^ class Noddy(Document):$/;" c function:QuerySetTest.test_no_cache +Node mongoengine/tests/document/instance.py /^ class Node(Document):$/;" c function:InstanceTest.test_complex_nesting_document_and_embedded_document +NodesSystem mongoengine/tests/document/instance.py /^ class NodesSystem(Document):$/;" c function:InstanceTest.test_complex_nesting_document_and_embedded_document +NonAbstractBase mongoengine/tests/all_warnings/__init__.py /^ class NonAbstractBase(Document):$/;" c function:AllWarnings.test_document_collection_syntax_warning +NotRegistered mongoengine/mongoengine/errors.py /^class NotRegistered(Exception):$/;" c +NotUniqueError mongoengine/mongoengine/errors.py /^class NotUniqueError(OperationError):$/;" c +Number mongoengine/tests/queryset/queryset.py /^ class Number(Document):$/;" c function:QuerySetTest.test_clone +Number mongoengine/tests/queryset/queryset.py /^ class Number(Document):$/;" c function:QuerySetTest.test_order_then_filter +Number mongoengine/tests/queryset/queryset.py /^ class Number(Document):$/;" c function:QuerySetTest.test_order_works_with_custom_db_field_names +Number mongoengine/tests/queryset/queryset.py /^ class Number(Document):$/;" c function:QuerySetTest.test_order_works_with_primary +Number2 mongoengine/tests/queryset/queryset.py /^ class Number2(Document):$/;" c function:QuerySetTest.test_using +Numbers mongoengine/tests/queryset/field_list.py /^ class Numbers(Document):$/;" c function:OnlyExcludeAllTest.test_slicing_fields +Numbers mongoengine/tests/queryset/field_list.py /^ class Numbers(Document):$/;" c function:OnlyExcludeAllTest.test_slicing_nested_fields +ONLY mongoengine/mongoengine/queryset/field_list.py /^ ONLY = 1$/;" v class:QueryFieldList +OR mongoengine/mongoengine/queryset/visitor.py /^ OR = 1$/;" v class:QNode +ObjectIdField mongoengine/mongoengine/base/fields.py /^class ObjectIdField(BaseField):$/;" c +Occurrence mongoengine/tests/document/instance.py /^ class Occurrence(EmbeddedDocument):$/;" c function:InstanceTest.test_invalid_son +Ocorrence mongoengine/tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields +Ocorrence mongoengine/tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields +Ocorrence mongoengine/tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_get_and_save +Ocorrence mongoengine/tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields +Ocorrence tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields +Ocorrence tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields +Ocorrence tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_get_and_save +Ocorrence tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_not_set +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_passthrough +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set +Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_simple +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_not_set +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_passthrough +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set +Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_simple +OldMixinNamingConvention mongoengine/tests/document/class_methods.py /^ class OldMixinNamingConvention(Document, BaseMixin):$/;" c function:ClassMethodsTest.test_collection_naming +OldNamingConvention mongoengine/tests/document/class_methods.py /^ class OldNamingConvention(BaseDocument):$/;" c function:ClassMethodsTest.test_collection_naming +OnlyExcludeAllTest mongoengine/tests/queryset/field_list.py /^class OnlyExcludeAllTest(unittest.TestCase):$/;" c +OperationError mongoengine/mongoengine/errors.py /^class OperationError(Exception):$/;" c +Organization mongoengine/tests/document/delta.py /^ class Organization(DocClass2):$/;" c function:DeltaTest.circular_reference_deltas +Organization mongoengine/tests/document/delta.py /^ class Organization(DocClass2):$/;" c function:DeltaTest.circular_reference_deltas_2 +Organization mongoengine/tests/document/delta.py /^ class Organization(Document):$/;" c function:DeltaTest.test_referenced_object_changed_attributes +Organization mongoengine/tests/document/instance.py /^ class Organization(Document):$/;" c function:InstanceTest.test_query_count_when_saving +Organization mongoengine/tests/queryset/queryset.py /^ class Organization(Document):$/;" c function:QuerySetTest.test_get_changed_fields_query_count +Organization mongoengine/tests/queryset/queryset.py /^ class Organization(Document):$/;" c function:QuerySetTest.test_no_dereference +Organization mongoengine/tests/queryset/queryset.py /^ class Organization(Document):$/;" c function:QuerySetTest.test_no_dereference_embedded_doc +Organization mongoengine/tests/queryset/queryset.py /^ class Organization(Document):$/;" c function:QuerySetTest.test_scalar +Other mongoengine/tests/test_dereference.py /^ class Other(EmbeddedDocument):$/;" c function:FieldTest.test_circular_tree_reference +Owner mongoengine/tests/fields/fields.py /^ class Owner(EmbeddedDocument):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields +Owner mongoengine/tests/fields/fields.py /^ class Owner(EmbeddedDocument):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields +Owner tests/fields/fields.py /^ class Owner(EmbeddedDocument):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields +Owner tests/fields/fields.py /^ class Owner(EmbeddedDocument):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields +PAPER mongoengine/docs/Makefile /^PAPER =$/;" m +PAPEROPT_a4 mongoengine/docs/Makefile /^PAPEROPT_a4 = -D latex_paper_size=a4$/;" m +PAPEROPT_letter mongoengine/docs/Makefile /^PAPEROPT_letter = -D latex_paper_size=letter$/;" m +PULL mongoengine/mongoengine/queryset/base.py /^PULL = 4$/;" v +Page mongoengine/tests/document/instance.py /^ class Page(Document):$/;" c function:InstanceTest.test_list_search_by_embedded +Page mongoengine/tests/document/instance.py /^ class Page(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_update +Page mongoengine/tests/document/instance.py /^ class Page(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_update_after_save +Page mongoengine/tests/document/instance.py /^ class Page(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_update_db_field +Page mongoengine/tests/test_dereference.py /^ class Page(Document):$/;" c function:FieldTest.test_dereferencing_embedded_listfield_referencefield +Parameter mongoengine/tests/document/instance.py /^ class Parameter(EmbeddedDocument):$/;" c function:InstanceTest.test_complex_nesting_document_and_embedded_document +Parent mongoengine/tests/document/validation.py /^ class Parent(Document):$/;" c function:ValidatorErrorTest.test_parent_reference_in_child_document +Parent mongoengine/tests/document/validation.py /^ class Parent(Document):$/;" c function:ValidatorErrorTest.test_parent_reference_set_as_attribute_in_child_document +Parent mongoengine/tests/fields/geo.py /^ class Parent(Document):$/;" c function:GeoFieldTest.test_geo_indexes_recursion +Parents mongoengine/tests/document/instance.py /^ class Parents(EmbeddedDocument):$/;" c function:InstanceTest.test_invalid_reverse_delete_rule_raise_errors +Pay mongoengine/tests/queryset/queryset.py /^ class Pay(EmbeddedDocument):$/;" c function:QuerySetTest.test_embedded_array_average +Pay mongoengine/tests/queryset/queryset.py /^ class Pay(EmbeddedDocument):$/;" c function:QuerySetTest.test_embedded_array_sum +Pay mongoengine/tests/queryset/queryset.py /^ class Pay(EmbeddedDocument):$/;" c function:QuerySetTest.test_embedded_average +Pay mongoengine/tests/queryset/queryset.py /^ class Pay(EmbeddedDocument):$/;" c function:QuerySetTest.test_embedded_sum +Person mongoengine/tests/document/class_methods.py /^ class Person(Document):$/;" c function:ClassMethodsTest.setUp +Person mongoengine/tests/document/class_methods.py /^ class Person(Document):$/;" c function:ClassMethodsTest.test_collection_name_and_primary +Person mongoengine/tests/document/class_methods.py /^ class Person(Document):$/;" c function:ClassMethodsTest.test_custom_collection_name_operations +Person mongoengine/tests/document/delta.py /^ class Person(DocClass1):$/;" c function:DeltaTest.circular_reference_deltas +Person mongoengine/tests/document/delta.py /^ class Person(DocClass1):$/;" c function:DeltaTest.circular_reference_deltas_2 +Person mongoengine/tests/document/delta.py /^ class Person(Document):$/;" c function:DeltaTest.setUp +Person mongoengine/tests/document/delta.py /^ class Person(DynamicDocument):$/;" c function:DeltaTest.test_delta_for_dynamic_documents +Person mongoengine/tests/document/dynamic.py /^ class Person(DynamicDocument):$/;" c function:DynamicTest.setUp +Person mongoengine/tests/document/dynamic.py /^ class Person(DynamicDocument):$/;" c function:DynamicTest.test_complex_dynamic_document_queries +Person mongoengine/tests/document/dynamic.py /^ class Person(DynamicDocument):$/;" c function:DynamicTest.test_dynamic_and_embedded +Person mongoengine/tests/document/dynamic.py /^ class Person(DynamicDocument):$/;" c function:DynamicTest.test_dynamic_and_embedded_dict_access +Person mongoengine/tests/document/dynamic.py /^ class Person(DynamicDocument):$/;" c function:DynamicTest.test_dynamic_embedded_works_with_only +Person mongoengine/tests/document/indexes.py /^ class Person(Document):$/;" c function:IndexesTest.setUp +Person mongoengine/tests/document/indexes.py /^ class Person(Document):$/;" c function:IndexesTest.test_embedded_document_index_meta +Person mongoengine/tests/document/indexes.py /^ class Person(UserBase):$/;" c function:IndexesTest.test_abstract_index_inheritance +Person mongoengine/tests/document/inheritance.py /^ class Person(Document):$/;" c function:InheritanceTest.test_inheritance_meta_data +Person mongoengine/tests/document/inheritance.py /^ class Person(Document):$/;" c function:InheritanceTest.test_inheritance_to_mongo_keys +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.setUp +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_data_contains_id_field +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_db_embedded_doc_field_load +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_db_field_load +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_default_values +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_do_not_save_unchanged_references +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_falsey_pk +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_not_saved_eq +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_cascade_kwargs +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_cascade_meta_false +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_cascade_meta_true +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_cascades +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_cascades_generically +Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_max_recursion_not_hit +Person mongoengine/tests/document/instance.py /^ class Person(DynamicDocument):$/;" c function:InstanceTest.test_mixed_creation_dynamic +Person mongoengine/tests/document/instance.py /^ class Person(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_to_mongo +Person mongoengine/tests/document/validation.py /^ class Person(BasePerson):$/;" c function:ValidatorErrorTest.test_fields_rewrite +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_auto_sync +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_update_all +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_boolean_validation +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_dbref_reference_fields +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_dbref_to_mongo +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_comparison +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_storage +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_validation +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_nothing_set +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_set_to_None +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_when_deleting_value +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_when_setting_to_None +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_embedded_document_validation +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_float_validation +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_embedded_document +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_embedded_document_choices +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_list_embedded_document_choices +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_reference_is_none +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_int_validation +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_multiple_sequence_fields +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_multiple_sequence_fields_on_docs +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_object_id_validation +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_objectid_reference_fields +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_required_values +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_get_next_value +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_sequence_name +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_value_decorator +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_string_validation +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_uuid_field_binary +Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_uuid_field_string +Person mongoengine/tests/queryset/field_list.py /^ class Person(Document):$/;" c function:OnlyExcludeAllTest.setUp +Person mongoengine/tests/queryset/pickable.py /^class Person(Document):$/;" c +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.setUp +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_bool_performance +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_bool_with_ordering +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_bool_with_ordering_from_meta_dict +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_cached_queryset +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_get_changed_fields_query_count +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_item_frequencies_null_values +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_item_frequencies_on_embedded +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_item_frequencies_with_null_embedded +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_loop_over_invalid_id_does_not_crash +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_map_reduce_custom_output +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_no_cached_queryset +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_queryset_aggregation_framework +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_scalar_decimal +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_scalar_embedded +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_scalar_generic_reference_field +Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_scalar_reference_field +Person mongoengine/tests/queryset/visitor.py /^ class Person(Document):$/;" c function:QTest.setUp +Person mongoengine/tests/queryset/visitor.py /^ class Person(Document):$/;" c function:QTest.test_empty_q +Person mongoengine/tests/test_dereference.py /^ class Person(Document):$/;" c function:FieldTest.test_circular_reference +Person mongoengine/tests/test_dereference.py /^ class Person(Document):$/;" c function:FieldTest.test_circular_reference_on_self +Person mongoengine/tests/test_dereference.py /^ class Person(Document):$/;" c function:FieldTest.test_circular_tree_reference +Person mongoengine/tests/test_dereference.py /^ class Person(Document):$/;" c function:FieldTest.test_dict_in_dbref_instance +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_auto_sync +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_update_all +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_boolean_validation +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_dbref_reference_fields +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_dbref_to_mongo +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_comparison +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_storage +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_validation +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_nothing_set +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_set_to_None +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_when_deleting_value +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_when_setting_to_None +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_embedded_document_validation +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_float_validation +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_embedded_document +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_embedded_document_choices +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_list_embedded_document_choices +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_reference_is_none +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_int_validation +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_multiple_sequence_fields +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_multiple_sequence_fields_on_docs +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_object_id_validation +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_objectid_reference_fields +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_required_values +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_get_next_value +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_sequence_name +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_value_decorator +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_string_validation +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_uuid_field_binary +Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_uuid_field_string +PersonAuto mongoengine/tests/fields/fields.py /^ class PersonAuto(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_decimal +PersonAuto tests/fields/fields.py /^ class PersonAuto(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_decimal +PersonMeta mongoengine/tests/queryset/queryset.py /^ class PersonMeta(EmbeddedDocument):$/;" c function:QuerySetTest.setUp +PersonPreferences mongoengine/tests/fields/fields.py /^ class PersonPreferences(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_validation +PersonPreferences tests/fields/fields.py /^ class PersonPreferences(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_validation +Persone mongoengine/tests/fields/fields.py /^ class Persone(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled +Persone tests/fields/fields.py /^ class Persone(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled +Phone mongoengine/tests/queryset/queryset.py /^ class Phone(EmbeddedDocument):$/;" c function:QuerySetTest.test_item_frequencies_on_embedded +PickleDynamicEmbedded mongoengine/tests/fixtures.py /^class PickleDynamicEmbedded(DynamicEmbeddedDocument):$/;" c +PickleDynamicTest mongoengine/tests/fixtures.py /^class PickleDynamicTest(DynamicDocument):$/;" c +PickleEmbedded mongoengine/tests/fixtures.py /^class PickleEmbedded(EmbeddedDocument):$/;" c +PickleSignalsTest mongoengine/tests/fixtures.py /^class PickleSignalsTest(Document):$/;" c +PickleTest mongoengine/tests/fixtures.py /^class PickleTest(Document):$/;" c +Pike mongoengine/tests/document/inheritance.py /^ class Pike(Fish):$/;" c function:InheritanceTest.test_dynamic_declarations +Place mongoengine/tests/document/indexes.py /^ class Place(Document):$/;" c function:IndexesTest.test_create_geohaystack_index +Place mongoengine/tests/document/indexes.py /^ class Place(Document):$/;" c function:IndexesTest.test_explicit_geo2d_index +Place mongoengine/tests/document/indexes.py /^ class Place(Document):$/;" c function:IndexesTest.test_explicit_geo2d_index_embedded +Place mongoengine/tests/document/indexes.py /^ class Place(Document):$/;" c function:IndexesTest.test_explicit_geohaystack_index +Place mongoengine/tests/document/indexes.py /^ class Place(Document):$/;" c function:IndexesTest.test_explicit_geosphere_index +Place mongoengine/tests/document/instance.py /^ class Place(Document):$/;" c function:InstanceTest.test_document_not_registered +Place mongoengine/tests/queryset/geo.py /^ class Place(Document):$/;" c function:GeoQueriesTest.test_aspymongo_with_only +Playlist mongoengine/tests/test_dereference.py /^ class Playlist(Document):$/;" c function:FieldTest.test_select_related_follows_embedded_referencefields +PlaylistItem mongoengine/tests/test_dereference.py /^ class PlaylistItem(EmbeddedDocument):$/;" c function:FieldTest.test_select_related_follows_embedded_referencefields +Point mongoengine/tests/queryset/geo.py /^ class Point(Document):$/;" c function:GeoQueriesTest.test_spherical_geospatial_operators +PointField mongoengine/fields.py /^class PointField(GeoJsonBaseField):$/;" c +PointField mongoengine/mongoengine/fields.py /^class PointField(GeoJsonBaseField):$/;" c +PolygonField mongoengine/fields.py /^class PolygonField(GeoJsonBaseField):$/;" c +PolygonField mongoengine/mongoengine/fields.py /^class PolygonField(GeoJsonBaseField):$/;" c +Post mongoengine/docs/code/tumblelog.py /^class Post(Document):$/;" c +Post mongoengine/tests/document/instance.py /^ class Post(Document):$/;" c function:InstanceTest.test_reload_of_non_strict_with_special_field_name +Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_embedded_sequence_field +Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference +Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_choices +Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_choices_no_dereference +Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list +Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list_choices +Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list_item_modification +Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_string_choices +Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_recursive_validation +Post mongoengine/tests/queryset/queryset.py /^ class Post(Base):$/;" c function:QuerySetTest.test_custom_querysets_inherited +Post mongoengine/tests/queryset/queryset.py /^ class Post(Base):$/;" c function:QuerySetTest.test_custom_querysets_inherited_direct +Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_call_after_limits_set +Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_count_limit_and_skip +Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_custom_querysets +Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_custom_querysets_managers_directly +Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_custom_querysets_set_manager_directly +Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_unset_reference +Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_updates_can_have_match_operators +Post mongoengine/tests/queryset/queryset.py /^ class Post(EmbeddedDocument):$/;" c function:QuerySetTest.test_bulk_insert +Post mongoengine/tests/queryset/queryset.py /^ class Post(EmbeddedDocument):$/;" c function:QuerySetTest.test_find_array_position +Post mongoengine/tests/queryset/queryset.py /^ class Post(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_array_position +Post mongoengine/tests/queryset/visitor.py /^ class Post(Document):$/;" c function:QTest.test_q_with_dbref +Post mongoengine/tests/queryset/visitor.py /^ class Post(EmbeddedDocument):$/;" c function:QTest.test_chained_q_or_filtering +Post mongoengine/tests/test_dereference.py /^ class Post(Document):$/;" c function:FieldTest.test_list_of_lists_of_references +Post mongoengine/tests/test_dereference.py /^ class Post(EmbeddedDocument):$/;" c function:FieldTest.test_dereferencing_embedded_listfield_referencefield +Post mongoengine/tests/test_signals.py /^ class Post(Document):$/;" c function:SignalTests.setUp +Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_embedded_sequence_field +Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference +Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_choices +Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_choices_no_dereference +Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list +Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list_choices +Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list_item_modification +Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_string_choices +Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_recursive_validation +PowerUser mongoengine/tests/fields/fields.py /^ class PowerUser(User):$/;" c function:FieldTest.test_embedded_document_inheritance +PowerUser tests/fields/fields.py /^ class PowerUser(User):$/;" c function:FieldTest.test_embedded_document_inheritance +Product mongoengine/tests/fields/fields.py /^ class Product(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields +Product mongoengine/tests/fields/fields.py /^ class Product(Document):$/;" c function:FieldTest.test_undefined_reference +Product mongoengine/tests/queryset/queryset.py /^ class Product(Document):$/;" c function:QuerySetTest.test_distinct_handles_db_field +Product tests/fields/fields.py /^ class Product(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields +Product tests/fields/fields.py /^ class Product(Document):$/;" c function:FieldTest.test_undefined_reference +Profile mongoengine/tests/queryset/queryset.py /^ class Profile(EmbeddedDocument):$/;" c function:QuerySetTest.test_scalar_embedded +Project mongoengine/tests/queryset/queryset.py /^ class Project(Document):$/;" c function:QuerySetTest.test_get_changed_fields_query_count +PutFile mongoengine/tests/fields/file_tests.py /^ class PutFile(Document):$/;" c function:FileTest.test_copyable +PutFile mongoengine/tests/fields/file_tests.py /^ class PutFile(Document):$/;" c function:FileTest.test_file_fields +Q mongoengine/mongoengine/queryset/visitor.py /^class Q(QNode):$/;" c +QCombination mongoengine/mongoengine/queryset/visitor.py /^class QCombination(QNode):$/;" c +QNode mongoengine/mongoengine/queryset/visitor.py /^class QNode(object):$/;" c +QNodeVisitor mongoengine/mongoengine/queryset/visitor.py /^class QNodeVisitor(object):$/;" c +QTest mongoengine/tests/queryset/visitor.py /^class QTest(unittest.TestCase):$/;" c +QueryCompilerVisitor mongoengine/mongoengine/queryset/visitor.py /^class QueryCompilerVisitor(QNodeVisitor):$/;" c +QueryFieldList mongoengine/mongoengine/queryset/field_list.py /^class QueryFieldList(object):$/;" c +QueryFieldListTest mongoengine/tests/queryset/field_list.py /^class QueryFieldListTest(unittest.TestCase):$/;" c +QuerySet mongoengine/mongoengine/queryset/queryset.py /^class QuerySet(BaseQuerySet):$/;" c +QuerySetManager mongoengine/mongoengine/queryset/manager.py /^class QuerySetManager(object):$/;" c +QuerySetNoCache mongoengine/mongoengine/queryset/queryset.py /^class QuerySetNoCache(BaseQuerySet):$/;" c +QuerySetNoDeRef mongoengine/mongoengine/queryset/queryset.py /^class QuerySetNoDeRef(QuerySet):$/;" c +QuerySetTest mongoengine/tests/queryset/queryset.py /^class QuerySetTest(unittest.TestCase):$/;" c +READ_PREF mongoengine/tests/test_replicaset_connection.py /^ READ_PREF = ReadPreference.SECONDARY$/;" v +READ_PREF mongoengine/tests/test_replicaset_connection.py /^ READ_PREF = ReadPreference.SECONDARY_ONLY$/;" v +READ_PREFERENCE mongoengine/mongoengine/connection.py /^ READ_PREFERENCE = False$/;" v +READ_PREFERENCE mongoengine/mongoengine/connection.py /^ READ_PREFERENCE = ReadPreference.PRIMARY$/;" v +RECURSIVE_REFERENCE_CONSTANT mongoengine/fields.py /^RECURSIVE_REFERENCE_CONSTANT = 'self'$/;" v +RECURSIVE_REFERENCE_CONSTANT mongoengine/mongoengine/fields.py /^RECURSIVE_REFERENCE_CONSTANT = 'self'$/;" v +REPR_OUTPUT_SIZE mongoengine/mongoengine/queryset/queryset.py /^REPR_OUTPUT_SIZE = 20$/;" v +RE_TYPE mongoengine/mongoengine/queryset/base.py /^RE_TYPE = type(re.compile(''))$/;" v +Rank mongoengine/tests/document/indexes.py /^ class Rank(EmbeddedDocument):$/;" c function:IndexesTest.test_embedded_document_index_meta +Rank mongoengine/tests/document/instance.py /^ class Rank(EmbeddedDocument):$/;" c function:InstanceTest.test_db_embedded_doc_field_load +Recipient mongoengine/tests/document/instance.py /^ class Recipient(Document):$/;" c function:InstanceTest.test_save +Record mongoengine/tests/document/instance.py /^ class Record(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_pull +RecursiveDocument mongoengine/tests/document/indexes.py /^ class RecursiveDocument(Document):$/;" c function:IndexesTest.test_recursive_embedded_objects_dont_break_indexes +RecursiveObject mongoengine/tests/document/indexes.py /^ class RecursiveObject(EmbeddedDocument):$/;" c function:IndexesTest.test_recursive_embedded_objects_dont_break_indexes +ReferenceField mongoengine/fields.py /^class ReferenceField(BaseField):$/;" c +ReferenceField mongoengine/mongoengine/fields.py /^class ReferenceField(BaseField):$/;" c +Relation mongoengine/tests/test_dereference.py /^ class Relation(EmbeddedDocument):$/;" c function:FieldTest.test_circular_reference +ReportDictField mongoengine/tests/document/indexes.py /^ class ReportDictField(Document):$/;" c function:IndexesTest.test_compound_key_dictfield +ReportEmbedded mongoengine/tests/document/indexes.py /^ class ReportEmbedded(Document):$/;" c function:IndexesTest.test_compound_key_embedded +Road mongoengine/tests/queryset/geo.py /^ class Road(Document):$/;" c function:GeoQueriesTest.test_linestring +Road mongoengine/tests/queryset/geo.py /^ class Road(Document):$/;" c function:GeoQueriesTest.test_polygon +Room mongoengine/tests/test_dereference.py /^ class Room(Document):$/;" c function:FieldTest.test_dict_in_dbref_instance +SPHINXBUILD mongoengine/docs/Makefile /^SPHINXBUILD = sphinx-build$/;" m +SPHINXOPTS mongoengine/docs/Makefile /^SPHINXOPTS =$/;" m +STRICT mongoengine/mongoengine/base/document.py /^ STRICT = False$/;" v class:BaseDocument +STRING_OPERATORS mongoengine/mongoengine/queryset/transform.py /^STRING_OPERATORS = ('contains', 'icontains', 'startswith',$/;" v +SaveConditionError mongoengine/mongoengine/errors.py /^class SaveConditionError(OperationError):$/;" c +SchemeLink mongoengine/tests/fields/fields.py /^ class SchemeLink(Document):$/;" c function:FieldTest.test_url_scheme_validation +SchemeLink tests/fields/fields.py /^ class SchemeLink(Document):$/;" c function:FieldTest.test_url_scheme_validation +Scores mongoengine/tests/queryset/queryset.py /^ class Scores(Document):$/;" c function:QuerySetTest.test_update_min_max +ScottishCat mongoengine/tests/queryset/queryset.py /^ class ScottishCat(Cat):$/;" c function:QuerySetTest.test_subclass_field_query +SequenceField mongoengine/fields.py /^class SequenceField(BaseField):$/;" c +SequenceField mongoengine/mongoengine/fields.py /^class SequenceField(BaseField):$/;" c +SetFile mongoengine/tests/fields/file_tests.py /^ class SetFile(Document):$/;" c function:FileTest.test_file_fields_set +SettingBase mongoengine/tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_complex_mapfield +SettingBase mongoengine/tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_dictfield_complex +SettingBase mongoengine/tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_list_field_complex +SettingBase tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_complex_mapfield +SettingBase tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_dictfield_complex +SettingBase tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_list_field_complex +SettingValue mongoengine/tests/queryset/queryset.py /^ class SettingValue(Document):$/;" c function:QuerySetTest.test_scalar_primary_key +Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_allow_using_sets_as_choices +Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_get_field_display +Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_accept_possible_value +Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_allow_no_value +Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_reject_unknown_value +Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_get_field_display +Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_validation +Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_validation_invalid_value +Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_allow_using_sets_as_choices +Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_get_field_display +Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_accept_possible_value +Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_allow_no_value +Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_reject_unknown_value +Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_get_field_display +Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_validation +Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_validation_invalid_value +Sibling mongoengine/tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_abstract_reference_base_type +Sibling mongoengine/tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_reference_abstract_class +Sibling mongoengine/tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_reference_class_with_abstract_parent +Sibling tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_abstract_reference_base_type +Sibling tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_reference_abstract_class +Sibling tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_reference_class_with_abstract_parent +SignalTests mongoengine/tests/test_signals.py /^class SignalTests(unittest.TestCase):$/;" c +Simple mongoengine/tests/document/instance.py /^ class Simple(Document):$/;" c function:InstanceTest.test_can_save_if_not_included +Simple mongoengine/tests/document/json_serialisation.py /^ class Simple(Document):$/;" c function:TestJson.test_json_complex +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_atomic_update_dict_field +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_complex_field_required +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_complex_field_same_value_not_changed +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_del_slice_marks_field_as_changed +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_dictfield_complex +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_dictfield_strict +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_complex +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_rejects_strings +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_strict +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_with_negative_indices +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_mapfield +Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_slice_marks_field_as_changed +Simple mongoengine/tests/queryset/queryset.py /^ class Simple(Document):$/;" c function:QuerySetTest.test_json_complex +Simple mongoengine/tests/queryset/queryset.py /^ class Simple(Document):$/;" c function:QuerySetTest.test_update_using_positional_operator_matches_first +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_atomic_update_dict_field +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_complex_field_required +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_complex_field_same_value_not_changed +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_del_slice_marks_field_as_changed +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_dictfield_complex +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_dictfield_strict +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_complex +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_rejects_strings +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_strict +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_with_negative_indices +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_mapfield +Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_slice_marks_field_as_changed +SimpleList mongoengine/tests/test_dereference.py /^ class SimpleList(Document):$/;" c function:FieldTest.test_list_of_lists_of_references +SimplificationVisitor mongoengine/mongoengine/queryset/visitor.py /^class SimplificationVisitor(QNodeVisitor):$/;" c +Sister mongoengine/tests/fields/fields.py /^ class Sister(Sibling):$/;" c function:FieldTest.test_reference_abstract_class +Sister mongoengine/tests/fields/fields.py /^ class Sister(Sibling):$/;" c function:FieldTest.test_reference_class_with_abstract_parent +Sister tests/fields/fields.py /^ class Sister(Sibling):$/;" c function:FieldTest.test_reference_abstract_class +Sister tests/fields/fields.py /^ class Sister(Sibling):$/;" c function:FieldTest.test_reference_class_with_abstract_parent +Site mongoengine/tests/document/instance.py /^ class Site(Document):$/;" c function:InstanceTest.test_embedded_update +Site mongoengine/tests/document/instance.py /^ class Site(Document):$/;" c function:InstanceTest.test_embedded_update_after_save +Site mongoengine/tests/document/instance.py /^ class Site(Document):$/;" c function:InstanceTest.test_embedded_update_db_field +Site mongoengine/tests/queryset/queryset.py /^ class Site(Document):$/;" c function:QuerySetTest.test_pull_from_nested_embedded +Site mongoengine/tests/queryset/queryset.py /^ class Site(Document):$/;" c function:QuerySetTest.test_pull_from_nested_mapfield +Site mongoengine/tests/queryset/queryset.py /^ class Site(Document):$/;" c function:QuerySetTest.test_pull_nested +Size mongoengine/tests/queryset/queryset.py /^ class Size(Document):$/;" c function:QuerySetTest.test_can_have_field_same_name_as_query_operator +SocialData mongoengine/tests/fields/fields.py /^ class SocialData(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference +SocialData tests/fields/fields.py /^ class SocialData(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference +SocialTest mongoengine/tests/fields/fields.py /^ class SocialTest(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_decimal +SocialTest tests/fields/fields.py /^ class SocialTest(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_decimal +Song mongoengine/tests/test_dereference.py /^ class Song(Document):$/;" c function:FieldTest.test_select_related_follows_embedded_referencefields +SortedListField mongoengine/fields.py /^class SortedListField(ListField):$/;" c +SortedListField mongoengine/mongoengine/fields.py /^class SortedListField(ListField):$/;" c +SpecialComment mongoengine/tests/document/inheritance.py /^ class SpecialComment(Comment):$/;" c class:InheritanceTest.test_allow_inheritance_embedded_document.Comment +SpecificStrictDict mongoengine/mongoengine/base/datastructures.py /^ class SpecificStrictDict(cls):$/;" c function:StrictDict.create +State mongoengine/tests/queryset/queryset.py /^ class State(Document):$/;" c function:QuerySetTest.test_scalar_generic_reference_field +State mongoengine/tests/queryset/queryset.py /^ class State(Document):$/;" c function:QuerySetTest.test_scalar_reference_field +Stats mongoengine/tests/document/instance.py /^ class Stats(Document):$/;" c function:InstanceTest.test_reference_inheritance +StreamFile mongoengine/tests/fields/file_tests.py /^ class StreamFile(Document):$/;" c function:FileTest.test_file_fields_stream +StreamFile mongoengine/tests/fields/file_tests.py /^ class StreamFile(Document):$/;" c function:FileTest.test_file_fields_stream_after_none +StrictDict mongoengine/mongoengine/base/datastructures.py /^class StrictDict(object):$/;" c +StringField mongoengine/fields.py /^class StringField(BaseField):$/;" c +StringField mongoengine/mongoengine/fields.py /^class StringField(BaseField):$/;" c +StringIO mongoengine/mongoengine/python_support.py /^ StringIO = cStringIO.StringIO$/;" v +StringIO mongoengine/mongoengine/python_support.py /^StringIO = six.BytesIO$/;" v +StringSetting mongoengine/tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_complex_mapfield +StringSetting mongoengine/tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_dictfield_complex +StringSetting mongoengine/tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_list_field_complex +StringSetting tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_complex_mapfield +StringSetting tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_dictfield_complex +StringSetting tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_list_field_complex +SubAnimal mongoengine/tests/fields/fields.py /^ class SubAnimal(Animal):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set +SubAnimal mongoengine/tests/fields/fields.py /^ class SubAnimal(Animal):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set +SubAnimal tests/fields/fields.py /^ class SubAnimal(Animal):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set +SubAnimal tests/fields/fields.py /^ class SubAnimal(Animal):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set +SubDoc mongoengine/tests/document/instance.py /^ class SubDoc(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_to_mongo_id +SubDoc mongoengine/tests/document/validation.py /^ class SubDoc(EmbeddedDocument):$/;" c function:ValidatorErrorTest.test_embedded_db_field_validate +SubDoc mongoengine/tests/document/validation.py /^ class SubDoc(EmbeddedDocument):$/;" c function:ValidatorErrorTest.test_embedded_weakref +SubDoc mongoengine/tests/queryset/queryset.py /^ class SubDoc(EmbeddedDocument):$/;" c function:QuerySetTest.test_reload_embedded_docs_instance +SubDoc mongoengine/tests/queryset/queryset.py /^ class SubDoc(EmbeddedDocument):$/;" c function:QuerySetTest.test_reload_list_embedded_docs_instance +SubDocument mongoengine/tests/document/indexes.py /^ class SubDocument(EmbeddedDocument):$/;" c function:IndexesTest.test_unique_embedded_document +SubDocument mongoengine/tests/document/indexes.py /^ class SubDocument(EmbeddedDocument):$/;" c function:IndexesTest.test_unique_embedded_document_in_list +SubDocument mongoengine/tests/document/indexes.py /^ class SubDocument(EmbeddedDocument):$/;" c function:IndexesTest.test_unique_with_embedded_document_and_embedded_unique +SuperPhylum mongoengine/tests/document/instance.py /^ class SuperPhylum(EmbeddedDocument):$/;" c function:InstanceTest.test_reload_sharded_nested +TEST_IMAGE2_PATH mongoengine/tests/fields/file_tests.py /^TEST_IMAGE2_PATH = os.path.join(os.path.dirname(__file__), 'mongodb_leaf.png')$/;" v +TEST_IMAGE_PATH mongoengine/tests/document/instance.py /^TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__),$/;" v +TEST_IMAGE_PATH mongoengine/tests/fields/file_tests.py /^TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__), 'mongoengine.png')$/;" v +TPS mongoengine/tests/fields/fields.py /^ TPS = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +TPS tests/fields/fields.py /^ TPS = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +TYPES mongoengine/tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person +TYPES mongoengine/tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone +TYPES mongoengine/tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person +TYPES tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person +TYPES tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone +TYPES tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person +Tag mongoengine/tests/document/indexes.py /^ class Tag(EmbeddedDocument):$/;" c function:IndexesTest.test_list_embedded_document_index +Tag mongoengine/tests/test_dereference.py /^ class Tag(Document):$/;" c function:FieldTest.test_dereferencing_embedded_listfield_referencefield +Test mongoengine/tests/document/indexes.py /^ class Test(Document):$/;" c function:IndexesTest.test_covered_index +Test mongoengine/tests/document/instance.py /^ class Test(Document):$/;" c function:InstanceTest.test_dbref_equality +Test mongoengine/tests/document/instance.py /^ class Test(Document):$/;" c function:InstanceTest.test_embedded_document_equality +Test mongoengine/tests/fields/fields.py /^ class Test(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields_on_embedded_documents +Test mongoengine/tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_embedded_db_field +Test mongoengine/tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_embedded_mapfield_db_field +Test mongoengine/tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_mapfield_numerical_index +Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_cursor_in_an_if_stmt +Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_dict_with_custom_baseclass +Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_item_frequencies_normalize +Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_item_frequencies_with_0_values +Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_item_frequencies_with_False_values +Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_upsert_includes_cls +Test mongoengine/tests/queryset/visitor.py /^ class Test(Document):$/;" c function:QTest.test_multiple_occurence_in_field +Test tests/fields/fields.py /^ class Test(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields_on_embedded_documents +Test tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_embedded_db_field +Test tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_embedded_mapfield_db_field +Test tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_mapfield_numerical_index +Test2 mongoengine/tests/document/instance.py /^ class Test2(Document):$/;" c function:InstanceTest.test_dbref_equality +Test3 mongoengine/tests/document/instance.py /^ class Test3(Document):$/;" c function:InstanceTest.test_dbref_equality +TestActivity mongoengine/tests/queryset/queryset.py /^ class TestActivity(Document):$/;" c function:QuerySetTest.test_generic_reference_field_with_only_and_as_pymongo +TestChildDoc mongoengine/tests/document/indexes.py /^ class TestChildDoc(TestDoc):$/;" c function:IndexesTest.test_index_dont_send_cls_option +TestDoc mongoengine/tests/document/indexes.py /^ class TestDoc(Document):$/;" c function:IndexesTest.test_compound_index_underscore_cls_not_overwritten +TestDoc mongoengine/tests/document/indexes.py /^ class TestDoc(Document):$/;" c function:IndexesTest.test_index_dont_send_cls_option +TestDoc mongoengine/tests/document/instance.py /^ class TestDoc(Document, DoubleMixIn):$/;" c function:InstanceTest.test_mixin_inheritance +TestDoc mongoengine/tests/fields/fields.py /^ class TestDoc(Document):$/;" c function:FieldTest.test_tuples_as_tuples +TestDoc mongoengine/tests/queryset/queryset.py /^ class TestDoc(Document):$/;" c function:QuerySetTest.test_scalar_db_field +TestDoc mongoengine/tests/queryset/queryset.py /^ class TestDoc(Document):$/;" c function:QuerySetTest.test_scalar_simple +TestDoc mongoengine/tests/queryset/visitor.py /^ class TestDoc(Document):$/;" c function:QTest.test_and_combination +TestDoc mongoengine/tests/queryset/visitor.py /^ class TestDoc(Document):$/;" c function:QTest.test_and_or_combination +TestDoc mongoengine/tests/queryset/visitor.py /^ class TestDoc(Document):$/;" c function:QTest.test_or_and_or_combination +TestDoc mongoengine/tests/queryset/visitor.py /^ class TestDoc(Document):$/;" c function:QTest.test_or_combination +TestDoc mongoengine/tests/queryset/visitor.py /^ class TestDoc(Document):$/;" c function:QTest.test_q_clone +TestDoc tests/fields/fields.py /^ class TestDoc(Document):$/;" c function:FieldTest.test_tuples_as_tuples +TestDocument mongoengine/tests/document/instance.py /^ class TestDocument(Document):$/;" c function:InstanceTest.test_document_clean +TestDocument mongoengine/tests/document/instance.py /^ class TestDocument(Document):$/;" c function:InstanceTest.test_document_embedded_clean +TestDocument mongoengine/tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_int_and_float_ne_operator +TestDocument mongoengine/tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_long_ne_operator +TestDocument mongoengine/tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_long_validation +TestDocument tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_int_and_float_ne_operator +TestDocument tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_long_ne_operator +TestDocument tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_long_validation +TestEmbeddedDocument mongoengine/tests/document/instance.py /^ class TestEmbeddedDocument(EmbeddedDocument):$/;" c function:InstanceTest.test_document_embedded_clean +TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_copyable +TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_boolean +TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_cmp +TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_disk_space +TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_multidb +TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_reassigning +TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_uniqueness +TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_image_field_reassigning +TestImage mongoengine/tests/fields/file_tests.py /^ class TestImage(Document):$/;" c function:FileTest.test_get_image_by_grid_id +TestImage mongoengine/tests/fields/file_tests.py /^ class TestImage(Document):$/;" c function:FileTest.test_image_field +TestImage mongoengine/tests/fields/file_tests.py /^ class TestImage(Document):$/;" c function:FileTest.test_image_field_resize +TestImage mongoengine/tests/fields/file_tests.py /^ class TestImage(Document):$/;" c function:FileTest.test_image_field_resize_force +TestImage mongoengine/tests/fields/file_tests.py /^ class TestImage(Document):$/;" c function:FileTest.test_image_field_thumbnail +TestJson mongoengine/tests/document/json_serialisation.py /^class TestJson(unittest.TestCase):$/;" c +TestLongFieldConsideredAsInt64 mongoengine/tests/fields/fields.py /^ class TestLongFieldConsideredAsInt64(Document):$/;" c function:FieldTest.test_long_field_is_considered_as_int64 +TestLongFieldConsideredAsInt64 tests/fields/fields.py /^ class TestLongFieldConsideredAsInt64(Document):$/;" c function:FieldTest.test_long_field_is_considered_as_int64 +TestOrganization mongoengine/tests/queryset/queryset.py /^ class TestOrganization(Document):$/;" c function:QuerySetTest.test_update_related_models +TestPerson mongoengine/tests/queryset/queryset.py /^ class TestPerson(Document):$/;" c function:QuerySetTest.test_update_related_models +TestPerson mongoengine/tests/queryset/queryset.py /^ class TestPerson(Document):$/;" c function:QuerySetTest.test_generic_reference_field_with_only_and_as_pymongo +TestQuerysetPickable mongoengine/tests/queryset/pickable.py /^class TestQuerysetPickable(unittest.TestCase):$/;" c +TestStrictDict mongoengine/tests/test_datastructures.py /^class TestStrictDict(unittest.TestCase):$/;" c +TextPost mongoengine/docs/code/tumblelog.py /^class TextPost(Post):$/;" c +Thing mongoengine/tests/document/instance.py /^ class Thing(EmbeddedDocument):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document +Thing mongoengine/tests/document/instance.py /^ class Thing(EmbeddedDocument):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false +Thing mongoengine/tests/document/instance.py /^ class Thing(EmbeddedDocument):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc +Thing mongoengine/tests/document/instance.py /^ class Thing(EmbeddedDocument):$/;" c function:InstanceTest.test_save_to_a_value_that_equates_to_false +ToEmbed mongoengine/tests/fields/fields.py /^ class ToEmbed(Document):$/;" c function:FieldTest.test_dictfield_dump_document +ToEmbed mongoengine/tests/fields/fields.py /^ class ToEmbed(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document +ToEmbed tests/fields/fields.py /^ class ToEmbed(Document):$/;" c function:FieldTest.test_dictfield_dump_document +ToEmbed tests/fields/fields.py /^ class ToEmbed(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document +ToEmbedChild mongoengine/tests/fields/fields.py /^ class ToEmbedChild(ToEmbedParent):$/;" c function:FieldTest.test_dictfield_dump_document +ToEmbedChild mongoengine/tests/fields/fields.py /^ class ToEmbedChild(ToEmbedParent):$/;" c function:FieldTest.test_dynamicfield_dump_document +ToEmbedChild tests/fields/fields.py /^ class ToEmbedChild(ToEmbedParent):$/;" c function:FieldTest.test_dictfield_dump_document +ToEmbedChild tests/fields/fields.py /^ class ToEmbedChild(ToEmbedParent):$/;" c function:FieldTest.test_dynamicfield_dump_document +ToEmbedParent mongoengine/tests/fields/fields.py /^ class ToEmbedParent(Document):$/;" c function:FieldTest.test_dictfield_dump_document +ToEmbedParent mongoengine/tests/fields/fields.py /^ class ToEmbedParent(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document +ToEmbedParent tests/fields/fields.py /^ class ToEmbedParent(Document):$/;" c function:FieldTest.test_dictfield_dump_document +ToEmbedParent tests/fields/fields.py /^ class ToEmbedParent(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document +TopLevelDocumentMetaclass mongoengine/mongoengine/base/metaclasses.py /^class TopLevelDocumentMetaclass(DocumentMetaclass):$/;" c +Topic mongoengine/tests/test_dereference.py /^ class Topic(Document):$/;" c function:FieldTest.test_document_reload_reference_integrity +TransformTest mongoengine/tests/queryset/transform.py /^class TransformTest(unittest.TestCase):$/;" c +Tree mongoengine/tests/fields/fields.py /^ class Tree(Document):$/;" c function:FieldTest.test_recursive_embedding +Tree tests/fields/fields.py /^ class Tree(Document):$/;" c function:FieldTest.test_recursive_embedding +TreeNode mongoengine/tests/fields/fields.py /^ class TreeNode(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_embedding +TreeNode tests/fields/fields.py /^ class TreeNode(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_embedding +UInfoDocument mongoengine/tests/document/delta.py /^ class UInfoDocument(Document):$/;" c function:DeltaTest.test_delta_for_nested_map_fields +UPDATE_OPERATORS mongoengine/mongoengine/base/common.py /^UPDATE_OPERATORS = set(['set', 'unset', 'inc', 'dec', 'pop', 'push',$/;" v +URLField mongoengine/fields.py /^class URLField(StringField):$/;" c +URLField mongoengine/mongoengine/fields.py /^class URLField(StringField):$/;" c +USER_REGEX mongoengine/fields.py /^ USER_REGEX = re.compile($/;" v class:EmailField +USER_REGEX mongoengine/mongoengine/fields.py /^ USER_REGEX = re.compile($/;" v class:EmailField +UTF8_USER_REGEX mongoengine/fields.py /^ UTF8_USER_REGEX = re.compile($/;" v class:EmailField +UTF8_USER_REGEX mongoengine/mongoengine/fields.py /^ UTF8_USER_REGEX = re.compile($/;" v class:EmailField +UUID mongoengine/tests/document/instance.py /^ def UUID(i):$/;" f function:InstanceTest.test_save_atomicity_condition +UUIDField mongoengine/fields.py /^class UUIDField(BaseField):$/;" c +UUIDField mongoengine/mongoengine/fields.py /^class UUIDField(BaseField):$/;" c +User mongoengine/docs/code/tumblelog.py /^class User(Document):$/;" c +User mongoengine/tests/document/delta.py /^ class User(Document):$/;" c function:DeltaTest.test_referenced_object_changed_attributes +User mongoengine/tests/document/indexes.py /^ class User(Document):$/;" c function:IndexesTest.test_disable_index_creation +User mongoengine/tests/document/indexes.py /^ class User(Document):$/;" c function:IndexesTest.test_unique_and_primary +User mongoengine/tests/document/indexes.py /^ class User(Document):$/;" c function:IndexesTest.test_unique_and_primary_create +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_custom_id_field +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_db_alias_tests +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_db_ref_usage +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_document_hash +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_list_search_by_embedded +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_load_undefined_fields +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_load_undefined_fields_with_strict_false +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_null_field +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_query_count_when_saving +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_with_custom_id_field +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_with_shared_id_among_collections +User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_save_to_a_value_that_equates_to_false +User mongoengine/tests/document/instance.py /^ class User(self.Person):$/;" c function:InstanceTest.test_save_only_changed_fields +User mongoengine/tests/document/instance.py /^ class User(self.Person):$/;" c function:InstanceTest.test_save_only_changed_fields_recursive +User mongoengine/tests/document/validation.py /^ class User(Document):$/;" c function:ValidatorErrorTest.test_model_validation +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_db_field_validation +User mongoengine/tests/fields/fields.py /^ class User(Basedoc):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_domain_whitelist +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_honors_regex +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_ip_domain +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_unicode_user +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_document_not_registered +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list_choices +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list_item_modification +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_list_validation +User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_reference_validation +User mongoengine/tests/fields/fields.py /^ class User(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_inheritance +User mongoengine/tests/queryset/field_list.py /^ class User(Base):$/;" c function:OnlyExcludeAllTest.test_exclude_from_subclasses_docs +User mongoengine/tests/queryset/field_list.py /^ class User(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_exclude +User mongoengine/tests/queryset/field_list.py /^ class User(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_only_with_subfields +User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_as_pymongo +User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_as_pymongo_json_limit_fields +User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_cache_not_cloned +User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_comment +User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_in_operator_on_non_iterable +User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_nested_queryset_iterator +User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_no_dereference +User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_no_dereference_embedded_doc +User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_scalar +User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_set_generic_embedded_documents +User mongoengine/tests/queryset/queryset.py /^ class User(EmbeddedDocument):$/;" c function:QuerySetTest.test_find_embedded +User mongoengine/tests/queryset/queryset.py /^ class User(EmbeddedDocument):$/;" c function:QuerySetTest.test_find_empty_embedded +User mongoengine/tests/queryset/queryset.py /^ class User(EmbeddedDocument):$/;" c function:QuerySetTest.test_pull_from_nested_embedded +User mongoengine/tests/queryset/visitor.py /^ class User(Document):$/;" c function:QTest.test_q_merge_queries_edge_case +User mongoengine/tests/queryset/visitor.py /^ class User(Document):$/;" c function:QTest.test_q_with_dbref +User mongoengine/tests/test_context_managers.py /^ class User(Document):$/;" c function:ContextManagersTest.test_no_dereference_context_manager_dbref +User mongoengine/tests/test_context_managers.py /^ class User(Document):$/;" c function:ContextManagersTest.test_no_dereference_context_manager_object_id +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_document_reload_reference_integrity +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_handle_old_style_references +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false_stores_as_type +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_of_lists_of_references +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_map_field_reference +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_migrate_references +User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_objectid_reference_across_databases +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_db_field_validation +User tests/fields/fields.py /^ class User(Basedoc):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_domain_whitelist +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_honors_regex +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_ip_domain +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_unicode_user +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_document_not_registered +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list_choices +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list_item_modification +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_list_validation +User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_reference_validation +User tests/fields/fields.py /^ class User(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_inheritance +UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_dict_field +UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_dict_field_no_field_inheritance +UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_generic_reference +UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_generic_reference_map_field +UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries +UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_list_field_complex +UserB mongoengine/tests/test_dereference.py /^ class UserB(Document):$/;" c function:FieldTest.test_dict_field +UserB mongoengine/tests/test_dereference.py /^ class UserB(Document):$/;" c function:FieldTest.test_generic_reference +UserB mongoengine/tests/test_dereference.py /^ class UserB(Document):$/;" c function:FieldTest.test_generic_reference_map_field +UserB mongoengine/tests/test_dereference.py /^ class UserB(Document):$/;" c function:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries +UserB mongoengine/tests/test_dereference.py /^ class UserB(Document):$/;" c function:FieldTest.test_list_field_complex +UserBase mongoengine/tests/document/indexes.py /^ class UserBase(Document):$/;" c function:IndexesTest.test_abstract_index_inheritance +UserC mongoengine/tests/test_dereference.py /^ class UserC(Document):$/;" c function:FieldTest.test_dict_field +UserC mongoengine/tests/test_dereference.py /^ class UserC(Document):$/;" c function:FieldTest.test_generic_reference +UserC mongoengine/tests/test_dereference.py /^ class UserC(Document):$/;" c function:FieldTest.test_generic_reference_map_field +UserC mongoengine/tests/test_dereference.py /^ class UserC(Document):$/;" c function:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries +UserC mongoengine/tests/test_dereference.py /^ class UserC(Document):$/;" c function:FieldTest.test_list_field_complex +UserComments mongoengine/tests/fields/fields.py /^ class UserComments(Comments):$/;" c function:FieldTest.test_choices_validation_documents_inheritance +UserComments mongoengine/tests/fields/fields.py /^ class UserComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents +UserComments mongoengine/tests/fields/fields.py /^ class UserComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_invalid +UserComments tests/fields/fields.py /^ class UserComments(Comments):$/;" c function:FieldTest.test_choices_validation_documents_inheritance +UserComments tests/fields/fields.py /^ class UserComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents +UserComments tests/fields/fields.py /^ class UserComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_invalid +UserDoc mongoengine/tests/queryset/queryset.py /^ class UserDoc(Document):$/;" c function:QuerySetTest.test_scalar_simple +UserSubscription mongoengine/tests/document/instance.py /^ class UserSubscription(Document):$/;" c function:InstanceTest.test_query_count_when_saving +UserVisit mongoengine/tests/queryset/queryset.py /^ class UserVisit(Document):$/;" c function:QuerySetTest.test_average_over_db_field +UserVisit mongoengine/tests/queryset/queryset.py /^ class UserVisit(Document):$/;" c function:QuerySetTest.test_sum_over_db_field +VALUE_DECORATOR mongoengine/fields.py /^ VALUE_DECORATOR = int$/;" v class:SequenceField +VALUE_DECORATOR mongoengine/mongoengine/fields.py /^ VALUE_DECORATOR = int$/;" v class:SequenceField +VERSION mongoengine/mongoengine/__init__.py /^VERSION = (0, 15, 0)$/;" v +VERSION mongoengine/setup.py /^VERSION = get_version(eval(version_line.split('=')[-1]))$/;" v +Vaccine mongoengine/tests/document/class_methods.py /^ class Vaccine(Document):$/;" c function:ClassMethodsTest.test_register_delete_rule_inherited +ValidationError mongoengine/mongoengine/errors.py /^class ValidationError(AssertionError):$/;" c +ValidatorErrorTest mongoengine/tests/document/validation.py /^class ValidatorErrorTest(unittest.TestCase):$/;" c +VariousData mongoengine/tests/queryset/field_list.py /^ class VariousData(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_only_with_subfields +Vegetal mongoengine/tests/fields/fields.py /^ class Vegetal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices +Vegetal tests/fields/fields.py /^ class Vegetal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices +Venue mongoengine/tests/fields/geo.py /^ class Venue(EmbeddedDocument):$/;" c function:GeoFieldTest.test_geopoint_embedded_indexes +Venue mongoengine/tests/fields/geo.py /^ class Venue(EmbeddedDocument):$/;" c function:GeoFieldTest.test_indexes_2dsphere_embedded +Venue mongoengine/tests/queryset/geo.py /^ class Venue(EmbeddedDocument):$/;" c function:GeoQueriesTest._test_embedded +Vote mongoengine/tests/queryset/queryset.py /^ class Vote(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_using_positional_operator_embedded_document +Widget mongoengine/tests/document/instance.py /^ class Widget(Document):$/;" c function:InstanceTest.test_save_atomicity_condition +Word mongoengine/tests/document/instance.py /^ class Word(Document):$/;" c function:InstanceTest.test_invalid_son +Writer mongoengine/tests/document/instance.py /^ class Writer(self.Person):$/;" c function:InstanceTest.test_reverse_delete_rule_with_document_inheritance +Zoo mongoengine/tests/document/instance.py /^ class Zoo(Document):$/;" c function:InstanceTest.test_polymorphic_references +_FakeSignal mongoengine/mongoengine/signals.py /^ class _FakeSignal(object):$/;" c +_URL_REGEX mongoengine/fields.py /^ _URL_REGEX = re.compile($/;" v class:URLField +_URL_REGEX mongoengine/mongoengine/fields.py /^ _URL_REGEX = re.compile($/;" v class:URLField +_URL_SCHEMES mongoengine/fields.py /^ _URL_SCHEMES = ['http', 'https', 'ftp', 'ftps']$/;" v class:URLField +_URL_SCHEMES mongoengine/mongoengine/fields.py /^ _URL_SCHEMES = ['http', 'https', 'ftp', 'ftps']$/;" v class:URLField +__add__ mongoengine/mongoengine/queryset/field_list.py /^ def __add__(self, f):$/;" m class:QueryFieldList file: +__all__ mongoengine/fields.py /^__all__ = ($/;" v +__all__ mongoengine/mongoengine/__init__.py /^__all__ = (list(document.__all__) + list(fields.__all__) +$/;" v +__all__ mongoengine/mongoengine/base/__init__.py /^__all__ = ($/;" v +__all__ mongoengine/mongoengine/base/common.py /^__all__ = ('UPDATE_OPERATORS', 'get_document', '_document_registry')$/;" v +__all__ mongoengine/mongoengine/base/datastructures.py /^__all__ = ('BaseDict', 'BaseList', 'EmbeddedDocumentList', 'LazyReference')$/;" v +__all__ mongoengine/mongoengine/base/document.py /^__all__ = ('BaseDocument', 'NON_FIELD_ERRORS')$/;" v +__all__ mongoengine/mongoengine/base/fields.py /^__all__ = ('BaseField', 'ComplexBaseField', 'ObjectIdField',$/;" v +__all__ mongoengine/mongoengine/base/metaclasses.py /^__all__ = ('DocumentMetaclass', 'TopLevelDocumentMetaclass')$/;" v +__all__ mongoengine/mongoengine/connection.py /^__all__ = ['MongoEngineConnectionError', 'connect', 'register_connection',$/;" v +__all__ mongoengine/mongoengine/context_managers.py /^__all__ = ('switch_db', 'switch_collection', 'no_dereference',$/;" v +__all__ mongoengine/mongoengine/document.py /^__all__ = ('Document', 'EmbeddedDocument', 'DynamicDocument',$/;" v +__all__ mongoengine/mongoengine/errors.py /^__all__ = ('NotRegistered', 'InvalidDocumentError', 'LookUpError',$/;" v +__all__ mongoengine/mongoengine/fields.py /^__all__ = ($/;" v +__all__ mongoengine/mongoengine/queryset/__init__.py /^__all__ = ($/;" v +__all__ mongoengine/mongoengine/queryset/base.py /^__all__ = ('BaseQuerySet', 'DO_NOTHING', 'NULLIFY', 'CASCADE', 'DENY', 'PULL')$/;" v +__all__ mongoengine/mongoengine/queryset/field_list.py /^__all__ = ('QueryFieldList',)$/;" v +__all__ mongoengine/mongoengine/queryset/manager.py /^__all__ = ('queryset_manager', 'QuerySetManager')$/;" v +__all__ mongoengine/mongoengine/queryset/queryset.py /^__all__ = ('QuerySet', 'QuerySetNoCache', 'DO_NOTHING', 'NULLIFY', 'CASCADE',$/;" v +__all__ mongoengine/mongoengine/queryset/transform.py /^__all__ = ('query', 'update')$/;" v +__all__ mongoengine/mongoengine/queryset/visitor.py /^__all__ = ('Q',)$/;" v +__all__ mongoengine/mongoengine/signals.py /^__all__ = ('pre_init', 'post_init', 'pre_save', 'pre_save_post_validation',$/;" v +__all__ mongoengine/tests/all_warnings/__init__.py /^__all__ = ('AllWarnings', )$/;" v +__all__ mongoengine/tests/document/class_methods.py /^__all__ = ("ClassMethodsTest", )$/;" v +__all__ mongoengine/tests/document/delta.py /^__all__ = ("DeltaTest",)$/;" v +__all__ mongoengine/tests/document/dynamic.py /^__all__ = ("DynamicTest", )$/;" v +__all__ mongoengine/tests/document/indexes.py /^__all__ = ("IndexesTest", )$/;" v +__all__ mongoengine/tests/document/inheritance.py /^__all__ = ('InheritanceTest', )$/;" v +__all__ mongoengine/tests/document/instance.py /^__all__ = ("InstanceTest",)$/;" v +__all__ mongoengine/tests/document/json_serialisation.py /^__all__ = ("TestJson",)$/;" v +__all__ mongoengine/tests/document/validation.py /^__all__ = ("ValidatorErrorTest",)$/;" v +__all__ mongoengine/tests/fields/fields.py /^__all__ = ("FieldTest", "EmbeddedDocumentListFieldTestCase")$/;" v +__all__ mongoengine/tests/fields/geo.py /^__all__ = ("GeoFieldTest", )$/;" v +__all__ mongoengine/tests/queryset/field_list.py /^__all__ = ("QueryFieldListTest", "OnlyExcludeAllTest")$/;" v +__all__ mongoengine/tests/queryset/geo.py /^__all__ = ("GeoQueriesTest",)$/;" v +__all__ mongoengine/tests/queryset/modify.py /^__all__ = ("FindAndModifyTest",)$/;" v +__all__ mongoengine/tests/queryset/queryset.py /^__all__ = ("QuerySetTest",)$/;" v +__all__ mongoengine/tests/queryset/transform.py /^__all__ = ("TransformTest",)$/;" v +__all__ mongoengine/tests/queryset/visitor.py /^__all__ = ("QTest",)$/;" v +__all__ tests/fields/fields.py /^__all__ = ("FieldTest", "EmbeddedDocumentListFieldTestCase")$/;" v +__and__ mongoengine/mongoengine/queryset/visitor.py /^ def __and__(self, other):$/;" m class:QNode file: +__author__ mongoengine/tests/queryset/pickable.py /^__author__ = 'stas'$/;" v +__bool__ mongoengine/mongoengine/queryset/base.py /^ def __bool__(self):$/;" m class:BaseQuerySet file: +__call__ mongoengine/mongoengine/dereference.py /^ def __call__(self, items, max_depth=1, instance=None, name=None):$/;" m class:DeReference file: +__call__ mongoengine/mongoengine/queryset/base.py /^ def __call__(self, q_obj=None, class_check=True, read_preference=None,$/;" m class:BaseQuerySet file: +__contains__ mongoengine/mongoengine/base/datastructures.py /^ def __contains__(self, key):$/;" m class:StrictDict file: +__contains__ mongoengine/mongoengine/base/document.py /^ def __contains__(self, name):$/;" m class:BaseDocument file: +__copy__ mongoengine/fields.py /^ def __copy__(self):$/;" m class:GridFSProxy file: +__copy__ mongoengine/mongoengine/fields.py /^ def __copy__(self):$/;" m class:GridFSProxy file: +__deepcopy__ mongoengine/fields.py /^ def __deepcopy__(self, memo):$/;" m class:GridFSProxy file: +__deepcopy__ mongoengine/mongoengine/fields.py /^ def __deepcopy__(self, memo):$/;" m class:GridFSProxy file: +__deepcopy__ mongoengine/mongoengine/queryset/base.py /^ def __deepcopy__(self, memo):$/;" m class:BaseQuerySet file: +__delattr__ mongoengine/mongoengine/base/datastructures.py /^ def __delattr__(self, key, *args, **kwargs):$/;" m class:BaseDict file: +__delattr__ mongoengine/mongoengine/base/document.py /^ def __delattr__(self, *args, **kwargs):$/;" m class:BaseDocument file: +__delattr__ mongoengine/mongoengine/document.py /^ def __delattr__(self, *args, **kwargs):$/;" m class:DynamicDocument file: +__delattr__ mongoengine/mongoengine/document.py /^ def __delattr__(self, *args, **kwargs):$/;" m class:DynamicEmbeddedDocument file: +__delete__ mongoengine/mongoengine/base/datastructures.py /^ def __delete__(self, *args, **kwargs):$/;" m class:BaseDict file: +__delitem__ mongoengine/mongoengine/base/datastructures.py /^ def __delitem__(self, key, *args, **kwargs):$/;" m class:BaseDict file: +__delitem__ mongoengine/mongoengine/base/datastructures.py /^ def __delitem__(self, key, *args, **kwargs):$/;" m class:BaseList file: +__delslice__ mongoengine/mongoengine/base/datastructures.py /^ def __delslice__(self, *args, **kwargs):$/;" m class:BaseList file: +__dereference mongoengine/mongoengine/queryset/base.py /^ __dereference = False$/;" v class:BaseQuerySet +__dereference mongoengine/mongoengine/queryset/queryset.py /^ def __dereference(items, max_depth=1, instance=None, name=None):$/;" m class:QuerySetNoDeRef file: +__enter__ mongoengine/mongoengine/context_managers.py /^ def __enter__(self):$/;" m class:no_dereference file: +__enter__ mongoengine/mongoengine/context_managers.py /^ def __enter__(self):$/;" m class:no_sub_classes file: +__enter__ mongoengine/mongoengine/context_managers.py /^ def __enter__(self):$/;" m class:query_counter file: +__enter__ mongoengine/mongoengine/context_managers.py /^ def __enter__(self):$/;" m class:switch_collection file: +__enter__ mongoengine/mongoengine/context_managers.py /^ def __enter__(self):$/;" m class:switch_db file: +__eq__ mongoengine/fields.py /^ def __eq__(self, other):$/;" m class:GridFSProxy file: +__eq__ mongoengine/mongoengine/base/datastructures.py /^ def __eq__(self, other):$/;" m class:StrictDict file: +__eq__ mongoengine/mongoengine/base/document.py /^ def __eq__(self, other):$/;" m class:BaseDocument file: +__eq__ mongoengine/mongoengine/context_managers.py /^ def __eq__(self, value):$/;" m class:query_counter file: +__eq__ mongoengine/mongoengine/document.py /^ def __eq__(self, other):$/;" m class:EmbeddedDocument file: +__eq__ mongoengine/mongoengine/fields.py /^ def __eq__(self, other):$/;" m class:GridFSProxy file: +__eq__ mongoengine/tests/document/instance.py /^ def __eq__(self, other):$/;" m class:InstanceTest.test_kwargs_complex.Doc file: +__eq__ mongoengine/tests/document/instance.py /^ def __eq__(self, other):$/;" m class:InstanceTest.test_kwargs_simple.Doc file: +__eq__ mongoengine/tests/document/json_serialisation.py /^ def __eq__(self, other):$/;" m class:TestJson.test_json_complex.Doc file: +__eq__ mongoengine/tests/document/json_serialisation.py /^ def __eq__(self, other):$/;" m class:TestJson.test_json_simple.Doc file: +__exit__ mongoengine/mongoengine/context_managers.py /^ def __exit__(self, t, value, traceback):$/;" m class:no_dereference file: +__exit__ mongoengine/mongoengine/context_managers.py /^ def __exit__(self, t, value, traceback):$/;" m class:no_sub_classes file: +__exit__ mongoengine/mongoengine/context_managers.py /^ def __exit__(self, t, value, traceback):$/;" m class:query_counter file: +__exit__ mongoengine/mongoengine/context_managers.py /^ def __exit__(self, t, value, traceback):$/;" m class:switch_collection file: +__exit__ mongoengine/mongoengine/context_managers.py /^ def __exit__(self, t, value, traceback):$/;" m class:switch_db file: +__expand_dynamic_values mongoengine/mongoengine/base/document.py /^ def __expand_dynamic_values(self, name, value):$/;" m class:BaseDocument file: +__ge__ mongoengine/mongoengine/context_managers.py /^ def __ge__(self, value):$/;" m class:query_counter file: +__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:CachedReferenceField file: +__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ComplexDateTimeField file: +__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:FileField file: +__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:GenericLazyReferenceField file: +__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:GenericReferenceField file: +__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:LazyReferenceField file: +__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ListField file: +__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ReferenceField file: +__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:SequenceField file: +__get__ mongoengine/fields.py /^ def __get__(self, instance, value):$/;" m class:GridFSProxy file: +__get__ mongoengine/mongoengine/base/fields.py /^ def __get__(self, instance, owner):$/;" m class:BaseField file: +__get__ mongoengine/mongoengine/base/fields.py /^ def __get__(self, instance, owner):$/;" m class:ComplexBaseField file: +__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:CachedReferenceField file: +__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ComplexDateTimeField file: +__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:FileField file: +__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:GenericLazyReferenceField file: +__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:GenericReferenceField file: +__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:LazyReferenceField file: +__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ListField file: +__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ReferenceField file: +__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:SequenceField file: +__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, value):$/;" m class:GridFSProxy file: +__get__ mongoengine/mongoengine/queryset/manager.py /^ def __get__(self, instance, owner):$/;" m class:QuerySetManager file: +__get_bases mongoengine/mongoengine/base/metaclasses.py /^ def __get_bases(cls, bases):$/;" m class:DocumentMetaclass file: +__get_field_display mongoengine/mongoengine/base/document.py /^ def __get_field_display(self, field):$/;" m class:BaseDocument file: +__getattr__ mongoengine/fields.py /^ def __getattr__(self, name):$/;" m class:GridFSProxy file: +__getattr__ mongoengine/mongoengine/base/datastructures.py /^ def __getattr__(self, name):$/;" m class:LazyReference file: +__getattr__ mongoengine/mongoengine/fields.py /^ def __getattr__(self, name):$/;" m class:GridFSProxy file: +__getattribute__ mongoengine/mongoengine/errors.py /^ def __getattribute__(self, name):$/;" m class:ValidationError file: +__getitem__ mongoengine/mongoengine/base/datastructures.py /^ def __getitem__(self, key):$/;" m class:StrictDict file: +__getitem__ mongoengine/mongoengine/base/datastructures.py /^ def __getitem__(self, key, *args, **kwargs):$/;" m class:BaseDict file: +__getitem__ mongoengine/mongoengine/base/datastructures.py /^ def __getitem__(self, key, *args, **kwargs):$/;" m class:BaseList file: +__getitem__ mongoengine/mongoengine/base/datastructures.py /^ def __getitem__(self, name):$/;" m class:LazyReference file: +__getitem__ mongoengine/mongoengine/base/document.py /^ def __getitem__(self, name):$/;" m class:BaseDocument file: +__getitem__ mongoengine/mongoengine/queryset/base.py /^ def __getitem__(self, key):$/;" m class:BaseQuerySet file: +__getstate__ mongoengine/fields.py /^ def __getstate__(self):$/;" m class:GridFSProxy file: +__getstate__ mongoengine/mongoengine/base/datastructures.py /^ def __getstate__(self):$/;" m class:BaseDict file: +__getstate__ mongoengine/mongoengine/base/datastructures.py /^ def __getstate__(self):$/;" m class:BaseList file: +__getstate__ mongoengine/mongoengine/base/document.py /^ def __getstate__(self):$/;" m class:BaseDocument file: +__getstate__ mongoengine/mongoengine/fields.py /^ def __getstate__(self):$/;" m class:GridFSProxy file: +__getstate__ mongoengine/mongoengine/queryset/base.py /^ def __getstate__(self):$/;" m class:BaseQuerySet file: +__gt__ mongoengine/mongoengine/context_managers.py /^ def __gt__(self, value):$/;" m class:query_counter file: +__hash__ mongoengine/mongoengine/document.py /^ __hash__ = None$/;" v class:EmbeddedDocument +__hash__ mongoengine/mongoengine/document.py /^ def __hash__(self):$/;" m class:Document file: +__iadd__ mongoengine/mongoengine/base/datastructures.py /^ def __iadd__(self, other):$/;" m class:BaseList file: +__imul__ mongoengine/mongoengine/base/datastructures.py /^ def __imul__(self, other):$/;" m class:BaseList file: +__init__ mongoengine/fields.py /^ def __init__(self, *args, **kwargs):$/;" m class:GenericLazyReferenceField +__init__ mongoengine/fields.py /^ def __init__(self, *args, **kwargs):$/;" m class:GenericReferenceField +__init__ mongoengine/fields.py /^ def __init__(self, basecls=None, field=None, *args, **kwargs):$/;" m class:DictField +__init__ mongoengine/fields.py /^ def __init__(self, binary=True, **kwargs):$/;" m class:UUIDField +__init__ mongoengine/fields.py /^ def __init__(self, collection_name=None, db_alias=None, sequence_name=None,$/;" m class:SequenceField +__init__ mongoengine/fields.py /^ def __init__(self, db_alias=DEFAULT_CONNECTION_NAME, collection_name='fs',$/;" m class:FileField +__init__ mongoengine/fields.py /^ def __init__(self, document_type, **kwargs):$/;" m class:EmbeddedDocumentField +__init__ mongoengine/fields.py /^ def __init__(self, document_type, **kwargs):$/;" m class:EmbeddedDocumentListField +__init__ mongoengine/fields.py /^ def __init__(self, document_type, dbref=False,$/;" m class:ReferenceField +__init__ mongoengine/fields.py /^ def __init__(self, document_type, fields=None, auto_sync=True, **kwargs):$/;" m class:CachedReferenceField +__init__ mongoengine/fields.py /^ def __init__(self, document_type, passthrough=False, dbref=False,$/;" m class:LazyReferenceField +__init__ mongoengine/fields.py /^ def __init__(self, domain_whitelist=None, allow_utf8_user=False,$/;" m class:EmailField +__init__ mongoengine/fields.py /^ def __init__(self, field, **kwargs):$/;" m class:SortedListField +__init__ mongoengine/fields.py /^ def __init__(self, field=None, **kwargs):$/;" m class:ListField +__init__ mongoengine/fields.py /^ def __init__(self, field=None, *args, **kwargs):$/;" m class:MapField +__init__ mongoengine/fields.py /^ def __init__(self, grid_id=None, key=None,$/;" m class:GridFSProxy +__init__ mongoengine/fields.py /^ def __init__(self, max_bytes=None, **kwargs):$/;" m class:BinaryField +__init__ mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:FloatField +__init__ mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:IntField +__init__ mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:LongField +__init__ mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, force_string=False,$/;" m class:DecimalField +__init__ mongoengine/fields.py /^ def __init__(self, regex=None, max_length=None, min_length=None, **kwargs):$/;" m class:StringField +__init__ mongoengine/fields.py /^ def __init__(self, separator=',', **kwargs):$/;" m class:ComplexDateTimeField +__init__ mongoengine/fields.py /^ def __init__(self, size=None, thumbnail_size=None,$/;" m class:ImageField +__init__ mongoengine/fields.py /^ def __init__(self, verify_exists=False, url_regex=None, schemes=None, **kwargs):$/;" m class:URLField +__init__ mongoengine/mongoengine/base/datastructures.py /^ def __init__(self, **kwargs):$/;" m class:StrictDict +__init__ mongoengine/mongoengine/base/datastructures.py /^ def __init__(self, dict_items, instance, name):$/;" m class:BaseDict +__init__ mongoengine/mongoengine/base/datastructures.py /^ def __init__(self, document_type, pk, cached_doc=None, passthrough=False):$/;" m class:LazyReference +__init__ mongoengine/mongoengine/base/datastructures.py /^ def __init__(self, list_items, instance, name):$/;" m class:BaseList +__init__ mongoengine/mongoengine/base/datastructures.py /^ def __init__(self, list_items, instance, name):$/;" m class:EmbeddedDocumentList +__init__ mongoengine/mongoengine/base/document.py /^ def __init__(self, *args, **values):$/;" m class:BaseDocument +__init__ mongoengine/mongoengine/base/fields.py /^ def __init__(self, auto_index=True, *args, **kwargs):$/;" m class:GeoJsonBaseField +__init__ mongoengine/mongoengine/base/fields.py /^ def __init__(self, db_field=None, name=None, required=False, default=None,$/;" m class:BaseField +__init__ mongoengine/mongoengine/context_managers.py /^ def __init__(self):$/;" m class:query_counter +__init__ mongoengine/mongoengine/context_managers.py /^ def __init__(self, cls):$/;" m class:no_dereference +__init__ mongoengine/mongoengine/context_managers.py /^ def __init__(self, cls):$/;" m class:no_sub_classes +__init__ mongoengine/mongoengine/context_managers.py /^ def __init__(self, cls, collection_name):$/;" m class:switch_collection +__init__ mongoengine/mongoengine/context_managers.py /^ def __init__(self, cls, db_alias):$/;" m class:switch_db +__init__ mongoengine/mongoengine/document.py /^ def __init__(self, *args, **kwargs):$/;" m class:EmbeddedDocument +__init__ mongoengine/mongoengine/document.py /^ def __init__(self, document, collection, key, value):$/;" m class:MapReduceDocument +__init__ mongoengine/mongoengine/errors.py /^ def __init__(self, message='', **kwargs):$/;" m class:ValidationError +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, *args, **kwargs):$/;" m class:GenericLazyReferenceField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, *args, **kwargs):$/;" m class:GenericReferenceField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, basecls=None, field=None, *args, **kwargs):$/;" m class:DictField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, binary=True, **kwargs):$/;" m class:UUIDField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, collection_name=None, db_alias=None, sequence_name=None,$/;" m class:SequenceField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, db_alias=DEFAULT_CONNECTION_NAME, collection_name='fs',$/;" m class:FileField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, document_type, **kwargs):$/;" m class:EmbeddedDocumentField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, document_type, **kwargs):$/;" m class:EmbeddedDocumentListField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, document_type, dbref=False,$/;" m class:ReferenceField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, document_type, fields=None, auto_sync=True, **kwargs):$/;" m class:CachedReferenceField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, document_type, passthrough=False, dbref=False,$/;" m class:LazyReferenceField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, domain_whitelist=None, allow_utf8_user=False,$/;" m class:EmailField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, field, **kwargs):$/;" m class:SortedListField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, field=None, **kwargs):$/;" m class:ListField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, field=None, *args, **kwargs):$/;" m class:MapField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, grid_id=None, key=None,$/;" m class:GridFSProxy +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, max_bytes=None, **kwargs):$/;" m class:BinaryField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:FloatField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:IntField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:LongField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, force_string=False,$/;" m class:DecimalField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, regex=None, max_length=None, min_length=None, **kwargs):$/;" m class:StringField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, separator=',', **kwargs):$/;" m class:ComplexDateTimeField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, size=None, thumbnail_size=None,$/;" m class:ImageField +__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, verify_exists=False, url_regex=None, schemes=None, **kwargs):$/;" m class:URLField +__init__ mongoengine/mongoengine/queryset/base.py /^ def __init__(self, document, collection):$/;" m class:BaseQuerySet +__init__ mongoengine/mongoengine/queryset/field_list.py /^ def __init__(self, fields=None, value=ONLY, always_include=None, _only_called=False):$/;" m class:QueryFieldList +__init__ mongoengine/mongoengine/queryset/manager.py /^ def __init__(self, queryset_func=None):$/;" m class:QuerySetManager +__init__ mongoengine/mongoengine/queryset/visitor.py /^ def __init__(self, **query):$/;" m class:Q +__init__ mongoengine/mongoengine/queryset/visitor.py /^ def __init__(self, document):$/;" m class:QueryCompilerVisitor +__init__ mongoengine/mongoengine/queryset/visitor.py /^ def __init__(self, operation, children):$/;" m class:QCombination +__init__ mongoengine/mongoengine/signals.py /^ def __init__(self, name, doc=None):$/;" m class:_FakeSignal +__init__ mongoengine/tests/fields/fields.py /^ def __init__(self, **kwargs):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField +__init__ tests/fields/fields.py /^ def __init__(self, **kwargs):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField +__int__ mongoengine/mongoengine/context_managers.py /^ def __int__(self):$/;" m class:query_counter file: +__iter__ mongoengine/mongoengine/base/datastructures.py /^ def __iter__(self):$/;" m class:BaseList file: +__iter__ mongoengine/mongoengine/base/datastructures.py /^ def __iter__(self):$/;" m class:StrictDict file: +__iter__ mongoengine/mongoengine/base/document.py /^ def __iter__(self):$/;" m class:BaseDocument file: +__iter__ mongoengine/mongoengine/queryset/base.py /^ def __iter__(self):$/;" m class:BaseQuerySet file: +__iter__ mongoengine/mongoengine/queryset/queryset.py /^ def __iter__(self):$/;" m class:QuerySet file: +__iter__ mongoengine/mongoengine/queryset/queryset.py /^ def __iter__(self):$/;" m class:QuerySetNoCache file: +__le__ mongoengine/mongoengine/context_managers.py /^ def __le__(self, value):$/;" m class:query_counter file: +__len__ mongoengine/mongoengine/base/datastructures.py /^ def __len__(self):$/;" m class:StrictDict file: +__len__ mongoengine/mongoengine/base/document.py /^ def __len__(self):$/;" m class:BaseDocument file: +__len__ mongoengine/mongoengine/queryset/queryset.py /^ def __len__(self):$/;" m class:QuerySet file: +__lt__ mongoengine/mongoengine/context_managers.py /^ def __lt__(self, value):$/;" m class:query_counter file: +__match_all mongoengine/mongoengine/base/datastructures.py /^ def __match_all(cls, embedded_doc, kwargs):$/;" m class:EmbeddedDocumentList file: +__metaclass__ mongoengine/mongoengine/document.py /^ __metaclass__ = DocumentMetaclass$/;" v class:DynamicEmbeddedDocument +__metaclass__ mongoengine/mongoengine/document.py /^ __metaclass__ = DocumentMetaclass$/;" v class:EmbeddedDocument +__metaclass__ mongoengine/mongoengine/document.py /^ __metaclass__ = TopLevelDocumentMetaclass$/;" v class:Document +__metaclass__ mongoengine/mongoengine/document.py /^ __metaclass__ = TopLevelDocumentMetaclass$/;" v class:DynamicDocument +__ne__ mongoengine/fields.py /^ def __ne__(self, other):$/;" m class:GridFSProxy file: +__ne__ mongoengine/mongoengine/base/datastructures.py /^ def __ne__(self, other):$/;" m class:StrictDict file: +__ne__ mongoengine/mongoengine/base/document.py /^ def __ne__(self, other):$/;" m class:BaseDocument file: +__ne__ mongoengine/mongoengine/context_managers.py /^ def __ne__(self, value):$/;" m class:query_counter file: +__ne__ mongoengine/mongoengine/document.py /^ def __ne__(self, other):$/;" m class:EmbeddedDocument file: +__ne__ mongoengine/mongoengine/fields.py /^ def __ne__(self, other):$/;" m class:GridFSProxy file: +__new__ mongoengine/mongoengine/base/metaclasses.py /^ def __new__(cls, name, bases, attrs):$/;" m class:DocumentMetaclass file: +__new__ mongoengine/mongoengine/base/metaclasses.py /^ def __new__(cls, name, bases, attrs):$/;" m class:TopLevelDocumentMetaclass file: +__nonzero__ mongoengine/fields.py /^ def __nonzero__(self):$/;" m class:GridFSProxy file: +__nonzero__ mongoengine/mongoengine/fields.py /^ def __nonzero__(self):$/;" m class:GridFSProxy file: +__nonzero__ mongoengine/mongoengine/queryset/base.py /^ def __nonzero__(self):$/;" m class:BaseQuerySet file: +__nonzero__ mongoengine/mongoengine/queryset/field_list.py /^ def __nonzero__(self):$/;" m class:QueryFieldList file: +__only_matches mongoengine/mongoengine/base/datastructures.py /^ def __only_matches(cls, embedded_docs, kwargs):$/;" m class:EmbeddedDocumentList file: +__or__ mongoengine/mongoengine/queryset/visitor.py /^ def __or__(self, other):$/;" m class:QNode file: +__raw__ mongoengine/tests/queryset/queryset.py /^ __raw__={"$addToSet": {"tags": {"$each": ["code", "mongodb", "code"]}}})$/;" v class:QuerySetTest.test_update_push_and_pull_add_to_set.BlogPost +__raw__ mongoengine/tests/queryset/queryset.py /^ __raw__={'document.a_name': 'A doc'}).count(), 1)$/;" v class:QuerySetTest.test_query_generic_embedded_document.Doc +__raw__ mongoengine/tests/queryset/queryset.py /^ __raw__={'document.b_name': 'B doc'}).count(), 1)$/;" v class:QuerySetTest.test_query_generic_embedded_document.Doc +__repr__ mongoengine/fields.py /^ def __repr__(self):$/;" m class:GridFSProxy file: +__repr__ mongoengine/mongoengine/base/datastructures.py /^ def __repr__(self):$/;" m class:StrictDict.create.SpecificStrictDict file: +__repr__ mongoengine/mongoengine/base/datastructures.py /^ def __repr__(self):$/;" m class:LazyReference file: +__repr__ mongoengine/mongoengine/base/document.py /^ def __repr__(self):$/;" m class:BaseDocument file: +__repr__ mongoengine/mongoengine/context_managers.py /^ def __repr__(self):$/;" m class:query_counter file: +__repr__ mongoengine/mongoengine/errors.py /^ def __repr__(self):$/;" m class:ValidationError file: +__repr__ mongoengine/mongoengine/fields.py /^ def __repr__(self):$/;" m class:GridFSProxy file: +__repr__ mongoengine/mongoengine/queryset/queryset.py /^ def __repr__(self):$/;" m class:QuerySet file: +__repr__ mongoengine/mongoengine/queryset/queryset.py /^ def __repr__(self):$/;" m class:QuerySetNoCache file: +__repr__ mongoengine/tests/queryset/queryset.py /^ def __repr__(self):$/;" m class:QuerySetTest.test_repr.Doc file: +__repr__ mongoengine/tests/test_dereference.py /^ def __repr__(self):$/;" m class:FieldTest.test_circular_reference.Person file: +__repr__ mongoengine/tests/test_dereference.py /^ def __repr__(self):$/;" m class:FieldTest.test_circular_reference_on_self.Person file: +__repr__ mongoengine/tests/test_dereference.py /^ def __repr__(self):$/;" m class:FieldTest.test_circular_tree_reference.Person file: +__set__ mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:BinaryField file: +__set__ mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:ComplexDateTimeField file: +__set__ mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:FileField file: +__set__ mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:SequenceField file: +__set__ mongoengine/mongoengine/base/fields.py /^ def __set__(self, instance, value):$/;" m class:BaseField file: +__set__ mongoengine/mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:BinaryField file: +__set__ mongoengine/mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:ComplexDateTimeField file: +__set__ mongoengine/mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:FileField file: +__set__ mongoengine/mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:SequenceField file: +__set_field_display mongoengine/mongoengine/base/document.py /^ def __set_field_display(self):$/;" m class:BaseDocument file: +__setattr__ mongoengine/mongoengine/base/document.py /^ def __setattr__(self, name, value):$/;" m class:BaseDocument file: +__setitem__ mongoengine/mongoengine/base/datastructures.py /^ def __setitem__(self, key, value):$/;" m class:StrictDict file: +__setitem__ mongoengine/mongoengine/base/datastructures.py /^ def __setitem__(self, key, value, *args, **kwargs):$/;" m class:BaseDict file: +__setitem__ mongoengine/mongoengine/base/datastructures.py /^ def __setitem__(self, key, value, *args, **kwargs):$/;" m class:BaseList file: +__setitem__ mongoengine/mongoengine/base/document.py /^ def __setitem__(self, name, value):$/;" m class:BaseDocument file: +__setslice__ mongoengine/mongoengine/base/datastructures.py /^ def __setslice__(self, *args, **kwargs):$/;" m class:BaseList file: +__setstate__ mongoengine/mongoengine/base/datastructures.py /^ def __setstate__(self, state):$/;" m class:BaseDict file: +__setstate__ mongoengine/mongoengine/base/datastructures.py /^ def __setstate__(self, state):$/;" m class:BaseList file: +__setstate__ mongoengine/mongoengine/base/document.py /^ def __setstate__(self, data):$/;" m class:BaseDocument file: +__setstate__ mongoengine/mongoengine/queryset/base.py /^ def __setstate__(self, obj_dict):$/;" m class:BaseQuerySet file: +__slots__ mongoengine/mongoengine/base/datastructures.py /^ __slots__ = allowed_keys_tuple$/;" v class:StrictDict.create.SpecificStrictDict +__slots__ mongoengine/mongoengine/base/datastructures.py /^ __slots__ = ('_cached_doc', 'passthrough', 'document_type')$/;" v class:LazyReference +__slots__ mongoengine/mongoengine/base/datastructures.py /^ __slots__ = ()$/;" v class:StrictDict +__slots__ mongoengine/mongoengine/base/document.py /^ __slots__ = ('_changed_fields', '_initialised', '_created', '_data',$/;" v class:BaseDocument +__slots__ mongoengine/mongoengine/document.py /^ __slots__ = ('__objects',)$/;" v class:Document +__slots__ mongoengine/mongoengine/document.py /^ __slots__ = ('_instance', )$/;" v class:EmbeddedDocument +__str__ mongoengine/fields.py /^ def __str__(self):$/;" m class:GridFSProxy file: +__str__ mongoengine/mongoengine/base/document.py /^ def __str__(self):$/;" m class:BaseDocument file: +__str__ mongoengine/mongoengine/errors.py /^ def __str__(self):$/;" m class:ValidationError file: +__str__ mongoengine/mongoengine/fields.py /^ def __str__(self):$/;" m class:GridFSProxy file: +__str__ mongoengine/tests/document/instance.py /^ def __str__(self):$/;" m class:InstanceTest.test_db_ref_usage.Book file: +__str__ mongoengine/tests/document/instance.py /^ def __str__(self):$/;" m class:InstanceTest.test_repr_none.Article file: +__unicode__ mongoengine/tests/document/instance.py /^ def __unicode__(self):$/;" m class:InstanceTest.test_db_ref_usage.Book file: +__unicode__ mongoengine/tests/document/instance.py /^ def __unicode__(self):$/;" m class:InstanceTest.test_repr.Article file: +__unicode__ mongoengine/tests/queryset/geo.py /^ def __unicode__(self):$/;" m class:GeoQueriesTest._create_event_data.Event file: +__unicode__ mongoengine/tests/queryset/queryset.py /^ def __unicode__(self):$/;" m class:QuerySetTest.test_cache_not_cloned.User file: +__unicode__ mongoengine/tests/queryset/queryset.py /^ def __unicode__(self):$/;" m class:QuerySetTest.test_nested_queryset_iterator.User file: +__unicode__ mongoengine/tests/queryset/queryset.py /^ def __unicode__(self):$/;" m class:QuerySetTest.test_pull_from_nested_embedded.User file: +__unicode__ mongoengine/tests/queryset/queryset.py /^ def __unicode__(self):$/;" m class:QuerySetTest.test_pull_from_nested_mapfield.Collaborator file: +__unicode__ mongoengine/tests/queryset/queryset.py /^ def __unicode__(self):$/;" m class:QuerySetTest.test_pull_nested.Collaborator file: +__unicode__ mongoengine/tests/test_signals.py /^ def __unicode__(self):$/;" m class:SignalTests.setUp.Another file: +__unicode__ mongoengine/tests/test_signals.py /^ def __unicode__(self):$/;" m class:SignalTests.setUp.Author file: +__unicode__ mongoengine/tests/test_signals.py /^ def __unicode__(self):$/;" m class:SignalTests.setUp.Post file: +__version__ mongoengine/mongoengine/__init__.py /^__version__ = get_version()$/;" v +_attach_objects mongoengine/mongoengine/dereference.py /^ def _attach_objects(self, items, depth=0, instance=None, name=None):$/;" m class:DeReference +_auto_dereference mongoengine/mongoengine/base/fields.py /^ _auto_dereference = True$/;" v class:BaseField +_auto_dereference mongoengine/mongoengine/queryset/base.py /^ _auto_dereference = True$/;" v class:BaseQuerySet +_auto_gen mongoengine/fields.py /^ _auto_gen = True$/;" v class:SequenceField +_auto_gen mongoengine/mongoengine/base/fields.py /^ _auto_gen = False # Call `generate` to generate a value$/;" v class:BaseField +_auto_gen mongoengine/mongoengine/fields.py /^ _auto_gen = True$/;" v class:SequenceField +_binary mongoengine/fields.py /^ _binary = None$/;" v class:UUIDField +_binary mongoengine/mongoengine/fields.py /^ _binary = None$/;" v class:UUIDField +_build_index_spec mongoengine/mongoengine/base/document.py /^ def _build_index_spec(cls, spec):$/;" m class:BaseDocument +_build_index_specs mongoengine/mongoengine/base/document.py /^ def _build_index_specs(cls, meta_indexes):$/;" m class:BaseDocument +_chainable_method mongoengine/mongoengine/queryset/base.py /^ def _chainable_method(self, method_name, val):$/;" m class:BaseQuerySet +_class_registry_cache mongoengine/mongoengine/common.py /^_class_registry_cache = {}$/;" v +_classes mongoengine/mongoengine/base/datastructures.py /^ _classes = {}$/;" v class:StrictDict +_clean_settings mongoengine/mongoengine/connection.py /^ def _clean_settings(settings_dict):$/;" f function:get_connection +_clean_slice mongoengine/mongoengine/queryset/field_list.py /^ def _clean_slice(self):$/;" m class:QueryFieldList +_clear_changed_fields mongoengine/mongoengine/base/document.py /^ def _clear_changed_fields(self):$/;" m class:BaseDocument +_clone_into mongoengine/mongoengine/queryset/base.py /^ def _clone_into(self, new_qs):$/;" m class:BaseQuerySet +_collection mongoengine/mongoengine/queryset/base.py /^ def _collection(self):$/;" m class:BaseQuerySet +_combine mongoengine/mongoengine/queryset/visitor.py /^ def _combine(self, other, operation):$/;" m class:QNode +_connection_settings mongoengine/mongoengine/connection.py /^_connection_settings = {}$/;" v +_connections mongoengine/mongoengine/connection.py /^_connections = {}$/;" v +_convert_from_datetime mongoengine/fields.py /^ def _convert_from_datetime(self, val):$/;" m class:ComplexDateTimeField +_convert_from_datetime mongoengine/mongoengine/fields.py /^ def _convert_from_datetime(self, val):$/;" m class:ComplexDateTimeField +_convert_from_string mongoengine/fields.py /^ def _convert_from_string(self, data):$/;" m class:ComplexDateTimeField +_convert_from_string mongoengine/mongoengine/fields.py /^ def _convert_from_string(self, data):$/;" m class:ComplexDateTimeField +_create_event_data mongoengine/tests/queryset/geo.py /^ def _create_event_data(self, point_field_class=GeoPointField):$/;" m class:GeoQueriesTest +_cursor mongoengine/mongoengine/queryset/base.py /^ def _cursor(self):$/;" m class:BaseQuerySet +_cursor_args mongoengine/mongoengine/queryset/base.py /^ def _cursor_args(self):$/;" m class:BaseQuerySet +_dbs mongoengine/mongoengine/connection.py /^_dbs = {}$/;" v +_decorated_with_ver_requirement mongoengine/tests/utils.py /^def _decorated_with_ver_requirement(func, ver_tuple):$/;" f +_delta mongoengine/mongoengine/base/document.py /^ def _delta(self):$/;" m class:BaseDocument +_dereference mongoengine/mongoengine/queryset/base.py /^ def _dereference(self):$/;" m class:BaseQuerySet +_dereferenced mongoengine/mongoengine/base/datastructures.py /^ _dereferenced = False$/;" v class:BaseDict +_dereferenced mongoengine/mongoengine/base/datastructures.py /^ _dereferenced = False$/;" v class:BaseList +_document_registry mongoengine/mongoengine/base/common.py /^_document_registry = {}$/;" v +_dynamic mongoengine/mongoengine/base/document.py /^ _dynamic = False$/;" v class:BaseDocument +_dynamic mongoengine/mongoengine/document.py /^ _dynamic = True$/;" v class:DynamicDocument +_dynamic mongoengine/mongoengine/document.py /^ _dynamic = True$/;" v class:DynamicEmbeddedDocument +_dynamic_lock mongoengine/mongoengine/base/document.py /^ _dynamic_lock = True$/;" v class:BaseDocument +_ensure_indexes mongoengine/mongoengine/queryset/base.py /^ def _ensure_indexes(self):$/;" m class:BaseQuerySet +_fail mongoengine/mongoengine/signals.py /^ def _fail(self, *args, **kwargs):$/;" m class:_FakeSignal +_fetch_objects mongoengine/mongoengine/dereference.py /^ def _fetch_objects(self, doc_type=None):$/;" m class:DeReference +_field_list_cache mongoengine/mongoengine/common.py /^_field_list_cache = []$/;" v +_fields_to_dbfields mongoengine/mongoengine/queryset/base.py /^ def _fields_to_dbfields(self, fields):$/;" m class:BaseQuerySet +_find_references mongoengine/mongoengine/dereference.py /^ def _find_references(self, items, depth=0):$/;" m class:DeReference +_format_errors mongoengine/mongoengine/errors.py /^ def _format_errors(self):$/;" m class:ValidationError +_from_son mongoengine/mongoengine/base/document.py /^ def _from_son(cls, son, _auto_dereference=True, only_fields=None, created=False):$/;" m class:BaseDocument +_fs mongoengine/fields.py /^ _fs = None$/;" v class:GridFSProxy +_fs mongoengine/mongoengine/fields.py /^ _fs = None$/;" v class:GridFSProxy +_geo_index mongoengine/fields.py /^ _geo_index = pymongo.GEO2D$/;" v class:GeoPointField +_geo_index mongoengine/mongoengine/base/fields.py /^ _geo_index = False$/;" v class:BaseField +_geo_index mongoengine/mongoengine/base/fields.py /^ _geo_index = pymongo.GEOSPHERE$/;" v class:GeoJsonBaseField +_geo_index mongoengine/mongoengine/fields.py /^ _geo_index = pymongo.GEO2D$/;" v class:GeoPointField +_geo_indices mongoengine/mongoengine/base/document.py /^ def _geo_indices(cls, inspected=None, parent_field=None):$/;" m class:BaseDocument +_geo_operator mongoengine/mongoengine/queryset/transform.py /^def _geo_operator(field, op, value):$/;" f +_get_as_pymongo mongoengine/mongoengine/queryset/base.py /^ def _get_as_pymongo(self, doc):$/;" m class:BaseQuerySet +_get_bases mongoengine/mongoengine/base/metaclasses.py /^ def _get_bases(cls, bases):$/;" m class:DocumentMetaclass +_get_capped_collection mongoengine/mongoengine/document.py /^ def _get_capped_collection(cls):$/;" m class:Document +_get_changed_fields mongoengine/mongoengine/base/document.py /^ def _get_changed_fields(self, inspected=None):$/;" m class:BaseDocument +_get_collection mongoengine/mongoengine/document.py /^ def _get_collection(cls):$/;" m class:Document +_get_collection_name mongoengine/mongoengine/base/document.py /^ def _get_collection_name(cls):$/;" m class:BaseDocument +_get_collection_name mongoengine/mongoengine/context_managers.py /^ def _get_collection_name(cls):$/;" f function:switch_collection.__enter__ +_get_connection mongoengine/mongoengine/connection.py /^_get_connection = get_connection$/;" v +_get_count mongoengine/mongoengine/context_managers.py /^ def _get_count(self):$/;" m class:query_counter +_get_db mongoengine/mongoengine/connection.py /^_get_db = get_db$/;" v +_get_db mongoengine/mongoengine/document.py /^ def _get_db(cls):$/;" m class:Document +_get_items mongoengine/mongoengine/dereference.py /^ def _get_items(items):$/;" f function:DeReference.__call__ +_get_loaded mongoengine/tests/queryset/pickable.py /^ def _get_loaded(self, qs):$/;" m class:TestQuerysetPickable +_get_message mongoengine/mongoengine/errors.py /^ def _get_message(self):$/;" m class:ValidationError +_get_order_by mongoengine/mongoengine/queryset/base.py /^ def _get_order_by(self, keys):$/;" m class:BaseQuerySet +_get_scalar mongoengine/mongoengine/queryset/base.py /^ def _get_scalar(self, doc):$/;" m class:BaseQuerySet +_get_update_doc mongoengine/mongoengine/document.py /^ def _get_update_doc(self):$/;" m class:Document +_has_data mongoengine/mongoengine/queryset/base.py /^ def _has_data(self):$/;" m class:BaseQuerySet +_has_more mongoengine/mongoengine/queryset/queryset.py /^ _has_more = True$/;" v class:QuerySet +_import_class mongoengine/mongoengine/common.py /^def _import_class(cls_name):$/;" f +_import_classes mongoengine/mongoengine/base/metaclasses.py /^ def _import_classes(cls):$/;" m class:DocumentMetaclass +_index_test mongoengine/tests/document/indexes.py /^ def _index_test(self, InheritFrom):$/;" m class:IndexesTest +_index_test_inheritance mongoengine/tests/document/indexes.py /^ def _index_test_inheritance(self, InheritFrom):$/;" m class:IndexesTest +_infer_geometry mongoengine/mongoengine/queryset/transform.py /^def _infer_geometry(value):$/;" f +_inner mongoengine/tests/utils.py /^ def _inner(*args, **kwargs):$/;" f function:_decorated_with_ver_requirement +_inner mongoengine/tests/utils.py /^ def _inner(*args, **kwargs):$/;" f function:skip_pymongo3 +_instance mongoengine/mongoengine/base/datastructures.py /^ _instance = None$/;" v class:BaseDict +_instance mongoengine/mongoengine/base/datastructures.py /^ _instance = None$/;" v class:BaseList +_item_frequencies_exec_js mongoengine/mongoengine/queryset/base.py /^ def _item_frequencies_exec_js(self, field, normalize=False):$/;" m class:BaseQuerySet +_item_frequencies_map_reduce mongoengine/mongoengine/queryset/base.py /^ def _item_frequencies_map_reduce(self, field, normalize=False):$/;" m class:BaseQuerySet +_iter_results mongoengine/mongoengine/queryset/queryset.py /^ def _iter_results(self):$/;" m class:QuerySet +_len mongoengine/mongoengine/queryset/queryset.py /^ _len = None$/;" v class:QuerySet +_lookup_field mongoengine/mongoengine/base/document.py /^ def _lookup_field(cls, parts):$/;" m class:BaseDocument +_mark_as_changed mongoengine/fields.py /^ def _mark_as_changed(self):$/;" m class:GridFSProxy +_mark_as_changed mongoengine/mongoengine/base/datastructures.py /^ def _mark_as_changed(self, key=None):$/;" m class:BaseDict +_mark_as_changed mongoengine/mongoengine/base/datastructures.py /^ def _mark_as_changed(self, key=None):$/;" m class:BaseList +_mark_as_changed mongoengine/mongoengine/base/document.py /^ def _mark_as_changed(self, key):$/;" m class:BaseDocument +_mark_as_changed mongoengine/mongoengine/fields.py /^ def _mark_as_changed(self):$/;" m class:GridFSProxy +_merge_options mongoengine/mongoengine/base/metaclasses.py /^ _merge_options = ('indexes',)$/;" v class:MetaDict +_message mongoengine/mongoengine/errors.py /^ _message = None$/;" v class:ValidationError +_name mongoengine/mongoengine/base/datastructures.py /^ _name = None$/;" v class:BaseDict +_name mongoengine/mongoengine/base/datastructures.py /^ _name = None$/;" v class:BaseList +_nestable_types_changed_fields mongoengine/mongoengine/base/document.py /^ def _nestable_types_changed_fields(self, changed_fields, key, data, inspected):$/;" m class:BaseDocument +_object_key mongoengine/mongoengine/document.py /^ def _object_key(self):$/;" m class:Document +_order_reverse mongoengine/fields.py /^ _order_reverse = False$/;" v class:SortedListField +_order_reverse mongoengine/mongoengine/fields.py /^ _order_reverse = False$/;" v class:SortedListField +_ordering mongoengine/fields.py /^ _ordering = None$/;" v class:SortedListField +_ordering mongoengine/mongoengine/fields.py /^ _ordering = None$/;" v class:SortedListField +_populate_cache mongoengine/mongoengine/queryset/queryset.py /^ def _populate_cache(self):$/;" m class:QuerySet +_prepare_query_for_iterable mongoengine/mongoengine/queryset/transform.py /^def _prepare_query_for_iterable(field, op, value):$/;" f +_put_thumbnail mongoengine/fields.py /^ def _put_thumbnail(self, thumbnail, format, progressive, **kwargs):$/;" m class:ImageGridFsProxy +_put_thumbnail mongoengine/mongoengine/fields.py /^ def _put_thumbnail(self, thumbnail, format, progressive, **kwargs):$/;" m class:ImageGridFsProxy +_qs mongoengine/mongoengine/document.py /^ def _qs(self):$/;" m class:Document +_query mongoengine/mongoengine/queryset/base.py /^ def _query(self):$/;" m class:BaseQuerySet +_query_conjunction mongoengine/mongoengine/queryset/visitor.py /^ def _query_conjunction(self, queries):$/;" m class:SimplificationVisitor +_rank mongoengine/tests/document/instance.py /^ _rank = StringField(required=False, db_field="rank")$/;" v class:InstanceTest.test_db_field_load.Person +_reload mongoengine/mongoengine/document.py /^ def _reload(self, key, value):$/;" m class:Document +_result_cache mongoengine/mongoengine/queryset/queryset.py /^ _result_cache = None$/;" v class:QuerySet +_save_create mongoengine/mongoengine/document.py /^ def _save_create(self, doc, force_insert, write_concern):$/;" m class:Document +_save_update mongoengine/mongoengine/document.py /^ def _save_update(self, doc, save_condition, write_concern):$/;" m class:Document +_set_message mongoengine/mongoengine/errors.py /^ def _set_message(self, message):$/;" m class:ValidationError +_set_owner_document mongoengine/mongoengine/base/fields.py /^ def _set_owner_document(self, owner_document):$/;" m class:BaseField +_set_owner_document mongoengine/mongoengine/base/fields.py /^ def _set_owner_document(self, owner_document):$/;" m class:ComplexBaseField +_signals mongoengine/mongoengine/signals.py /^_signals = Namespace()$/;" v +_sort_key mongoengine/mongoengine/queryset/base.py /^ def _sort_key(field_tuple):$/;" f function:BaseQuerySet.fields +_special_fields mongoengine/mongoengine/base/datastructures.py /^ _special_fields = set(['get', 'pop', 'iteritems', 'items', 'keys', 'create'])$/;" v class:StrictDict +_sub_js_fields mongoengine/mongoengine/queryset/base.py /^ def _sub_js_fields(self, code):$/;" m class:BaseQuerySet +_test_embedded mongoengine/tests/queryset/geo.py /^ def _test_embedded(self, point_field_class):$/;" m class:GeoQueriesTest +_test_for_expected_error mongoengine/tests/fields/geo.py /^ def _test_for_expected_error(self, Cls, loc, expected):$/;" m class:GeoFieldTest +_to_mongo_safe_call mongoengine/mongoengine/base/fields.py /^ def _to_mongo_safe_call(self, value, use_db_field=True, fields=None):$/;" m class:BaseField +_translate_field_name mongoengine/mongoengine/base/document.py /^ def _translate_field_name(cls, field, sep='.'):$/;" m class:BaseDocument +_type mongoengine/fields.py /^ _type = 'LineString'$/;" v class:LineStringField +_type mongoengine/fields.py /^ _type = 'MultiLineString'$/;" v class:MultiLineStringField +_type mongoengine/fields.py /^ _type = 'MultiPoint'$/;" v class:MultiPointField +_type mongoengine/fields.py /^ _type = 'MultiPolygon'$/;" v class:MultiPolygonField +_type mongoengine/fields.py /^ _type = 'Point'$/;" v class:PointField +_type mongoengine/fields.py /^ _type = 'Polygon'$/;" v class:PolygonField +_type mongoengine/mongoengine/base/fields.py /^ _type = 'GeoBase'$/;" v class:GeoJsonBaseField +_type mongoengine/mongoengine/fields.py /^ _type = 'LineString'$/;" v class:LineStringField +_type mongoengine/mongoengine/fields.py /^ _type = 'MultiLineString'$/;" v class:MultiLineStringField +_type mongoengine/mongoengine/fields.py /^ _type = 'MultiPoint'$/;" v class:MultiPointField +_type mongoengine/mongoengine/fields.py /^ _type = 'MultiPolygon'$/;" v class:MultiPolygonField +_type mongoengine/mongoengine/fields.py /^ _type = 'Point'$/;" v class:PointField +_type mongoengine/mongoengine/fields.py /^ _type = 'Polygon'$/;" v class:PolygonField +_unique_with_indexes mongoengine/mongoengine/base/document.py /^ def _unique_with_indexes(cls, namespace=''):$/;" m class:BaseDocument +_validate mongoengine/mongoengine/base/fields.py /^ def _validate(self, value, **kwargs):$/;" m class:BaseField +_validate_choices mongoengine/fields.py /^ def _validate_choices(self, value):$/;" m class:GenericLazyReferenceField +_validate_choices mongoengine/fields.py /^ def _validate_choices(self, value):$/;" m class:GenericReferenceField +_validate_choices mongoengine/mongoengine/base/fields.py /^ def _validate_choices(self, value):$/;" m class:BaseField +_validate_choices mongoengine/mongoengine/fields.py /^ def _validate_choices(self, value):$/;" m class:GenericLazyReferenceField +_validate_choices mongoengine/mongoengine/fields.py /^ def _validate_choices(self, value):$/;" m class:GenericReferenceField +_validate_linestring mongoengine/mongoengine/base/fields.py /^ def _validate_linestring(self, value, top_level=True):$/;" m class:GeoJsonBaseField +_validate_multilinestring mongoengine/mongoengine/base/fields.py /^ def _validate_multilinestring(self, value, top_level=True):$/;" m class:GeoJsonBaseField +_validate_multipoint mongoengine/mongoengine/base/fields.py /^ def _validate_multipoint(self, value):$/;" m class:GeoJsonBaseField +_validate_multipolygon mongoengine/mongoengine/base/fields.py /^ def _validate_multipolygon(self, value):$/;" m class:GeoJsonBaseField +_validate_point mongoengine/mongoengine/base/fields.py /^ def _validate_point(self, value):$/;" m class:GeoJsonBaseField +_validate_polygon mongoengine/mongoengine/base/fields.py /^ def _validate_polygon(self, value, top_level=True):$/;" m class:GeoJsonBaseField +a mongoengine/tests/document/indexes.py /^ a = IntField()$/;" v class:IndexesTest.test_covered_index.Test +a mongoengine/tests/document/inheritance.py /^ a = StringField()$/;" v class:InheritanceTest.test_indexes_and_multiple_inheritance.A +a mongoengine/tests/queryset/field_list.py /^ a = ListField()$/;" v class:OnlyExcludeAllTest.test_mix_slice_with_other_fields.MyDoc +a mongoengine/tests/queryset/field_list.py /^ a = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc +a mongoengine/tests/queryset/field_list.py /^ a = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc +a mongoengine/tests/queryset/queryset.py /^ a = ReferenceField(A)$/;" v class:QuerySetTest.test_query_reference_to_custom_pk_doc.B +a mongoengine/tests/queryset/transform.py /^ a = ReferenceField(A)$/;" v class:TransformTest.test_chaining.B +a mongoengine/tests/queryset/transform.py /^ a = StringField()$/;" v class:TransformTest.test_raw_query_and_Q_objects.Foo +a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i)$/;" v class:FieldTest.test_dict_field.Group +a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i)$/;" v class:FieldTest.test_dict_field_no_field_inheritance.Group +a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i)$/;" v class:FieldTest.test_generic_reference.Group +a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i)$/;" v class:FieldTest.test_generic_reference_map_field.Group +a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i)$/;" v class:FieldTest.test_list_field_complex.Group +a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i).save()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group +a_field mongoengine/tests/fields/fields.py /^ a_field = IntField()$/;" v class:EmbeddedDocumentListFieldTestCase.test_custom_data.CustomData +a_field tests/fields/fields.py /^ a_field = IntField()$/;" v class:EmbeddedDocumentListFieldTestCase.test_custom_data.CustomData +a_name mongoengine/tests/queryset/queryset.py /^ a_name = StringField()$/;" v class:QuerySetTest.test_query_generic_embedded_document.A +accept mongoengine/mongoengine/queryset/visitor.py /^ def accept(self, visitor):$/;" m class:Q +accept mongoengine/mongoengine/queryset/visitor.py /^ def accept(self, visitor):$/;" m class:QCombination +accept mongoengine/mongoengine/queryset/visitor.py /^ def accept(self, visitor):$/;" m class:QNode +actions mongoengine/tests/fields/fields.py /^ actions = MapField(EmbeddedDocumentField(Action))$/;" v class:FieldTest.test_map_field_lookup.Log +actions mongoengine/tests/fields/fields.py /^ actions={'friends': Action(operation='drink', object='beer')}).save()$/;" v class:FieldTest.test_map_field_lookup.Log +actions tests/fields/fields.py /^ actions = MapField(EmbeddedDocumentField(Action))$/;" v class:FieldTest.test_map_field_lookup.Log +actions tests/fields/fields.py /^ actions={'friends': Action(operation='drink', object='beer')}).save()$/;" v class:FieldTest.test_map_field_lookup.Log +actions__friends__object mongoengine/tests/fields/fields.py /^ actions__friends__object='beer').count())$/;" v class:FieldTest.test_map_field_lookup.Log +actions__friends__object tests/fields/fields.py /^ actions__friends__object='beer').count())$/;" v class:FieldTest.test_map_field_lookup.Log +actions__friends__operation mongoengine/tests/fields/fields.py /^ actions__friends__operation='drink',$/;" v class:FieldTest.test_map_field_lookup.Log +actions__friends__operation tests/fields/fields.py /^ actions__friends__operation='drink',$/;" v class:FieldTest.test_map_field_lookup.Log +active mongoengine/tests/document/instance.py /^ active = BooleanField(default=True)$/;" v class:InstanceTest.test_save_only_changed_fields.User +active mongoengine/tests/document/instance.py /^ active = BooleanField(default=True)$/;" v class:InstanceTest.test_save_only_changed_fields_recursive.User +active mongoengine/tests/queryset/queryset.py /^ active = BooleanField(default=False)$/;" v class:QuerySetTest.test_custom_manager_overriding_objects_works.Foo +active mongoengine/tests/queryset/queryset.py /^ active = BooleanField(default=True)$/;" v class:QuerySetTest.test_inherit_objects.Foo +active mongoengine/tests/queryset/queryset.py /^ active = BooleanField(default=True)$/;" v class:QuerySetTest.test_inherit_objects_override.Foo +active mongoengine/tests/test_signals.py /^ active = BooleanField(default=False)$/;" v class:SignalTests.setUp.Post +actual mongoengine/tests/fields/fields.py /^ actual = list(Person.objects().scalar(field_name))$/;" v class:FieldTest.test_decimal_storage.Person +actual tests/fields/fields.py /^ actual = list(Person.objects().scalar(field_name))$/;" v class:FieldTest.test_decimal_storage.Person +add_to_class mongoengine/mongoengine/base/metaclasses.py /^ def add_to_class(self, name, value):$/;" m class:DocumentMetaclass +address mongoengine/tests/document/dynamic.py /^ address = EmbeddedDocumentField(Address)$/;" v class:DynamicTest.test_dynamic_embedded_works_with_only.Person +admin mongoengine/tests/fields/fields.py /^ admin = BooleanField()$/;" v class:FieldTest.test_boolean_validation.Person +admin mongoengine/tests/queryset/queryset.py /^ admin = ListField(ReferenceField(User))$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Organization +admin tests/fields/fields.py /^ admin = BooleanField()$/;" v class:FieldTest.test_boolean_validation.Person +adult mongoengine/tests/queryset/queryset.py /^ adult = (User.objects.filter(age__gte=18)$/;" v class:QuerySetTest.test_comment.User +age mongoengine/tests/document/class_methods.py /^ age = IntField()$/;" v class:ClassMethodsTest.setUp.Person +age mongoengine/tests/document/delta.py /^ age = IntField()$/;" v class:DeltaTest.setUp.Person +age mongoengine/tests/document/indexes.py /^ age = IntField()$/;" v class:IndexesTest.setUp.Person +age mongoengine/tests/document/inheritance.py /^ age = IntField()$/;" v class:InheritanceTest.test_inheritance_meta_data.Person +age mongoengine/tests/document/inheritance.py /^ age = IntField()$/;" v class:InheritanceTest.test_inheritance_to_mongo_keys.Person +age mongoengine/tests/document/instance.py /^ age = IntField()$/;" v class:InstanceTest.setUp.Person +age mongoengine/tests/document/instance.py /^ age = IntField()$/;" v class:InstanceTest.test_do_not_save_unchanged_references.Person +age mongoengine/tests/document/instance.py /^ age = IntField()$/;" v class:InstanceTest.test_embedded_document_to_mongo.Person +age mongoengine/tests/document/instance.py /^ age = IntField()$/;" v class:InstanceTest.test_mixin_inheritance.TestDoc +age mongoengine/tests/document/instance.py /^ age = IntField(primary_key=True)$/;" v class:InstanceTest.test_falsey_pk.Person +age mongoengine/tests/document/validation.py /^ age = IntField()$/;" v class:ValidatorErrorTest.test_fields_rewrite.BasePerson +age mongoengine/tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_nothing_set.Person +age mongoengine/tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_set_to_None.Person +age mongoengine/tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person +age mongoengine/tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person +age mongoengine/tests/fields/fields.py /^ age = IntField(min_value=0, max_value=110)$/;" v class:FieldTest.test_int_validation.Person +age mongoengine/tests/fields/fields.py /^ age = IntField(required=True)$/;" v class:FieldTest.test_required_values.Person +age mongoengine/tests/queryset/field_list.py /^ age = IntField()$/;" v class:OnlyExcludeAllTest.setUp.Person +age mongoengine/tests/queryset/pickable.py /^ age = IntField()$/;" v class:Person +age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.setUp.Person +age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_as_pymongo.User +age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_comment.User +age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person +age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_mapfield_update.Member +age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_queryset_aggregation_framework.Person +age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_scalar_embedded.Profile +age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_scalar_simple.UserDoc +age mongoengine/tests/queryset/queryset.py /^ age=51,$/;" v class:QuerySetTest.test_as_pymongo.User +age mongoengine/tests/queryset/visitor.py /^ age = IntField()$/;" v class:QTest.setUp.Person +age mongoengine/tests/queryset/visitor.py /^ age = IntField()$/;" v class:QTest.test_empty_q.Person +age tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_nothing_set.Person +age tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_set_to_None.Person +age tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person +age tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person +age tests/fields/fields.py /^ age = IntField(min_value=0, max_value=110)$/;" v class:FieldTest.test_int_validation.Person +age tests/fields/fields.py /^ age = IntField(required=True)$/;" v class:FieldTest.test_required_values.Person +aggregate mongoengine/mongoengine/queryset/base.py /^ def aggregate(self, *pipeline, **kwargs):$/;" m class:BaseQuerySet +all mongoengine/mongoengine/queryset/base.py /^ def all(self):$/;" m class:BaseQuerySet +all_fields mongoengine/mongoengine/queryset/base.py /^ def all_fields(self):$/;" m class:BaseQuerySet +animal mongoengine/tests/fields/fields.py /^ animal=Animal(name="Leopard", tag="heavy").save()).save()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence +animal mongoengine/tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence +animal mongoengine/tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +animal mongoengine/tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Ocorrence +animal mongoengine/tests/fields/fields.py /^ animal = CachedReferenceField(Animal)$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence +animal mongoengine/tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Ocurrence +animal mongoengine/tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Ocurrence +animal mongoengine/tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Ocurrence +animal mongoengine/tests/fields/fields.py /^ animal = GenericLazyReferenceField(choices=['Animal'])$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Ocurrence +animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Ocurrence +animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Ocurrence +animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Ocurrence +animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Ocurrence +animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Ocurrence +animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal, passthrough=False)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Ocurrence +animal tests/fields/fields.py /^ animal=Animal(name="Leopard", tag="heavy").save()).save()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence +animal tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence +animal tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +animal tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Ocorrence +animal tests/fields/fields.py /^ animal = CachedReferenceField(Animal)$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence +animal tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Ocurrence +animal tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Ocurrence +animal tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Ocurrence +animal tests/fields/fields.py /^ animal = GenericLazyReferenceField(choices=['Animal'])$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Ocurrence +animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Ocurrence +animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Ocurrence +animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Ocurrence +animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Ocurrence +animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Ocurrence +animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal, passthrough=False)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Ocurrence +animal__owner__tags mongoengine/tests/fields/fields.py /^ animal__owner__tags='cool').first()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +animal__owner__tags tests/fields/fields.py /^ animal__owner__tags='cool').first()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +animal__owner__tp mongoengine/tests/fields/fields.py /^ animal__owner__tp='u').first()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence +animal__owner__tp tests/fields/fields.py /^ animal__owner__tp='u').first()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence +animal__tag mongoengine/tests/fields/fields.py /^ animal__tag='heavy',$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence +animal__tag mongoengine/tests/fields/fields.py /^ animal__tag='heavy',$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +animal__tag tests/fields/fields.py /^ animal__tag='heavy',$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence +animal__tag tests/fields/fields.py /^ animal__tag='heavy',$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +animal_passthrough mongoengine/tests/fields/fields.py /^ animal_passthrough = LazyReferenceField(Animal, passthrough=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Ocurrence +animal_passthrough tests/fields/fields.py /^ animal_passthrough = LazyReferenceField(Animal, passthrough=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Ocurrence +animals mongoengine/tests/document/instance.py /^ animals = ListField(GenericReferenceField())$/;" v class:InstanceTest.test_polymorphic_references.Zoo +animals mongoengine/tests/document/instance.py /^ animals = ListField(ReferenceField(Animal))$/;" v class:InstanceTest.test_polymorphic_references.Zoo +anon mongoengine/tests/queryset/field_list.py /^ anon = BooleanField()$/;" v class:OnlyExcludeAllTest.test_exclude_from_subclasses_docs.Anon +api_key mongoengine/tests/fields/fields.py /^ api_key = UUIDField(binary=False)$/;" v class:FieldTest.test_uuid_field_string.Person +api_key mongoengine/tests/fields/fields.py /^ api_key = UUIDField(binary=True)$/;" v class:FieldTest.test_uuid_field_binary.Person +api_key tests/fields/fields.py /^ api_key = UUIDField(binary=False)$/;" v class:FieldTest.test_uuid_field_string.Person +api_key tests/fields/fields.py /^ api_key = UUIDField(binary=True)$/;" v class:FieldTest.test_uuid_field_binary.Person +append mongoengine/mongoengine/base/datastructures.py /^ def append(self, *args, **kwargs):$/;" m class:BaseList +append_to_warning_list mongoengine/tests/all_warnings/__init__.py /^ def append_to_warning_list(self, message, category, *args):$/;" m class:AllWarnings +archived mongoengine/tests/document/instance.py /^ archived = BooleanField(default=False, required=True)$/;" v class:InstanceTest.test_can_save_false_values.Doc +as_dict mongoengine/mongoengine/queryset/field_list.py /^ def as_dict(self):$/;" m class:QueryFieldList +as_pymongo mongoengine/mongoengine/queryset/base.py /^ def as_pymongo(self):$/;" m class:BaseQuerySet +assertDbEqual mongoengine/tests/document/instance.py /^ def assertDbEqual(self, docs):$/;" m class:InstanceTest +assertDbEqual mongoengine/tests/queryset/modify.py /^ def assertDbEqual(self, docs):$/;" m class:FindAndModifyTest +assertHasInstance mongoengine/tests/document/instance.py /^ def assertHasInstance(self, field, instance):$/;" m class:InstanceTest +assertSequence mongoengine/tests/queryset/queryset.py /^ def assertSequence(self, qs, expected):$/;" m class:QuerySetTest +attachments mongoengine/tests/queryset/field_list.py /^ attachments = ListField(EmbeddedDocumentField(Attachment))$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email +author mongoengine/docs/code/tumblelog.py /^ author = ReferenceField(User)$/;" v class:Post +author mongoengine/tests/document/class_methods.py /^ author = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes.BlogPost +author mongoengine/tests/document/class_methods.py /^ author = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPost +author mongoengine/tests/document/class_methods.py /^ author = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPost +author mongoengine/tests/document/class_methods.py /^ author = StringField()$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPost +author mongoengine/tests/document/instance.py /^ author = ReferenceField(User)$/;" v class:InstanceTest.test_db_alias_tests.AuthorBooks +author mongoengine/tests/document/instance.py /^ author = ReferenceField(User)$/;" v class:InstanceTest.test_db_ref_usage.Book +author mongoengine/tests/document/instance.py /^ author = ReferenceField(User, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_with_custom_id_field.Book +author mongoengine/tests/document/instance.py /^ author = ReferenceField(User, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_with_shared_id_among_collections.Book +author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person)$/;" v class:InstanceTest.test_save_reference.BlogPost +author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify.BlogPost +author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_recurs.BlogPost +author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal.BlogPost +author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_with_document_inheritance.BlogPost +author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person, reverse_delete_rule=DENY)$/;" v class:InstanceTest.test_reverse_delete_rule_deny.BlogPost +author mongoengine/tests/fields/fields.py /^ author = EmbeddedDocumentField(Author, required=True)$/;" v class:FieldTest.test_recursive_validation.Comment +author mongoengine/tests/fields/fields.py /^ author = EmbeddedDocumentField(User)$/;" v class:FieldTest.test_embedded_document_inheritance.BlogPost +author mongoengine/tests/fields/fields.py /^ author = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.BlogPost +author mongoengine/tests/fields/fields.py /^ author = LazyReferenceField(Member, dbref=False)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.BlogPost +author mongoengine/tests/fields/fields.py /^ author = LazyReferenceField(Member, dbref=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.BlogPost +author mongoengine/tests/fields/fields.py /^ author = ReferenceField(Member, dbref=False)$/;" v class:FieldTest.test_reference_query_conversion.BlogPost +author mongoengine/tests/fields/fields.py /^ author = ReferenceField(Member, dbref=True)$/;" v class:FieldTest.test_reference_query_conversion_dbref.BlogPost +author mongoengine/tests/fields/fields.py /^ author = ReferenceField(User)$/;" v class:FieldTest.test_reference_validation.BlogPost +author mongoengine/tests/fields/fields.py /^ author = StringField()$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.Comments +author mongoengine/tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents.UserComments +author mongoengine/tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments +author mongoengine/tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.ModeratorComments +author mongoengine/tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.UserComments +author mongoengine/tests/queryset/field_list.py /^ author = EmbeddedDocumentField(User)$/;" v class:OnlyExcludeAllTest.test_exclude.BlogPost +author mongoengine/tests/queryset/field_list.py /^ author = EmbeddedDocumentField(User)$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.BlogPost +author mongoengine/tests/queryset/queryset.py /^ author = EmbeddedDocumentField(User)$/;" v class:QuerySetTest.test_find_embedded.BlogPost +author mongoengine/tests/queryset/queryset.py /^ author = EmbeddedDocumentField(User)$/;" v class:QuerySetTest.test_find_empty_embedded.BlogPost +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person)$/;" v class:QuerySetTest.test_cannot_perform_joins_references.BlogPost +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person)$/;" v class:QuerySetTest.test_confirm_order_by_reference_wont_work.Author +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person)$/;" v class:QuerySetTest.test_query_value_conversion.BlogPost +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person)$/;" v class:QuerySetTest.test_reference_field_find.BlogPost +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, dbref=True)$/;" v class:QuerySetTest.test_reference_field_find_dbref.BlogPost +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_delete_with_limit_handles_delete_rules.BlogPost +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade.BlogPost +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_on_abstract_document.AbstractBlogPost +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=DENY)$/;" v class:QuerySetTest.test_reverse_delete_rule_deny.BlogPost +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=DENY)$/;" v class:QuerySetTest.test_reverse_delete_rule_deny_on_abstract_document.AbstractBlogPost +author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=NULLIFY)$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify_on_abstract_document.AbstractBlogPost +author mongoengine/tests/queryset/queryset.py /^ author=user,$/;" v class:QuerySetTest.test_find_embedded.BlogPost +author mongoengine/tests/test_dereference.py /^ author = ReferenceField(User)$/;" v class:FieldTest.test_document_reload_reference_integrity.Message +author mongoengine/tests/test_dereference.py /^ author = ReferenceField(User)$/;" v class:FieldTest.test_objectid_reference_across_databases.Book +author mongoengine/tests/test_dereference.py /^ author = ReferenceField(User, dbref=False)$/;" v class:FieldTest.test_migrate_references.Group +author mongoengine/tests/test_dereference.py /^ author = ReferenceField(User, dbref=True)$/;" v class:FieldTest.test_migrate_references.Group +author tests/fields/fields.py /^ author = EmbeddedDocumentField(Author, required=True)$/;" v class:FieldTest.test_recursive_validation.Comment +author tests/fields/fields.py /^ author = EmbeddedDocumentField(User)$/;" v class:FieldTest.test_embedded_document_inheritance.BlogPost +author tests/fields/fields.py /^ author = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.BlogPost +author tests/fields/fields.py /^ author = LazyReferenceField(Member, dbref=False)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.BlogPost +author tests/fields/fields.py /^ author = LazyReferenceField(Member, dbref=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.BlogPost +author tests/fields/fields.py /^ author = ReferenceField(Member, dbref=False)$/;" v class:FieldTest.test_reference_query_conversion.BlogPost +author tests/fields/fields.py /^ author = ReferenceField(Member, dbref=True)$/;" v class:FieldTest.test_reference_query_conversion_dbref.BlogPost +author tests/fields/fields.py /^ author = ReferenceField(User)$/;" v class:FieldTest.test_reference_validation.BlogPost +author tests/fields/fields.py /^ author = StringField()$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.Comments +author tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents.UserComments +author tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments +author tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.ModeratorComments +author tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.UserComments +author2 mongoengine/tests/queryset/queryset.py /^ author2 = GenericReferenceField()$/;" v class:QuerySetTest.test_cannot_perform_joins_references.BlogPost +authors mongoengine/tests/document/instance.py /^ authors = MapField(ReferenceField($/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Blog +authors mongoengine/tests/document/instance.py /^ authors = ListField(ReferenceField($/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify_complex_field.BlogPost +authors mongoengine/tests/fields/fields.py /^ authors = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_validation.BlogPost +authors mongoengine/tests/queryset/queryset.py /^ authors=[author])$/;" v class:QuerySetTest.test_in_operator_on_non_iterable.BlogPost +authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(EmbeddedDocumentField('Author'))$/;" v class:QuerySetTest.test_set_list_embedded_documents.Message +authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(EmbeddedDocumentField(Author))$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField.Book +authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(EmbeddedDocumentField(Author))$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Book +authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(ReferenceField(User))$/;" v class:QuerySetTest.test_in_operator_on_non_iterable.BlogPost +authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(ReferenceField(self.Person,$/;" v class:QuerySetTest.test_reverse_delete_rule_pull.BlogPost +authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(ReferenceField(self.Person,$/;" v class:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents.AbstractBlogPost +authors tests/fields/fields.py /^ authors = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_validation.BlogPost +authors_as_lazy mongoengine/tests/fields/fields.py /^ authors_as_lazy = ListField(LazyReferenceField(User))$/;" v class:FieldTest.test_list_validation.BlogPost +authors_as_lazy tests/fields/fields.py /^ authors_as_lazy = ListField(LazyReferenceField(User))$/;" v class:FieldTest.test_list_validation.BlogPost +auto_creation_counter mongoengine/mongoengine/base/fields.py /^ auto_creation_counter = -1$/;" v class:BaseField +autoclass_content mongoengine/docs/conf.py /^autoclass_content = 'both'$/;" v +average mongoengine/mongoengine/queryset/base.py /^ def average(self, field):$/;" m class:BaseQuerySet +b mongoengine/tests/document/indexes.py /^ b = IntField()$/;" v class:IndexesTest.test_covered_index.Test +b mongoengine/tests/document/inheritance.py /^ b = StringField()$/;" v class:InheritanceTest.test_indexes_and_multiple_inheritance.B +b mongoengine/tests/document/instance.py /^ b = EmbeddedDocumentField(B, default=lambda: B())$/;" v class:InstanceTest.test_mutating_documents.A +b mongoengine/tests/document/instance.py /^ b = Foo.objects.with_id(a.id)$/;" v class:InstanceTest.test_save_max_recursion_not_hit_with_file_field.Foo +b mongoengine/tests/fields/fields.py /^ b = EmbeddedDocumentField(B, db_field='fb')$/;" v class:FieldTest.test_double_embedded_db_field.A +b mongoengine/tests/fields/fields.py /^ b = EmbeddedDocumentField(B, db_field='fb')$/;" v class:FieldTest.test_double_embedded_db_field_from_son.A +b mongoengine/tests/fields/fields.py /^ b=B($/;" v class:FieldTest.test_double_embedded_db_field.A +b mongoengine/tests/queryset/field_list.py /^ b = ListField()$/;" v class:OnlyExcludeAllTest.test_mix_slice_with_other_fields.MyDoc +b mongoengine/tests/queryset/field_list.py /^ b = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc +b mongoengine/tests/queryset/field_list.py /^ b = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc +b mongoengine/tests/queryset/queryset.py /^ b = ListField(EmbeddedDocumentField(B))$/;" v class:QuerySetTest.test_count_list_embedded.A +b mongoengine/tests/queryset/transform.py /^ b = StringField()$/;" v class:TransformTest.test_raw_query_and_Q_objects.Foo +b mongoengine/tests/test_dereference.py /^ b = UserB(name='User B %s' % i)$/;" v class:FieldTest.test_dict_field.Group +b mongoengine/tests/test_dereference.py /^ b = UserB(name='User B %s' % i)$/;" v class:FieldTest.test_generic_reference.Group +b mongoengine/tests/test_dereference.py /^ b = UserB(name='User B %s' % i)$/;" v class:FieldTest.test_generic_reference_map_field.Group +b mongoengine/tests/test_dereference.py /^ b = UserB(name='User B %s' % i)$/;" v class:FieldTest.test_list_field_complex.Group +b mongoengine/tests/test_dereference.py /^ b = UserB(name='User B %s' % i).save()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group +b tests/fields/fields.py /^ b = EmbeddedDocumentField(B, db_field='fb')$/;" v class:FieldTest.test_double_embedded_db_field.A +b tests/fields/fields.py /^ b = EmbeddedDocumentField(B, db_field='fb')$/;" v class:FieldTest.test_double_embedded_db_field_from_son.A +b tests/fields/fields.py /^ b=B($/;" v class:FieldTest.test_double_embedded_db_field.A +b_name mongoengine/tests/queryset/queryset.py /^ b_name = StringField()$/;" v class:QuerySetTest.test_query_generic_embedded_document.B +bar mongoengine/tests/document/instance.py /^ bar = ReferenceField('self')$/;" v class:InstanceTest.test_save_max_recursion_not_hit_with_file_field.Foo +bar mongoengine/tests/document/instance.py /^ bar = ReferenceField(Bar)$/;" v class:InstanceTest.test_two_way_reverse_delete_rule.Foo +bar mongoengine/tests/document/instance.py /^ bar = StringField()$/;" v class:InstanceTest.test_shard_key_in_embedded_document.Bar +bar mongoengine/tests/document/instance.py /^ bar = StringField(default=None)$/;" v class:InstanceTest.test_set_unset_one_operation.FooBar +bar mongoengine/tests/queryset/queryset.py /^ bar = GenericEmbeddedDocumentField(choices=[Bar,])$/;" v class:QuerySetTest.test_set_generic_embedded_documents.User +bar mongoengine/tests/queryset/queryset.py /^ bar = ReferenceField("Bar")$/;" v class:QuerySetTest.test_distinct_handles_references.Foo +bar mongoengine/tests/queryset/queryset.py /^ bar = ReferenceField("Bar")$/;" v class:QuerySetTest.test_distinct_handles_references_to_alias.Foo +bar mongoengine/tests/queryset/queryset.py /^ bar = ReferenceField('Bar')$/;" v class:QuerySetTest.test_distinct_ListField_ReferenceField.Foo +bar mongoengine/tests/queryset/queryset.py /^ bar = StringField(default='bar')$/;" v class:QuerySetTest.test_custom_manager_overriding_objects_works.Foo +bar mongoengine/tests/test_dereference.py /^ bar = ReferenceField('Bar')$/;" v class:FieldTest.test_document_reload_no_inheritance.Foo +bar_lst mongoengine/tests/queryset/queryset.py /^ bar_lst = ListField(ReferenceField('Bar'))$/;" v class:QuerySetTest.test_distinct_ListField_ReferenceField.Foo +bars mongoengine/tests/fields/fields.py /^ bars = ListField(ReferenceField("Bar"))$/;" v class:FieldTest.test_list_field_passed_in_value.Foo +bars tests/fields/fields.py /^ bars = ListField(ReferenceField("Bar"))$/;" v class:FieldTest.test_list_field_passed_in_value.Foo +batch_size mongoengine/mongoengine/queryset/base.py /^ def batch_size(self, size):$/;" m class:BaseQuerySet +baz mongoengine/tests/test_dereference.py /^ baz = ReferenceField('Baz')$/;" v class:FieldTest.test_document_reload_no_inheritance.Foo +blob mongoengine/tests/fields/fields.py /^ blob = BinaryField()$/;" v class:FieldTest.test_binary_fields.Attachment +blob mongoengine/tests/fields/fields.py /^ blob = BinaryField()$/;" v class:FieldTest.test_binary_validation.Attachment +blob mongoengine/tests/fields/fields.py /^ blob = BinaryField(max_bytes=4)$/;" v class:FieldTest.test_binary_validation.AttachmentSizeLimit +blob mongoengine/tests/fields/fields.py /^ blob = BinaryField(required=True)$/;" v class:FieldTest.test_binary_validation.AttachmentRequired +blob mongoengine/tests/fields/fields.py /^ blob=six.b('\\xe6\\x00\\xc4\\xff\\x07'))$/;" v class:FieldTest.test_binary_validation.AttachmentSizeLimit +blob tests/fields/fields.py /^ blob = BinaryField()$/;" v class:FieldTest.test_binary_fields.Attachment +blob tests/fields/fields.py /^ blob = BinaryField()$/;" v class:FieldTest.test_binary_validation.Attachment +blob tests/fields/fields.py /^ blob = BinaryField(max_bytes=4)$/;" v class:FieldTest.test_binary_validation.AttachmentSizeLimit +blob tests/fields/fields.py /^ blob = BinaryField(required=True)$/;" v class:FieldTest.test_binary_validation.AttachmentRequired +blob tests/fields/fields.py /^ blob=six.b('\\xe6\\x00\\xc4\\xff\\x07'))$/;" v class:FieldTest.test_binary_validation.AttachmentSizeLimit +blog mongoengine/tests/queryset/queryset.py /^ blog = Blog.objects.first()$/;" v class:QuerySetTest.test_bulk_insert.Blog +blog mongoengine/tests/queryset/queryset.py /^ blog = ReferenceField(Blog)$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +blog mongoengine/tests/queryset/queryset.py /^ blog=blog_1,$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +blog mongoengine/tests/queryset/queryset.py /^ blog=blog_2,$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +blog mongoengine/tests/queryset/queryset.py /^ blog=blog_3,$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +blogs mongoengine/tests/queryset/queryset.py /^ blogs = Blog.objects$/;" v class:QuerySetTest.test_bulk_insert.Blog +blogs mongoengine/tests/queryset/queryset.py /^ blogs = []$/;" v class:QuerySetTest.test_bulk_insert.Blog +body mongoengine/tests/queryset/field_list.py /^ body = StringField()$/;" v class:OnlyExcludeAllTest.test_all_fields.Email +body mongoengine/tests/queryset/field_list.py /^ body = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email +body mongoengine/tests/test_dereference.py /^ body = StringField()$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Post +book mongoengine/tests/document/instance.py /^ book = ReferenceField(Book)$/;" v class:InstanceTest.test_db_alias_tests.AuthorBooks +bookmark_object mongoengine/tests/fields/fields.py /^ bookmark_object = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference.Bookmark +bookmark_object mongoengine/tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=('Post', Link))$/;" v class:FieldTest.test_generic_reference_string_choices.Bookmark +bookmark_object mongoengine/tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=(Post, ))$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Bookmark +bookmark_object mongoengine/tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=(Post,))$/;" v class:FieldTest.test_generic_reference_choices.Bookmark +bookmark_object tests/fields/fields.py /^ bookmark_object = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference.Bookmark +bookmark_object tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=('Post', Link))$/;" v class:FieldTest.test_generic_reference_string_choices.Bookmark +bookmark_object tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=(Post, ))$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Bookmark +bookmark_object tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=(Post,))$/;" v class:FieldTest.test_generic_reference_choices.Bookmark +bookmarks mongoengine/tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_document_not_registered.User +bookmarks mongoengine/tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_list.User +bookmarks mongoengine/tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_list_item_modification.User +bookmarks mongoengine/tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField(choices=(Post,)))$/;" v class:FieldTest.test_generic_reference_list_choices.User +bookmarks tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_document_not_registered.User +bookmarks tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_list.User +bookmarks tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_list_item_modification.User +bookmarks tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField(choices=(Post,)))$/;" v class:FieldTest.test_generic_reference_list_choices.User +bool_info mongoengine/tests/fields/fields.py /^ bool_info = ListField(BooleanField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost +bool_info tests/fields/fields.py /^ bool_info = ListField(BooleanField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost +boolean_field mongoengine/tests/document/instance.py /^ boolean_field = BooleanField(default=True)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +boolean_field mongoengine/tests/document/json_serialisation.py /^ boolean_field = BooleanField(default=True)$/;" v class:TestJson.test_json_complex.Doc +boolean_field mongoengine/tests/queryset/queryset.py /^ boolean_field = BooleanField(default=True)$/;" v class:QuerySetTest.test_json_complex.Doc +boolfield mongoengine/tests/queryset/queryset.py /^ boolfield = BooleanField(default=False)$/;" v class:QuerySetTest.test_chaining.B +boss mongoengine/tests/fields/fields.py /^ boss = ReferenceField('self')$/;" v class:FieldTest.test_recursive_reference.Employee +boss mongoengine/tests/test_dereference.py /^ boss = ReferenceField('self')$/;" v class:FieldTest.test_recursive_reference.Employee +boss tests/fields/fields.py /^ boss = ReferenceField('self')$/;" v class:FieldTest.test_recursive_reference.Employee +brands mongoengine/tests/test_dereference.py /^ brands = ListField(ReferenceField("Brand", dbref=True))$/;" v class:FieldTest.test_non_ascii_pk.BrandGroup +build_dict mongoengine/mongoengine/errors.py /^ def build_dict(source):$/;" f function:ValidationError.to_dict +build_lazyref mongoengine/fields.py /^ def build_lazyref(self, value):$/;" m class:GenericLazyReferenceField +build_lazyref mongoengine/fields.py /^ def build_lazyref(self, value):$/;" m class:LazyReferenceField +build_lazyref mongoengine/mongoengine/fields.py /^ def build_lazyref(self, value):$/;" m class:GenericLazyReferenceField +build_lazyref mongoengine/mongoengine/fields.py /^ def build_lazyref(self, value):$/;" m class:LazyReferenceField +bulk_create_author mongoengine/tests/test_signals.py /^ def bulk_create_author():$/;" f function:SignalTests.test_signal_kwargs +bulk_create_author_with_load mongoengine/tests/test_signals.py /^ def bulk_create_author_with_load():$/;" f function:SignalTests.test_model_signals +bulk_create_author_without_load mongoengine/tests/test_signals.py /^ def bulk_create_author_without_load():$/;" f function:SignalTests.test_model_signals +bulk_set_active_post mongoengine/tests/test_signals.py /^ def bulk_set_active_post():$/;" f function:SignalTests.test_signals_bulk_insert +by mongoengine/tests/queryset/queryset.py /^ by = StringField()$/;" v class:QuerySetTest.test_update_using_positional_operator.Comment +by mongoengine/tests/queryset/queryset.py /^ by = StringField()$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.Comment +c mongoengine/tests/document/indexes.py /^ c = StringField()$/;" v class:IndexesTest.test_index_no_cls.B +c mongoengine/tests/fields/fields.py /^ c=C(txt='hi')$/;" v class:FieldTest.test_double_embedded_db_field.A +c mongoengine/tests/fields/fields.py /^ c = EmbeddedDocumentField(C, db_field='fc')$/;" v class:FieldTest.test_double_embedded_db_field.B +c mongoengine/tests/fields/fields.py /^ c = EmbeddedDocumentField(C, db_field='fc')$/;" v class:FieldTest.test_double_embedded_db_field_from_son.B +c mongoengine/tests/queryset/field_list.py /^ c = ListField()$/;" v class:OnlyExcludeAllTest.test_mix_slice_with_other_fields.MyDoc +c mongoengine/tests/queryset/field_list.py /^ c = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc +c mongoengine/tests/queryset/field_list.py /^ c = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc +c mongoengine/tests/queryset/queryset.py /^ c = StringField()$/;" v class:QuerySetTest.test_count_list_embedded.B +c mongoengine/tests/queryset/transform.py /^ c = StringField()$/;" v class:TransformTest.test_raw_query_and_Q_objects.Foo +c mongoengine/tests/test_dereference.py /^ c = UserC(name='User C %s' % i)$/;" v class:FieldTest.test_dict_field.Group +c mongoengine/tests/test_dereference.py /^ c = UserC(name='User C %s' % i)$/;" v class:FieldTest.test_generic_reference.Group +c mongoengine/tests/test_dereference.py /^ c = UserC(name='User C %s' % i)$/;" v class:FieldTest.test_generic_reference_map_field.Group +c mongoengine/tests/test_dereference.py /^ c = UserC(name='User C %s' % i)$/;" v class:FieldTest.test_list_field_complex.Group +c mongoengine/tests/test_dereference.py /^ c = UserC(name='User C %s' % i).save()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group +c tests/fields/fields.py /^ c=C(txt='hi')$/;" v class:FieldTest.test_double_embedded_db_field.A +c tests/fields/fields.py /^ c = EmbeddedDocumentField(C, db_field='fc')$/;" v class:FieldTest.test_double_embedded_db_field.B +c tests/fields/fields.py /^ c = EmbeddedDocumentField(C, db_field='fc')$/;" v class:FieldTest.test_double_embedded_db_field_from_son.B +c_field mongoengine/tests/document/instance.py /^ c_field = StringField(default='cfield')$/;" v class:InstanceTest.test_mutating_documents.C +c_field mongoengine/tests/fields/fields.py /^ c_field = IntField(custom_data=custom_data)$/;" v class:EmbeddedDocumentListFieldTestCase.test_custom_data.CustomData +c_field tests/fields/fields.py /^ c_field = IntField(custom_data=custom_data)$/;" v class:EmbeddedDocumentListFieldTestCase.test_custom_data.CustomData +cache mongoengine/mongoengine/queryset/queryset.py /^ def cache(self):$/;" m class:QuerySetNoCache +cascade_save mongoengine/mongoengine/document.py /^ def cascade_save(self, **kwargs):$/;" m class:Document +cat mongoengine/tests/queryset/queryset.py /^ cat = ReferenceField(Category, reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_complex_cycle.Dummy +categories mongoengine/tests/document/indexes.py /^ categories = ListField()$/;" v class:IndexesTest.test_index_on_id.BlogPost +categories mongoengine/tests/fields/fields.py /^ categories = SortedListField(EmbeddedDocumentField(Category),$/;" v class:FieldTest.test_reverse_list_sorting.CategoryList +categories tests/fields/fields.py /^ categories = SortedListField(EmbeddedDocumentField(Category),$/;" v class:FieldTest.test_reverse_list_sorting.CategoryList +category mongoengine/tests/document/indexes.py /^ category = StringField()$/;" v class:IndexesTest._index_test.BlogPost +category mongoengine/tests/document/indexes.py /^ category = StringField()$/;" v class:IndexesTest._index_test_inheritance.BlogPost +category mongoengine/tests/document/indexes.py /^ category = StringField()$/;" v class:IndexesTest.test_dictionary_indexes.BlogPost +category mongoengine/tests/queryset/queryset.py /^ category = ReferenceField(Category, reverse_delete_rule=NULLIFY)$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify.BlogPost +cdt_f mongoengine/tests/queryset/queryset.py /^ cdt_f = ComplexDateTimeField()$/;" v class:QuerySetTest.test_update_validate.Doc +cdt_fld mongoengine/tests/document/instance.py /^ cdt_fld = ComplexDateTimeField(null=True)$/;" v class:InstanceTest.test_null_field.User +ceo mongoengine/tests/queryset/queryset.py /^ ceo = ReferenceField(User)$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Organization +check_fields_type mongoengine/tests/fields/fields.py /^ def check_fields_type(occ):$/;" f function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded +check_fields_type mongoengine/tests/fields/fields.py /^ def check_fields_type(occ):$/;" f function:LazyReferenceFieldTest.test_lazy_reference_embedded +check_fields_type tests/fields/fields.py /^ def check_fields_type(occ):$/;" f function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded +check_fields_type tests/fields/fields.py /^ def check_fields_type(occ):$/;" f function:LazyReferenceFieldTest.test_lazy_reference_embedded +child mongoengine/tests/queryset/queryset.py /^ child = Category(name=child_name, parent=base)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category +child_child mongoengine/tests/queryset/queryset.py /^ child_child = Category(name=child_child_name, parent=child)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category +child_child_name mongoengine/tests/queryset/queryset.py /^ child_child_name = 'Child-Child-%i' % i$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category +child_name mongoengine/tests/queryset/queryset.py /^ child_name = 'Child-%i' % i$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category +children mongoengine/tests/document/instance.py /^ children = ListField(ReferenceField('self', reverse_delete_rule=PULL))$/;" v class:InstanceTest.test_reverse_delete_rule_pull.Record +children mongoengine/tests/fields/fields.py /^ children = ListField(EmbeddedDocumentField('TreeNode'))$/;" v class:FieldTest.test_recursive_embedding.Tree +children mongoengine/tests/fields/fields.py /^ children = ListField(EmbeddedDocumentField('self'))$/;" v class:FieldTest.test_recursive_embedding.TreeNode +children mongoengine/tests/test_dereference.py /^ children = ListField(GenericReferenceField())$/;" v class:FieldTest.test_multidirectional_lists.Asset +children tests/fields/fields.py /^ children = ListField(EmbeddedDocumentField('TreeNode'))$/;" v class:FieldTest.test_recursive_embedding.Tree +children tests/fields/fields.py /^ children = ListField(EmbeddedDocumentField('self'))$/;" v class:FieldTest.test_recursive_embedding.TreeNode +choices mongoengine/tests/fields/fields.py /^ choices=('Small', 'Baggy', 'wide'),$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt +choices mongoengine/tests/fields/fields.py /^ choices=('S', 'M', 'L', 'XL', 'XXL'))$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt +choices mongoengine/tests/fields/fields.py /^ choices=('S', 'M', 'L', 'XL', 'XXL'))$/;" v class:FieldTest.test_simple_choices_validation.Shirt +choices mongoengine/tests/fields/fields.py /^ choices=TPS)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +choices mongoengine/tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person +choices mongoengine/tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone +choices mongoengine/tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person +choices mongoengine/tests/queryset/queryset.py /^ choices=[Foo, ]))$/;" v class:QuerySetTest.test_pull_in_genericembedded_field.Bar +choices tests/fields/fields.py /^ choices=('Small', 'Baggy', 'wide'),$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt +choices tests/fields/fields.py /^ choices=('S', 'M', 'L', 'XL', 'XXL'))$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt +choices tests/fields/fields.py /^ choices=('S', 'M', 'L', 'XL', 'XXL'))$/;" v class:FieldTest.test_simple_choices_validation.Shirt +choices tests/fields/fields.py /^ choices=TPS)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +choices tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person +choices tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone +choices tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person +circular_reference_deltas mongoengine/tests/document/delta.py /^ def circular_reference_deltas(self, DocClass1, DocClass2):$/;" m class:DeltaTest +circular_reference_deltas_2 mongoengine/tests/document/delta.py /^ def circular_reference_deltas_2(self, DocClass1, DocClass2, dbref=True):$/;" m class:DeltaTest +city mongoengine/tests/document/dynamic.py /^ city = StringField()$/;" v class:DynamicTest.test_dynamic_and_embedded.Address +city mongoengine/tests/document/dynamic.py /^ city = StringField()$/;" v class:DynamicTest.test_dynamic_and_embedded_dict_access.Address +city mongoengine/tests/document/dynamic.py /^ city = StringField()$/;" v class:DynamicTest.test_dynamic_embedded_works_with_only.Address +city mongoengine/tests/fields/fields.py /^ city = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_is_none.Person +city mongoengine/tests/queryset/queryset.py /^ city = StringField()$/;" v class:QuerySetTest.test_item_frequencies_null_values.Person +city mongoengine/tests/queryset/queryset.py /^ city = StringField()$/;" v class:QuerySetTest.test_scalar_embedded.Locale +city tests/fields/fields.py /^ city = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_is_none.Person +city_id mongoengine/tests/document/inheritance.py /^ city_id = IntField(primary_key=True)$/;" v class:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class.City +clean mongoengine/mongoengine/base/document.py /^ def clean(self):$/;" m class:BaseDocument +clean mongoengine/tests/document/instance.py /^ def clean(self):$/;" m class:InstanceTest.test_document_clean.TestDocument +clean mongoengine/tests/document/instance.py /^ def clean(self):$/;" m class:InstanceTest.test_document_embedded_clean.TestEmbeddedDocument +clear mongoengine/mongoengine/base/datastructures.py /^ def clear(self, *args, **kwargs):$/;" m class:BaseDict +clone mongoengine/mongoengine/queryset/base.py /^ def clone(self):$/;" m class:BaseQuerySet +close mongoengine/fields.py /^ def close(self):$/;" m class:GridFSProxy +close mongoengine/mongoengine/fields.py /^ def close(self):$/;" m class:GridFSProxy +collaborators mongoengine/tests/queryset/queryset.py /^ collaborators = EmbeddedDocumentField(Collaborator)$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Site +collaborators mongoengine/tests/queryset/queryset.py /^ collaborators = ListField(EmbeddedDocumentField(Collaborator))$/;" v class:QuerySetTest.test_pull_nested.Site +collaborators mongoengine/tests/queryset/queryset.py /^ collaborators = MapField($/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Site +collection_name mongoengine/tests/fields/file_tests.py /^ collection_name="macumba")$/;" v class:FileTest.test_file_multidb.TestFile +color mongoengine/tests/fields/fields.py /^ color = StringField(max_length=1, choices=COLORS)$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt +color mongoengine/tests/queryset/queryset.py /^ color = StringField()$/;" v class:QuerySetTest.test_elem_match.Foo +color tests/fields/fields.py /^ color = StringField(max_length=1, choices=COLORS)$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt +comment mongoengine/mongoengine/queryset/base.py /^ def comment(self, text):$/;" m class:BaseQuerySet +comment mongoengine/tests/document/instance.py /^ comment = StringField()$/;" v class:InstanceTest.test_list_search_by_embedded.Comment +comment mongoengine/tests/document/instance.py /^ comment = StringField()$/;" v class:InstanceTest.test_mixin_inheritance.DoubleMixIn +comment mongoengine/tests/queryset/queryset.py /^ comment = ReferenceField(Comment)$/;" v class:QuerySetTest.test_unset_reference.Post +comment1 mongoengine/tests/queryset/queryset.py /^ comment1 = Comment(name='testa')$/;" v class:QuerySetTest.test_bulk_insert.Blog +comment2 mongoengine/tests/queryset/queryset.py /^ comment2 = Comment(name='testb')$/;" v class:QuerySetTest.test_bulk_insert.Blog +comment_id mongoengine/tests/document/indexes.py /^ comment_id = IntField(required=True)$/;" v class:IndexesTest.test_index_with_pk.Comment +comments mongoengine/docs/code/tumblelog.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:Post +comments mongoengine/tests/document/indexes.py /^ comments = EmbeddedDocumentField(Comment)$/;" v class:IndexesTest.test_index_with_pk.Comment.BlogPost +comments mongoengine/tests/document/instance.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:InstanceTest.test_list_search_by_embedded.Page +comments mongoengine/tests/document/instance.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:InstanceTest.test_save_list.BlogPost +comments mongoengine/tests/document/instance.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:InstanceTest.test_save_only_changed_fields_recursive.User +comments mongoengine/tests/fields/fields.py /^ comments=[Comment(content="NoSQL Rocks"),$/;" v class:FieldTest.test_embedded_sequence_field.Post +comments mongoengine/tests/fields/fields.py /^ comments = EmbeddedDocumentListField(Comments)$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.BlogPost +comments mongoengine/tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents.BlogPost +comments mongoengine/tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents_inheritance.BlogPost +comments mongoengine/tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents_invalid.BlogPost +comments mongoengine/tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_embedded_sequence_field.Post +comments mongoengine/tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_list_validation.BlogPost +comments mongoengine/tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_recursive_validation.Post +comments mongoengine/tests/fields/fields.py /^ comments = SortedListField(EmbeddedDocumentField(Comment),$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost +comments mongoengine/tests/queryset/field_list.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:OnlyExcludeAllTest.test_exclude.BlogPost +comments mongoengine/tests/queryset/field_list.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.BlogPost +comments mongoengine/tests/queryset/queryset.py /^ comments=[comm1, comm2]).save()$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Post +comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField("Comment"))$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Post +comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:QuerySetTest.test_bulk_insert.Post +comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:QuerySetTest.test_find_array_position.Post +comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:QuerySetTest.test_update_array_position.Post +comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:QuerySetTest.test_update_using_positional_operator.BlogPost +comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.BlogPost +comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment),$/;" v class:QuerySetTest.test_exec_js_field_sub.BlogPost +comments mongoengine/tests/queryset/transform.py /^ comments = ListField(EmbeddedDocumentField(Comment),$/;" v class:TransformTest.test_query_field_name.BlogPost +comments mongoengine/tests/test_dereference.py /^ comments = ListField(ReferenceField(Comment))$/;" v class:FieldTest.test_list_lookup_not_checked_in_map.Message +comments tests/fields/fields.py /^ comments=[Comment(content="NoSQL Rocks"),$/;" v class:FieldTest.test_embedded_sequence_field.Post +comments tests/fields/fields.py /^ comments = EmbeddedDocumentListField(Comments)$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.BlogPost +comments tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents.BlogPost +comments tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents_inheritance.BlogPost +comments tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents_invalid.BlogPost +comments tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_embedded_sequence_field.Post +comments tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_list_validation.BlogPost +comments tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_recursive_validation.Post +comments tests/fields/fields.py /^ comments = SortedListField(EmbeddedDocumentField(Comment),$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost +comments_dict mongoengine/tests/document/instance.py /^ comments_dict = DictField()$/;" v class:InstanceTest.test_save_only_changed_fields_recursive.User +comp_dt_fld mongoengine/tests/fields/fields.py /^ comp_dt_fld = ComplexDateTimeField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +comp_dt_fld mongoengine/tests/fields/fields.py /^ comp_dt_fld = ComplexDateTimeField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields +comp_dt_fld tests/fields/fields.py /^ comp_dt_fld = ComplexDateTimeField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +comp_dt_fld tests/fields/fields.py /^ comp_dt_fld = ComplexDateTimeField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields +company mongoengine/tests/fields/fields.py /^ company = ReferenceField('Company')$/;" v class:FieldTest.test_undefined_reference.Product +company tests/fields/fields.py /^ company = ReferenceField('Company')$/;" v class:FieldTest.test_undefined_reference.Product +compare_indexes mongoengine/mongoengine/document.py /^ def compare_indexes(cls):$/;" m class:Document +complex_datetime_field mongoengine/tests/document/instance.py /^ complex_datetime_field = ComplexDateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +complex_datetime_field mongoengine/tests/document/json_serialisation.py /^ complex_datetime_field = ComplexDateTimeField(default=datetime.now)$/;" v class:TestJson.test_json_complex.Doc +complex_datetime_field mongoengine/tests/queryset/queryset.py /^ complex_datetime_field = ComplexDateTimeField(default=datetime.datetime.now)$/;" v class:QuerySetTest.test_json_complex.Doc +connect mongoengine/mongoengine/connection.py /^def connect(db=None, alias=DEFAULT_CONNECTION_NAME, **kwargs):$/;" f +content mongoengine/docs/code/tumblelog.py /^ content = StringField()$/;" v class:Comment +content mongoengine/docs/code/tumblelog.py /^ content = StringField()$/;" v class:TextPost +content mongoengine/tests/document/dynamic.py /^ content = URLField()$/;" v class:DynamicTest.test_complex_embedded_document_validation.Embedded +content mongoengine/tests/document/inheritance.py /^ content = StringField()$/;" v class:InheritanceTest.test_allow_inheritance_embedded_document.Comment +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Blog +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_embedded_document.Comment +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify.BlogPost +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify_complex_field.BlogPost +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_recurs.BlogPost +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal.BlogPost +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_deny.BlogPost +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_with_document_inheritance.BlogPost +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_save_list.BlogPost +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_save_list.Comment +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_save_reference.BlogPost +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_two_way_reverse_delete_rule.Bar +content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_two_way_reverse_delete_rule.Foo +content mongoengine/tests/document/validation.py /^ content = StringField(required=True)$/;" v class:ValidatorErrorTest.test_embedded_document_validation.Comment +content mongoengine/tests/fields/fields.py /^ content = ListField(StringField())$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Group +content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance.BlogPost +content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_embedded_document_validation.Comment +content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_list_validation.BlogPost +content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_list_validation.Comment +content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_reference_validation.BlogPost +content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost +content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_sorted_list_sorting.Comment +content mongoengine/tests/fields/fields.py /^ content = StringField(required=True)$/;" v class:FieldTest.test_embedded_sequence_field.Comment +content mongoengine/tests/fields/fields.py /^ content = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Comment +content mongoengine/tests/queryset/field_list.py /^ content = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude.BlogPost +content mongoengine/tests/queryset/field_list.py /^ content = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Attachment +content mongoengine/tests/queryset/field_list.py /^ content = StringField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content="Com o brasil nas quartas de finais teremos um "$/;" v class:QuerySetTest.test_text_indexes.News +content mongoengine/tests/queryset/queryset.py /^ content="O Brasil sofre com a perda de Neymar").save()$/;" v class:QuerySetTest.test_text_indexes.News +content mongoengine/tests/queryset/queryset.py /^ content=u"A candidata dilma roussef já começa o teu planejamento",$/;" v class:QuerySetTest.test_text_indexes.News +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_delete_with_limit_handles_delete_rules.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_find_embedded.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_find_empty_embedded.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_in_operator_on_non_iterable.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reference_field_find.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reference_field_find_dbref.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_on_abstract_document.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_deny.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_deny_on_abstract_document.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify_on_abstract_document.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_pull.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents.BlogPost +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_text_indexes.News +content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Comment +content mongoengine/tests/queryset/queryset.py /^ content = StringField(db_field='body')$/;" v class:QuerySetTest.test_exec_js_field_sub.Comment +content mongoengine/tests/queryset/queryset.py /^ content='Had a good coffee today...'$/;" v class:QuerySetTest.test_find_embedded.BlogPost +content mongoengine/tests/queryset/transform.py /^ content = StringField(db_field='commentContent')$/;" v class:TransformTest.test_query_field_name.Comment +content mongoengine/tests/test_signals.py /^ content = StringField()$/;" v class:SignalTests.setUp.Post +content tests/fields/fields.py /^ content = ListField(StringField())$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Group +content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance.BlogPost +content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_embedded_document_validation.Comment +content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_list_validation.BlogPost +content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_list_validation.Comment +content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_reference_validation.BlogPost +content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost +content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_sorted_list_sorting.Comment +content tests/fields/fields.py /^ content = StringField(required=True)$/;" v class:FieldTest.test_embedded_sequence_field.Comment +content tests/fields/fields.py /^ content = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Comment +content_type mongoengine/tests/fields/fields.py /^ content_type = StringField()$/;" v class:FieldTest.test_binary_fields.Attachment +content_type mongoengine/tests/queryset/field_list.py /^ content_type = StringField()$/;" v class:OnlyExcludeAllTest.test_all_fields.Email +content_type mongoengine/tests/queryset/field_list.py /^ content_type = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email +content_type tests/fields/fields.py /^ content_type = StringField()$/;" v class:FieldTest.test_binary_fields.Attachment +continent mongoengine/tests/document/inheritance.py /^ continent = StringField()$/;" v class:InheritanceTest.test_abstract_document_creation_does_not_fail.City +continent mongoengine/tests/document/inheritance.py /^ continent = StringField()$/;" v class:InheritanceTest.test_abstract_handle_ids_in_metaclass_properly.City +continent mongoengine/tests/document/inheritance.py /^ continent = StringField()$/;" v class:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class.City +continent mongoengine/tests/document/inheritance.py /^ continent = StringField()$/;" v class:InheritanceTest.test_auto_id_vs_non_pk_id_field.City +continent mongoengine/tests/queryset/queryset.py /^ continent = EmbeddedDocumentField(Continent)$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Country +continent_name mongoengine/tests/queryset/queryset.py /^ continent_name = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Continent +copyright mongoengine/docs/conf.py /^copyright = u'2009, MongoEngine Authors'$/;" v +count mongoengine/mongoengine/base/datastructures.py /^ def count(self):$/;" m class:EmbeddedDocumentList +count mongoengine/mongoengine/queryset/base.py /^ def count(self, with_limit_and_skip=False):$/;" m class:BaseQuerySet +count mongoengine/mongoengine/queryset/queryset.py /^ def count(self, with_limit_and_skip=False):$/;" m class:QuerySet +count mongoengine/tests/document/instance.py /^ count = IntField()$/;" v class:InstanceTest.test_mixin_inheritance.BaseMixIn +count mongoengine/tests/document/instance.py /^ count = IntField()$/;" v class:InstanceTest.test_save_to_a_value_that_equates_to_false.Thing +count mongoengine/tests/document/instance.py /^ count = IntField(default=0)$/;" v class:InstanceTest.test_save_atomicity_condition.Widget +count mongoengine/tests/document/instance.py /^ count = IntField(default=1)$/;" v class:InstanceTest.test_invalid_son.Word +count mongoengine/tests/fields/fields.py /^ count = IntField()$/;" v class:FieldTest.test_reverse_list_sorting.Category +count tests/fields/fields.py /^ count = IntField()$/;" v class:FieldTest.test_reverse_list_sorting.Category +counter mongoengine/tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_inherited_sequencefield.Base +counter mongoengine/tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_multiple_sequence_fields.Person +counter mongoengine/tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Bar +counter mongoengine/tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Foo +counter mongoengine/tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_sequence_fields_reload.Animal +counter tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_inherited_sequencefield.Base +counter tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_multiple_sequence_fields.Person +counter tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Bar +counter tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Foo +counter tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_sequence_fields_reload.Animal +country mongoengine/tests/queryset/queryset.py /^ country = EmbeddedDocumentField(Country)$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Author +country mongoengine/tests/queryset/queryset.py /^ country = StringField()$/;" v class:QuerySetTest.test_scalar_embedded.Locale +country_name mongoengine/tests/queryset/queryset.py /^ country_name = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Country +create mongoengine/mongoengine/base/datastructures.py /^ def create(cls, allowed_keys):$/;" m class:StrictDict +create mongoengine/mongoengine/base/datastructures.py /^ def create(self, **values):$/;" m class:EmbeddedDocumentList +create mongoengine/mongoengine/queryset/base.py /^ def create(self, **kwargs):$/;" m class:BaseQuerySet +create_author mongoengine/tests/test_signals.py /^ def create_author():$/;" f function:SignalTests.test_model_signals +create_index mongoengine/mongoengine/document.py /^ def create_index(cls, keys, background=False, **kwargs):$/;" m class:Document +created mongoengine/tests/document/indexes.py /^ created = DateTimeField(default=datetime.now)$/;" v class:IndexesTest.test_ttl_indexes.Log +created mongoengine/tests/document/instance.py /^ created = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_reference_inheritance.Stats +created mongoengine/tests/fields/fields.py /^ created=datetime.datetime(2014, 6, 12))$/;" v class:FieldTest.test_default_values_when_deleting_value.Person +created mongoengine/tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_nothing_set.Person +created mongoengine/tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_set_to_None.Person +created mongoengine/tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person +created mongoengine/tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person +created tests/fields/fields.py /^ created=datetime.datetime(2014, 6, 12))$/;" v class:FieldTest.test_default_values_when_deleting_value.Person +created tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_nothing_set.Person +created tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_set_to_None.Person +created tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person +created tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person +created_on mongoengine/tests/document/instance.py /^ created_on = DateTimeField(default=lambda: datetime.utcnow())$/;" v class:InstanceTest.test_default_values.Person +created_user mongoengine/tests/queryset/visitor.py /^ created_user = ReferenceField(User)$/;" v class:QTest.test_q_with_dbref.Post +creation_counter mongoengine/mongoengine/base/fields.py /^ creation_counter = 0$/;" v class:BaseField +current mongoengine/tests/document/indexes.py /^ current = DictField(field=EmbeddedDocumentField('EmbeddedLocation'))$/;" v class:IndexesTest.test_explicit_geo2d_index_embedded.Place +cursor_args_fields mongoengine/tests/queryset/queryset.py /^ cursor_args_fields = cursor_args['fields']$/;" v class:QuerySetTest.test_text_indexes.News +cursor_args_fields mongoengine/tests/queryset/queryset.py /^ cursor_args_fields = cursor_args['projection']$/;" v class:QuerySetTest.test_text_indexes.News +cust_id mongoengine/tests/document/indexes.py /^ cust_id = IntField(unique=True, required=True)$/;" v class:IndexesTest.test_unique_and_indexes.Customer +custom mongoengine/tests/document/class_methods.py /^ custom = DictField()$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPostWithCustomField +d mongoengine/tests/document/indexes.py /^ d = StringField()$/;" v class:IndexesTest.test_index_no_cls.B +d mongoengine/tests/fields/fields.py /^ d = datetime.datetime(i, 1, 1, 0, 0, 1)$/;" v class:FieldTest.test_datetime_usage.LogEntry +d mongoengine/tests/fields/fields.py /^ d = datetime.datetime(i, 1, 1, 0, 0, 1, 999)$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +d mongoengine/tests/queryset/field_list.py /^ d = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc +d mongoengine/tests/queryset/field_list.py /^ d = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc +d tests/fields/fields.py /^ d = datetime.datetime(i, 1, 1, 0, 0, 1)$/;" v class:FieldTest.test_datetime_usage.LogEntry +d tests/fields/fields.py /^ d = datetime.datetime(i, 1, 1, 0, 0, 1, 999)$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +d1 mongoengine/tests/fields/fields.py /^ d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999)$/;" v class:FieldTest.test_datetime.LogEntry +d1 mongoengine/tests/fields/fields.py /^ d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, i)$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry +d1 tests/fields/fields.py /^ d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999)$/;" v class:FieldTest.test_datetime.LogEntry +d1 tests/fields/fields.py /^ d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, i)$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry +d2 mongoengine/tests/fields/fields.py /^ d2 = datetime.datetime(1969, 12, 31, 23, 59, 59)$/;" v class:FieldTest.test_datetime.LogEntry +d2 tests/fields/fields.py /^ d2 = datetime.datetime(1969, 12, 31, 23, 59, 59)$/;" v class:FieldTest.test_datetime.LogEntry +data mongoengine/tests/document/instance.py /^ data = StringField()$/;" v class:InstanceTest.test_mixin_inheritance.BaseMixIn +data mongoengine/tests/fields/fields.py /^ data = DictField()$/;" v class:FieldTest.test_ensure_unique_default_instances.D +data mongoengine/tests/queryset/queryset.py /^ data = EmbeddedDocumentField(Data, required=True)$/;" v class:QuerySetTest.test_item_frequencies_with_null_embedded.Person +data tests/fields/fields.py /^ data = DictField()$/;" v class:FieldTest.test_ensure_unique_default_instances.D +data2 mongoengine/tests/fields/fields.py /^ data2 = DictField(default=lambda: {})$/;" v class:FieldTest.test_ensure_unique_default_instances.D +data2 tests/fields/fields.py /^ data2 = DictField(default=lambda: {})$/;" v class:FieldTest.test_ensure_unique_default_instances.D +date mongoengine/tests/document/indexes.py /^ date = DateTimeField(db_field='addDate', default=datetime.now)$/;" v class:IndexesTest._index_test.BlogPost +date mongoengine/tests/document/indexes.py /^ date = DateTimeField(db_field='addDate', default=datetime.now)$/;" v class:IndexesTest._index_test_inheritance.BlogPost +date mongoengine/tests/document/indexes.py /^ date = DateTimeField(db_field='addDate', default=datetime.now)$/;" v class:IndexesTest.test_dictionary_indexes.BlogPost +date mongoengine/tests/document/indexes.py /^ date = EmbeddedDocumentField(Date)$/;" v class:IndexesTest.test_embedded_document_index.BlogPost +date mongoengine/tests/document/indexes.py /^ date = EmbeddedDocumentField(Date)$/;" v class:IndexesTest.test_unique_with.BlogPost +date mongoengine/tests/document/instance.py /^ date = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_capped_collection.Log +date mongoengine/tests/document/instance.py /^ date = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_capped_collection_default.Log +date mongoengine/tests/document/instance.py /^ date = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_capped_collection_no_max_size_problems.Log +date mongoengine/tests/document/validation.py /^ date = DateTimeField()$/;" v class:ValidatorErrorTest.test_embedded_document_validation.Comment +date mongoengine/tests/fields/fields.py /^ date=datetime.datetime(2015, 1, 1, 0, 0, 0, microsecond)$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +date mongoengine/tests/fields/fields.py /^ date = ComplexDateTimeField()$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry +date mongoengine/tests/fields/fields.py /^ date = ComplexDateTimeField()$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +date mongoengine/tests/fields/fields.py /^ date = DateTimeField()$/;" v class:FieldTest.test_datetime.LogEntry +date mongoengine/tests/fields/fields.py /^ date = DateTimeField()$/;" v class:FieldTest.test_datetime_usage.LogEntry +date mongoengine/tests/fixtures.py /^ date = DateTimeField(default=datetime.now)$/;" v class:PickleDynamicEmbedded +date mongoengine/tests/fixtures.py /^ date = DateTimeField(default=datetime.now)$/;" v class:PickleEmbedded +date mongoengine/tests/queryset/geo.py /^ date = DateTimeField()$/;" v class:GeoQueriesTest._create_event_data.Event +date mongoengine/tests/queryset/geo.py /^ date=datetime.datetime.now() - datetime.timedelta(days=1),$/;" v class:GeoQueriesTest._create_event_data.Event +date mongoengine/tests/queryset/geo.py /^ date=datetime.datetime.now() - datetime.timedelta(days=10),$/;" v class:GeoQueriesTest._create_event_data.Event +date mongoengine/tests/queryset/geo.py /^ date=datetime.datetime.now(),$/;" v class:GeoQueriesTest._create_event_data.Event +date mongoengine/tests/queryset/queryset.py /^ date = DateTimeField(default=datetime.datetime.now)$/;" v class:QuerySetTest.test_custom_manager.BlogPost +date tests/fields/fields.py /^ date=datetime.datetime(2015, 1, 1, 0, 0, 0, microsecond)$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +date tests/fields/fields.py /^ date = ComplexDateTimeField()$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry +date tests/fields/fields.py /^ date = ComplexDateTimeField()$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +date tests/fields/fields.py /^ date = DateTimeField()$/;" v class:FieldTest.test_datetime.LogEntry +date tests/fields/fields.py /^ date = DateTimeField()$/;" v class:FieldTest.test_datetime_usage.LogEntry +date__gte mongoengine/tests/fields/fields.py /^ date__gte=datetime.datetime(1975, 1, 1),$/;" v class:FieldTest.test_datetime_usage.LogEntry +date__gte mongoengine/tests/fields/fields.py /^ date__gte=datetime.datetime(2000, 1, 1),$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +date__gte tests/fields/fields.py /^ date__gte=datetime.datetime(1975, 1, 1),$/;" v class:FieldTest.test_datetime_usage.LogEntry +date__gte tests/fields/fields.py /^ date__gte=datetime.datetime(2000, 1, 1),$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +date__lte mongoengine/tests/fields/fields.py /^ date__lte=datetime.datetime(1980, 1, 1),$/;" v class:FieldTest.test_datetime_usage.LogEntry +date__lte mongoengine/tests/fields/fields.py /^ date__lte=datetime.datetime(2011, 1, 1),$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +date__lte mongoengine/tests/fields/fields.py /^ date__lte=datetime.datetime(2015, 1, 1, 0, 0, 0, 10000))$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +date__lte tests/fields/fields.py /^ date__lte=datetime.datetime(1980, 1, 1),$/;" v class:FieldTest.test_datetime_usage.LogEntry +date__lte tests/fields/fields.py /^ date__lte=datetime.datetime(2011, 1, 1),$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +date__lte tests/fields/fields.py /^ date__lte=datetime.datetime(2015, 1, 1, 0, 0, 0, 10000))$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +date_with_dots mongoengine/tests/fields/fields.py /^ date_with_dots = ComplexDateTimeField(separator='.')$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry +date_with_dots tests/fields/fields.py /^ date_with_dots = ComplexDateTimeField(separator='.')$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry +datetime mongoengine/tests/fields/geo.py /^ datetime = DateTimeField()$/;" v class:GeoFieldTest.test_geo_indexes_auto_index.Log +datetime_field mongoengine/tests/document/instance.py /^ datetime_field = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +datetime_field mongoengine/tests/document/json_serialisation.py /^ datetime_field = DateTimeField(default=datetime.now)$/;" v class:TestJson.test_json_complex.Doc +datetime_field mongoengine/tests/queryset/queryset.py /^ datetime_field = DateTimeField(default=datetime.datetime.now)$/;" v class:QuerySetTest.test_json_complex.Doc +dateutil mongoengine/fields.py /^ dateutil = None$/;" v +dateutil mongoengine/mongoengine/fields.py /^ dateutil = None$/;" v +dateutil mongoengine/tests/fields/fields.py /^ dateutil = None$/;" v +dateutil tests/fields/fields.py /^ dateutil = None$/;" v +db_field mongoengine/tests/document/delta.py /^ db_field='db_embedded_field')$/;" v class:DeltaTest.delta_recursive_db_field.Doc +db_field mongoengine/tests/document/instance.py /^ db_field='rank')$/;" v class:InstanceTest.test_db_embedded_doc_field_load.Person +db_field mongoengine/tests/document/instance.py /^ db_field="page_log_message",$/;" v class:InstanceTest.test_embedded_update_db_field.Page +db_field mongoengine/tests/fields/fields.py /^ db_field='x')$/;" v class:FieldTest.test_embedded_mapfield_db_field.Test +db_field mongoengine/tests/fields/fields.py /^ db_field="t",$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +db_field mongoengine/tests/queryset/queryset.py /^ db_field='cmnts')$/;" v class:QuerySetTest.test_exec_js_field_sub.BlogPost +db_field mongoengine/tests/queryset/transform.py /^ db_field='postComments')$/;" v class:TransformTest.test_query_field_name.BlogPost +db_field tests/fields/fields.py /^ db_field='x')$/;" v class:FieldTest.test_embedded_mapfield_db_field.Test +db_field tests/fields/fields.py /^ db_field="t",$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +db_ops_tracker mongoengine/tests/queryset/queryset.py /^class db_ops_tracker(query_counter):$/;" c +decimal_field mongoengine/tests/document/instance.py /^ decimal_field = DecimalField(default=1.0)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +decimal_field mongoengine/tests/document/json_serialisation.py /^ decimal_field = DecimalField(default=1.0)$/;" v class:TestJson.test_json_complex.Doc +decimal_field mongoengine/tests/queryset/queryset.py /^ decimal_field = DecimalField(default=1.0)$/;" v class:QuerySetTest.test_json_complex.Doc +default mongoengine/mongoengine/queryset/manager.py /^ default = QuerySet$/;" v class:QuerySetManager +default mongoengine/tests/document/instance.py /^ default=lambda: [1, 2, 3])$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +default mongoengine/tests/document/instance.py /^ default=lambda: EmbeddedDoc())$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +default mongoengine/tests/document/instance.py /^ default=lambda: Simple().save())$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +default mongoengine/tests/document/json_serialisation.py /^ default=lambda: [1, 2, 3])$/;" v class:TestJson.test_json_complex.Doc +default mongoengine/tests/document/json_serialisation.py /^ default=lambda: Simple().save())$/;" v class:TestJson.test_json_complex.Doc +default mongoengine/tests/document/json_serialisation.py /^ default=lambda: EmbeddedDoc())$/;" v class:TestJson.test_json_complex.Doc +default mongoengine/tests/fields/fields.py /^ default='Small')$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt +default mongoengine/tests/queryset/queryset.py /^ default=lambda: [1, 2, 3])$/;" v class:QuerySetTest.test_json_complex.Doc +default mongoengine/tests/queryset/queryset.py /^ default=lambda: EmbeddedDoc())$/;" v class:QuerySetTest.test_json_complex.Doc +default mongoengine/tests/queryset/queryset.py /^ default=lambda: Simple().save())$/;" v class:QuerySetTest.test_json_complex.Doc +default tests/fields/fields.py /^ default='Small')$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt +delete mongoengine/fields.py /^ def delete(self):$/;" m class:GridFSProxy +delete mongoengine/fields.py /^ def delete(self, *args, **kwargs):$/;" m class:ImageGridFsProxy +delete mongoengine/mongoengine/base/datastructures.py /^ def delete(self):$/;" m class:EmbeddedDocumentList +delete mongoengine/mongoengine/document.py /^ def delete(self, signal_kwargs=None, **write_concern):$/;" m class:Document +delete mongoengine/mongoengine/fields.py /^ def delete(self):$/;" m class:GridFSProxy +delete mongoengine/mongoengine/fields.py /^ def delete(self, *args, **kwargs):$/;" m class:ImageGridFsProxy +delete mongoengine/mongoengine/queryset/base.py /^ def delete(self, write_concern=None, _from_doc_delete=False,$/;" m class:BaseQuerySet +deleted mongoengine/tests/queryset/queryset.py /^ deleted = BooleanField(default=False)$/;" v class:QuerySetTest.test_custom_manager.BlogPost +delta mongoengine/tests/document/delta.py /^ def delta(self, DocClass):$/;" m class:DeltaTest +delta_db_field mongoengine/tests/document/delta.py /^ def delta_db_field(self, DocClass):$/;" m class:DeltaTest +delta_recursive mongoengine/tests/document/delta.py /^ def delta_recursive(self, DocClass, EmbeddedClass):$/;" m class:DeltaTest +delta_recursive_db_field mongoengine/tests/document/delta.py /^ def delta_recursive_db_field(self, DocClass, EmbeddedClass):$/;" m class:DeltaTest +dereference mongoengine/fields.py /^ def dereference(self, value):$/;" m class:GenericReferenceField +dereference mongoengine/mongoengine/fields.py /^ def dereference(self, value):$/;" m class:GenericReferenceField +description mongoengine/tests/document/class_methods.py /^ description = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes.BlogPost +description mongoengine/tests/document/class_methods.py /^ description = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPost +description mongoengine/tests/document/class_methods.py /^ description = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPost +description mongoengine/tests/document/class_methods.py /^ description = StringField()$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPost +description mongoengine/tests/document/indexes.py /^ description = StringField()$/;" v class:IndexesTest.test_inherited_index.B +description mongoengine/tests/document/indexes.py /^ description = StringField(required=True)$/;" v class:IndexesTest.test_index_on_id.BlogPost +description mongoengine/tests/fields/fields.py /^ description = StringField()$/;" v class:FieldTest.test_map_field_unicode.Info +description mongoengine/tests/queryset/queryset.py /^ description = StringField(max_length=50)$/;" v class:QuerySetTest.test_add_to_set_each.Item +description tests/fields/fields.py /^ description = StringField()$/;" v class:FieldTest.test_map_field_unicode.Info +details mongoengine/tests/document/instance.py /^ details = EmbeddedDocumentField(EmployeeDetails)$/;" v class:InstanceTest.test_save_embedded_document.Employee +details mongoengine/tests/document/instance.py /^ details = EmbeddedDocumentField(EmployeeDetails)$/;" v class:InstanceTest.test_updating_an_embedded_document.Employee +df mongoengine/tests/queryset/transform.py /^ df = DynamicField()$/;" v class:TransformTest.test_type.Doc +dictField mongoengine/tests/queryset/transform.py /^ dictField = DictField()$/;" v class:TransformTest.test_transform_update.DicDoc +dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField()$/;" v class:DeltaTest.delta.Doc +dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField()$/;" v class:DeltaTest.delta_recursive.Doc +dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField()$/;" v class:DeltaTest.delta_recursive.Embedded +dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField(db_field='db_dict_field')$/;" v class:DeltaTest.delta_db_field.Doc +dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField(db_field='db_dict_field')$/;" v class:DeltaTest.delta_recursive_db_field.Doc +dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField(db_field='db_dict_field')$/;" v class:DeltaTest.delta_recursive_db_field.Embedded +dict_field mongoengine/tests/document/instance.py /^ dict_field = DictField()$/;" v class:InstanceTest.test_reload_referencing.Doc +dict_field mongoengine/tests/document/instance.py /^ dict_field = DictField()$/;" v class:InstanceTest.test_reload_referencing.Embedded +dict_field mongoengine/tests/document/instance.py /^ dict_field = DictField(default=lambda: {"hello": "world"})$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +dict_field mongoengine/tests/document/json_serialisation.py /^ dict_field = DictField(default=lambda: {"hello": "world"})$/;" v class:TestJson.test_json_complex.Doc +dict_field mongoengine/tests/queryset/queryset.py /^ dict_field = DictField(default=lambda: {"hello": "world"})$/;" v class:QuerySetTest.test_json_complex.Doc +dictionary mongoengine/tests/fields/fields.py /^ dictionary = DictField(required=True)$/;" v class:FieldTest.test_invalid_dict_value.DictFieldTest +dictionary tests/fields/fields.py /^ dictionary = DictField(required=True)$/;" v class:FieldTest.test_invalid_dict_value.DictFieldTest +direct mongoengine/tests/fields/fields.py /^ direct = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.EmbeddedOcurrence +direct mongoengine/tests/fields/fields.py /^ direct = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence +direct mongoengine/tests/fields/fields.py /^ direct = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.EmbeddedOcurrence +direct mongoengine/tests/fields/fields.py /^ direct = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence +direct tests/fields/fields.py /^ direct = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.EmbeddedOcurrence +direct tests/fields/fields.py /^ direct = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence +direct tests/fields/fields.py /^ direct = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.EmbeddedOcurrence +direct tests/fields/fields.py /^ direct = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence +disconnect mongoengine/mongoengine/connection.py /^def disconnect(alias=DEFAULT_CONNECTION_NAME):$/;" f +distinct mongoengine/mongoengine/queryset/base.py /^ def distinct(self, field):$/;" m class:BaseQuerySet +doc mongoengine/tests/document/instance.py /^ doc = EmbeddedDocumentField(Embedded)$/;" v class:InstanceTest.test_kwargs_simple.Doc +doc mongoengine/tests/document/instance.py /^ doc = EmbeddedDocumentField(TestEmbeddedDocument)$/;" v class:InstanceTest.test_document_embedded_clean.TestDocument +doc_a mongoengine/tests/fields/file_tests.py /^ doc_a = GridDocument()$/;" v class:FileTest.test_file_field_no_default.GridDocument +doc_b mongoengine/tests/fields/file_tests.py /^ doc_b = GridDocument.objects.with_id(doc_a.id)$/;" v class:FileTest.test_file_field_no_default.GridDocument +doc_c mongoengine/tests/fields/file_tests.py /^ doc_c = GridDocument.objects.with_id(doc_b.id)$/;" v class:FileTest.test_file_field_no_default.GridDocument +doc_d mongoengine/tests/fields/file_tests.py /^ doc_d = GridDocument(the_file=six.b(''))$/;" v class:FileTest.test_file_field_no_default.GridDocument +doc_e mongoengine/tests/fields/file_tests.py /^ doc_e = GridDocument.objects.with_id(doc_d.id)$/;" v class:FileTest.test_file_field_no_default.GridDocument +doc_f mongoengine/tests/fields/file_tests.py /^ doc_f = GridDocument.objects.with_id(doc_e.id)$/;" v class:FileTest.test_file_field_no_default.GridDocument +doc_name mongoengine/tests/document/instance.py /^ doc_name = StringField()$/;" v class:InstanceTest.test_kwargs_complex.Doc +doc_name mongoengine/tests/document/instance.py /^ doc_name = StringField()$/;" v class:InstanceTest.test_kwargs_simple.Doc +docs mongoengine/tests/document/instance.py /^ docs = ListField(EmbeddedDocumentField(Embedded))$/;" v class:InstanceTest.test_kwargs_complex.Doc +doctype mongoengine/tests/fields/fields.py /^ doctype = StringField(require=True, default='userdata')$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.User +doctype tests/fields/fields.py /^ doctype = StringField(require=True, default='userdata')$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.User +document mongoengine/tests/queryset/queryset.py /^ document = GenericEmbeddedDocumentField(choices=(A, B))$/;" v class:QuerySetTest.test_query_generic_embedded_document.Doc +document_type mongoengine/fields.py /^ def document_type(self):$/;" m class:CachedReferenceField +document_type mongoengine/fields.py /^ def document_type(self):$/;" m class:EmbeddedDocumentField +document_type mongoengine/fields.py /^ def document_type(self):$/;" m class:LazyReferenceField +document_type mongoengine/fields.py /^ def document_type(self):$/;" m class:ReferenceField +document_type mongoengine/mongoengine/fields.py /^ def document_type(self):$/;" m class:CachedReferenceField +document_type mongoengine/mongoengine/fields.py /^ def document_type(self):$/;" m class:EmbeddedDocumentField +document_type mongoengine/mongoengine/fields.py /^ def document_type(self):$/;" m class:LazyReferenceField +document_type mongoengine/mongoengine/fields.py /^ def document_type(self):$/;" m class:ReferenceField +down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=105,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=124,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=13,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=17,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=530,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=553,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +down_votes mongoengine/tests/queryset/queryset.py /^ down_votes = IntField()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +drink mongoengine/tests/document/inheritance.py /^ drink = GenericReferenceField()$/;" v class:InheritanceTest.test_inherited_collections.Drinker +drop_collection mongoengine/mongoengine/document.py /^ def drop_collection(cls):$/;" m class:Document +dt mongoengine/tests/fields/fields.py /^ dt = DateTimeField()$/;" v class:FieldTest.test_datetime_from_empty_string.MyDoc +dt mongoengine/tests/fields/fields.py /^ dt = DateTimeField()$/;" v class:FieldTest.test_datetime_from_whitespace_string.MyDoc +dt tests/fields/fields.py /^ dt = DateTimeField()$/;" v class:FieldTest.test_datetime_from_empty_string.MyDoc +dt tests/fields/fields.py /^ dt = DateTimeField()$/;" v class:FieldTest.test_datetime_from_whitespace_string.MyDoc +dt_f mongoengine/tests/queryset/queryset.py /^ dt_f = DateTimeField()$/;" v class:QuerySetTest.test_update_validate.Doc +dt_fld mongoengine/tests/document/instance.py /^ dt_fld = DateTimeField(null=True)$/;" v class:InstanceTest.test_null_field.User +dynamic_field mongoengine/tests/document/instance.py /^ dynamic_field = DynamicField(default=1)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +dynamic_field mongoengine/tests/document/json_serialisation.py /^ dynamic_field = DynamicField(default=1)$/;" v class:TestJson.test_json_complex.Doc +dynamic_field mongoengine/tests/queryset/queryset.py /^ dynamic_field = DynamicField(default=1)$/;" v class:QuerySetTest.test_json_complex.Doc +e mongoengine/tests/document/validation.py /^ e = EmbeddedDocumentField(SubDoc, db_field='eb')$/;" v class:ValidatorErrorTest.test_embedded_db_field_validate.Doc +e mongoengine/tests/document/validation.py /^ e = EmbeddedDocumentField(SubDoc, db_field='eb')$/;" v class:ValidatorErrorTest.test_embedded_weakref.Doc +e mongoengine/tests/queryset/field_list.py /^ e = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc +e mongoengine/tests/queryset/field_list.py /^ e = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc +ed_f mongoengine/tests/queryset/queryset.py /^ ed_f = EmbeddedDocumentField(EmDoc)$/;" v class:QuerySetTest.test_update_validate.Doc +editor mongoengine/tests/document/instance.py /^ editor = ReferenceField(Editor)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal.BlogPost +email mongoengine/docs/code/tumblelog.py /^ email = StringField(required=True)$/;" v class:User +email mongoengine/tests/document/instance.py /^ email = StringField(primary_key=True)$/;" v class:InstanceTest.test_custom_id_field.User.EmailUser +email mongoengine/tests/document/instance.py /^ email = EmailField()$/;" v class:InstanceTest.test_instance_is_set_on_setattr.Email +email mongoengine/tests/document/instance.py /^ email = EmailField()$/;" v class:InstanceTest.test_instance_is_set_on_setattr_on_embedded_document_list.Email +email mongoengine/tests/document/instance.py /^ email = EmailField(required=True)$/;" v class:InstanceTest.test_save.Recipient +email mongoengine/tests/document/instance.py /^ email = EmbeddedDocumentField(Email)$/;" v class:InstanceTest.test_instance_is_set_on_setattr.Account +email mongoengine/tests/document/instance.py /^ email = StringField()$/;" v class:InstanceTest.test_custom_id_field.EmailUser +email mongoengine/tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field.User +email mongoengine/tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_domain_whitelist.User +email mongoengine/tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_ip_domain.User +email mongoengine/tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_unicode_user.User +email mongoengine/tests/fields/fields.py /^ email = EmailField(allow_ip_domain=True)$/;" v class:FieldTest.test_email_field_ip_domain.User +email mongoengine/tests/fields/fields.py /^ email = EmailField(allow_utf8_user=True)$/;" v class:FieldTest.test_email_field_unicode_user.User +email mongoengine/tests/fields/fields.py /^ email = EmailField(domain_whitelist=['localhost'])$/;" v class:FieldTest.test_email_field_domain_whitelist.User +email mongoengine/tests/fields/fields.py /^ email = EmailField(regex=r'\\w+@example.com')$/;" v class:FieldTest.test_email_field_honors_regex.User +email mongoengine/tests/queryset/field_list.py /^ email = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude.User +email mongoengine/tests/queryset/field_list.py /^ email = StringField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.User +email mongoengine/tests/queryset/queryset.py /^ email = EmailField(unique=True, required=True)$/;" v class:QuerySetTest.test_as_pymongo_json_limit_fields.User +email mongoengine/tests/queryset/visitor.py /^ email = EmailField(required=False)$/;" v class:QTest.test_q_merge_queries_edge_case.User +email tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field.User +email tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_domain_whitelist.User +email tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_ip_domain.User +email tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_unicode_user.User +email tests/fields/fields.py /^ email = EmailField(allow_ip_domain=True)$/;" v class:FieldTest.test_email_field_ip_domain.User +email tests/fields/fields.py /^ email = EmailField(allow_utf8_user=True)$/;" v class:FieldTest.test_email_field_unicode_user.User +email tests/fields/fields.py /^ email = EmailField(domain_whitelist=['localhost'])$/;" v class:FieldTest.test_email_field_domain_whitelist.User +email tests/fields/fields.py /^ email = EmailField(regex=r'\\w+@example.com')$/;" v class:FieldTest.test_email_field_honors_regex.User +email_field mongoengine/tests/document/instance.py /^ email_field = EmailField(default="ross@example.com")$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +email_field mongoengine/tests/document/json_serialisation.py /^ email_field = EmailField(default="ross@example.com")$/;" v class:TestJson.test_json_complex.Doc +email_field mongoengine/tests/queryset/queryset.py /^ email_field = EmailField(default="ross@example.com")$/;" v class:QuerySetTest.test_json_complex.Doc +emails mongoengine/tests/document/instance.py /^ emails = EmbeddedDocumentListField(Email)$/;" v class:InstanceTest.test_instance_is_set_on_setattr_on_embedded_document_list.Account +embed mongoengine/tests/queryset/queryset.py /^ embed = EmbeddedDocumentField(Embed, default=Embed)$/;" v class:QuerySetTest.test_save_and_only_on_fields_with_default.B +embed_me mongoengine/tests/fields/fields.py /^ embed_me = DynamicField(db_field='e')$/;" v class:FieldTest.test_dynamic_fields_class.Doc +embed_me mongoengine/tests/fields/fields.py /^ embed_me = DynamicField(db_field='e')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc +embed_me tests/fields/fields.py /^ embed_me = DynamicField(db_field='e')$/;" v class:FieldTest.test_dynamic_fields_class.Doc +embed_me tests/fields/fields.py /^ embed_me = DynamicField(db_field='e')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc +embed_no_default mongoengine/tests/queryset/queryset.py /^ embed_no_default = EmbeddedDocumentField(Embed)$/;" v class:QuerySetTest.test_save_and_only_on_fields_with_default.B +embedded mongoengine/tests/document/json_serialisation.py /^ embedded = EmbeddedDocumentField(Embedded, db_field='e')$/;" v class:TestJson.test_json_names.Doc +embedded mongoengine/tests/fields/fields.py /^ embedded = EmbeddedDocumentField(Embedded, db_field='x')$/;" v class:FieldTest.test_embedded_db_field.Test +embedded mongoengine/tests/fixtures.py /^ embedded = EmbeddedDocumentField(PickleEmbedded)$/;" v class:NewDocumentPickleTest +embedded mongoengine/tests/fixtures.py /^ embedded = EmbeddedDocumentField(PickleEmbedded)$/;" v class:PickleSignalsTest +embedded mongoengine/tests/fixtures.py /^ embedded = EmbeddedDocumentField(PickleEmbedded)$/;" v class:PickleTest +embedded mongoengine/tests/queryset/field_list.py /^ embedded = EmbeddedDocumentField(EmbeddedNumber)$/;" v class:OnlyExcludeAllTest.test_slicing_nested_fields.Numbers +embedded mongoengine/tests/queryset/queryset.py /^ embedded = EmbeddedDocumentField(SubDoc)$/;" v class:QuerySetTest.test_reload_embedded_docs_instance.Doc +embedded mongoengine/tests/queryset/queryset.py /^ embedded = ListField(EmbeddedDocumentField(SubDoc))$/;" v class:QuerySetTest.test_reload_list_embedded_docs_instance.Doc +embedded tests/fields/fields.py /^ embedded = EmbeddedDocumentField(Embedded, db_field='x')$/;" v class:FieldTest.test_embedded_db_field.Test +embedded_document_field mongoengine/tests/document/instance.py /^ embedded_document_field = EmbeddedDocumentField($/;" v class:InstanceTest.test_can_save_if_not_included.Doc +embedded_document_field mongoengine/tests/document/json_serialisation.py /^ embedded_document_field = EmbeddedDocumentField(EmbeddedDoc,$/;" v class:TestJson.test_json_complex.Doc +embedded_document_field mongoengine/tests/queryset/queryset.py /^ embedded_document_field = EmbeddedDocumentField($/;" v class:QuerySetTest.test_json_complex.Doc +embedded_field mongoengine/tests/document/delta.py /^ embedded_field = EmbeddedDocumentField(Embedded)$/;" v class:DeltaTest.delta_recursive.Doc +embedded_field mongoengine/tests/document/delta.py /^ embedded_field = EmbeddedDocumentField(Embedded,$/;" v class:DeltaTest.delta_recursive_db_field.Doc +embedded_field mongoengine/tests/document/instance.py /^ embedded_field = EmbeddedDocumentField(Embedded)$/;" v class:InstanceTest.test_embedded_document_instance.Doc +embedded_field mongoengine/tests/document/instance.py /^ embedded_field = EmbeddedDocumentField(Embedded)$/;" v class:InstanceTest.test_reload_referencing.Doc +embedded_field mongoengine/tests/document/instance.py /^ embedded_field = ListField(EmbeddedDocumentField(Embedded))$/;" v class:InstanceTest.test_embedded_document_complex_instance.Doc +embedded_field mongoengine/tests/document/instance.py /^ embedded_field = ListField(EmbeddedDocumentField(Embedded))$/;" v class:InstanceTest.test_embedded_document_complex_instance_no_use_db_field.Doc +embedded_field mongoengine/tests/document/json_serialisation.py /^ embedded_field = EmbeddedDocumentField(Embedded)$/;" v class:TestJson.test_json_simple.Doc +embedded_field mongoengine/tests/queryset/queryset.py /^ embedded_field = EmbeddedDocumentField(Embedded)$/;" v class:QuerySetTest.test_json_simple.Doc +employee mongoengine/tests/document/class_methods.py /^ employee = ReferenceField(self.Person)$/;" v class:ClassMethodsTest.test_register_delete_rule.Job +employees mongoengine/tests/document/delta.py /^ employees = ListField(ReferenceField('Person', dbref=dbref))$/;" v class:DeltaTest.circular_reference_deltas_2.Organization +employees mongoengine/tests/queryset/queryset.py /^ employees = ListField(ReferenceField(Person))$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Organization +employees mongoengine/tests/test_dereference.py /^ employees = Employee.objects(boss=bill).select_related()$/;" v class:FieldTest.test_recursive_reference.Employee +employer mongoengine/tests/document/delta.py /^ employer = ReferenceField('Organization', dbref=dbref)$/;" v class:DeltaTest.circular_reference_deltas_2.Person +empty mongoengine/mongoengine/queryset/visitor.py /^ def empty(self):$/;" m class:Q +empty mongoengine/mongoengine/queryset/visitor.py /^ def empty(self):$/;" m class:QCombination +empty mongoengine/mongoengine/queryset/visitor.py /^ def empty(self):$/;" m class:QNode +ensure_index mongoengine/mongoengine/document.py /^ def ensure_index(cls, key_or_list, drop_dups=False, background=False,$/;" m class:Document +ensure_index mongoengine/mongoengine/queryset/base.py /^ def ensure_index(self, **kwargs):$/;" m class:BaseQuerySet +ensure_indexes mongoengine/mongoengine/document.py /^ def ensure_indexes(cls):$/;" m class:Document +error mongoengine/mongoengine/base/fields.py /^ def error(self, message='', errors=None, field_name=None):$/;" m class:BaseField +error_class mongoengine/tests/queryset/queryset.py /^ error_class = ConfigurationError$/;" v class:QuerySetTest.test_read_preference.Bar +error_class mongoengine/tests/queryset/queryset.py /^ error_class = TypeError$/;" v class:QuerySetTest.test_read_preference.Bar +error_dict mongoengine/tests/fields/fields.py /^ error_dict = error.to_dict()$/;" v class:FieldTest.test_recursive_validation.Post +error_dict mongoengine/tests/fields/fields.py /^ error_dict = error.to_dict()$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt +error_dict tests/fields/fields.py /^ error_dict = error.to_dict()$/;" v class:FieldTest.test_recursive_validation.Post +error_dict tests/fields/fields.py /^ error_dict = error.to_dict()$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt +error_msg mongoengine/fields.py /^ error_msg = u'Invalid email address: %s'$/;" v class:EmailField +error_msg mongoengine/mongoengine/fields.py /^ error_msg = u'Invalid email address: %s'$/;" v class:EmailField +errors mongoengine/mongoengine/errors.py /^ errors = {}$/;" v class:ValidationError +evil mongoengine/tests/document/inheritance.py /^ evil = BooleanField(default=True)$/;" v class:InheritanceTest.test_abstract_documents.Human.EvilHuman +exclude mongoengine/mongoengine/base/datastructures.py /^ def exclude(self, **kwargs):$/;" m class:EmbeddedDocumentList +exclude mongoengine/mongoengine/queryset/base.py /^ def exclude(self, *fields):$/;" m class:BaseQuerySet +exclude_trees mongoengine/docs/conf.py /^exclude_trees = ['_build']$/;" v +exec_js mongoengine/mongoengine/queryset/base.py /^ def exec_js(self, code, *fields, **options):$/;" m class:BaseQuerySet +expand mongoengine/tests/document/instance.py /^ def expand(self):$/;" m class:InstanceTest.test_complex_nesting_document_and_embedded_document.Node +expand mongoengine/tests/document/instance.py /^ def expand(self):$/;" m class:InstanceTest.test_complex_nesting_document_and_embedded_document.Parameter +expect_msg mongoengine/tests/document/instance.py /^ expect_msg = "Draft entries may not have a publication date."$/;" v class:InstanceTest.test_document_clean.TestDocument +expected mongoengine/tests/fields/geo.py /^ expected = "Both values (%s) in point must be float or int" % repr(coord)$/;" v class:GeoFieldTest.test_geopoint_validation.Location +expected mongoengine/tests/fields/geo.py /^ expected = "Both values (%s) in point must be float or int" % repr(coord)$/;" v class:GeoFieldTest.test_point_validation.Location +expected mongoengine/tests/fields/geo.py /^ expected = "Both values (%s) in point must be float or int" % repr(coord[0])$/;" v class:GeoFieldTest.test_multipoint_validation.Location +expected mongoengine/tests/fields/geo.py /^ expected = "Invalid LineString:\\nBoth values (%s) in point must be float or int" % repr(coord[0])$/;" v class:GeoFieldTest.test_linestring_validation.Location +expected mongoengine/tests/fields/geo.py /^ expected = "Invalid MultiLineString:\\nBoth values (%s) in point must be float or int" % repr(coord[0][0])$/;" v class:GeoFieldTest.test_multilinestring_validation.Location +expected mongoengine/tests/fields/geo.py /^ expected = "Value (%s) must be a two-dimensional point" % repr(coord)$/;" v class:GeoFieldTest.test_geopoint_validation.Location +expected mongoengine/tests/fields/geo.py /^ expected = "Value (%s) must be a two-dimensional point" % repr(coord)$/;" v class:GeoFieldTest.test_point_validation.Location +expected mongoengine/tests/fields/geo.py /^ expected = "Value (%s) must be a two-dimensional point" % repr(coord[0])$/;" v class:GeoFieldTest.test_multipoint_validation.Location +explain mongoengine/mongoengine/queryset/base.py /^ def explain(self, format=False):$/;" m class:BaseQuerySet +extend mongoengine/mongoengine/base/datastructures.py /^ def extend(self, *args, **kwargs):$/;" m class:BaseList +extensions mongoengine/docs/conf.py /^extensions = ['sphinx.ext.autodoc', 'sphinx.ext.todo']$/;" v +extra mongoengine/tests/document/instance.py /^ extra = DictField()$/;" v class:InstanceTest.test_db_ref_usage.Book +extra mongoengine/tests/queryset/queryset.py /^ extra = EmbeddedDocumentField(Extra)$/;" v class:QuerySetTest.test_item_frequencies_with_null_embedded.Person +extra_opts mongoengine/setup.py /^extra_opts = {$/;" v +extra_text mongoengine/tests/document/class_methods.py /^ extra_text = StringField()$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPostWithTagsAndExtraText +f mongoengine/tests/queryset/field_list.py /^ f = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc +f mongoengine/tests/queryset/field_list.py /^ f = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc +fake_update mongoengine/tests/document/instance.py /^ def fake_update(*args, **kwargs):$/;" m class:InstanceTest.test_do_not_save_unchanged_references.Person +family mongoengine/tests/document/class_methods.py /^ family = StringField(required=True)$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Animal +family mongoengine/tests/fields/file_tests.py /^ family = StringField()$/;" v class:FileTest.test_complex_field_filefield.Animal +family mongoengine/tests/fields/file_tests.py /^ family = StringField()$/;" v class:FileTest.test_file_saving.Animal +family mongoengine/tests/queryset/queryset.py /^ family = ReferenceField(Family)$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person +father mongoengine/tests/document/instance.py /^ father = ReferenceField('Person', reverse_delete_rule=DENY)$/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Parents +father mongoengine/tests/fields/fields.py /^ father = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone +father mongoengine/tests/fields/fields.py /^ father = CachedReferenceField('self', fields=('tp',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person +father mongoengine/tests/fields/fields.py /^ father = CachedReferenceField('self', fields=('tp',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person +father tests/fields/fields.py /^ father = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone +father tests/fields/fields.py /^ father = CachedReferenceField('self', fields=('tp',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person +father tests/fields/fields.py /^ father = CachedReferenceField('self', fields=('tp',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person +feed mongoengine/tests/document/instance.py /^ feed = Feed.objects.first()$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription +feed mongoengine/tests/document/instance.py /^ feed = ReferenceField(Feed)$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription +fetch mongoengine/mongoengine/base/datastructures.py /^ def fetch(self, force=False):$/;" m class:LazyReference +field mongoengine/mongoengine/base/fields.py /^ field = None$/;" v class:ComplexBaseField +field mongoengine/tests/document/instance.py /^ field=ReferenceField($/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Blog +field mongoengine/tests/document/instance.py /^ field = StringField(required=True)$/;" v class:InstanceTest.test_embedded_document_equality.Test +field mongoengine/tests/fields/fields.py /^ field = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.Doc +field mongoengine/tests/fields/fields.py /^ field = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.Doc +field mongoengine/tests/queryset/queryset.py /^ field = IntField()$/;" v class:QuerySetTest.test_save_and_only_on_fields_with_default.Embed +field mongoengine/tests/queryset/queryset.py /^ field = IntField(default=1)$/;" v class:QuerySetTest.test_save_and_only_on_fields_with_default.B +field tests/fields/fields.py /^ field = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.Doc +field tests/fields/fields.py /^ field = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.Doc +field1 mongoengine/tests/document/instance.py /^ field1 = StringField(default='field1')$/;" v class:InstanceTest.test_mutating_documents.B +field2 mongoengine/tests/document/instance.py /^ field2 = EmbeddedDocumentField(C, default=lambda: C())$/;" v class:InstanceTest.test_mutating_documents.B +field_1 mongoengine/tests/fields/fields.py /^ field_1 = StringField(db_field='f')$/;" v class:FieldTest.test_dynamic_fields_class.Doc2 +field_1 mongoengine/tests/fields/fields.py /^ field_1 = StringField(db_field='f')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Embed +field_1 tests/fields/fields.py /^ field_1 = StringField(db_field='f')$/;" v class:FieldTest.test_dynamic_fields_class.Doc2 +field_1 tests/fields/fields.py /^ field_1 = StringField(db_field='f')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Embed +field_name mongoengine/mongoengine/errors.py /^ field_name = None$/;" v class:ValidationError +field_path_sub mongoengine/mongoengine/queryset/base.py /^ def field_path_sub(match):$/;" f function:BaseQuerySet._sub_js_fields +field_sub mongoengine/mongoengine/queryset/base.py /^ def field_sub(match):$/;" f function:BaseQuerySet._sub_js_fields +field_x mongoengine/tests/fields/fields.py /^ field_x = StringField(db_field='x')$/;" v class:FieldTest.test_dynamic_fields_class.Doc +field_x mongoengine/tests/fields/fields.py /^ field_x = StringField(db_field='x')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc +field_x tests/fields/fields.py /^ field_x = StringField(db_field='x')$/;" v class:FieldTest.test_dynamic_fields_class.Doc +field_x tests/fields/fields.py /^ field_x = StringField(db_field='x')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc +fielda mongoengine/tests/queryset/queryset.py /^ fielda = IntField()$/;" v class:QuerySetTest.test_where.IntPair +fieldb mongoengine/tests/queryset/queryset.py /^ fieldb = IntField()$/;" v class:QuerySetTest.test_where.IntPair +fields mongoengine/mongoengine/queryset/base.py /^ def fields(self, _only_called=False, **kwargs):$/;" m class:BaseQuerySet +fields mongoengine/tests/fields/fields.py /^ fields=('group',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData +fields mongoengine/tests/fields/fields.py /^ fields=('salary',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest +fields mongoengine/tests/queryset/queryset.py /^ fields = DictField()$/;" v class:QuerySetTest.test_no_cache.Noddy +fields tests/fields/fields.py /^ fields=('group',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData +fields tests/fields/fields.py /^ fields=('salary',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest +filter mongoengine/mongoengine/base/datastructures.py /^ def filter(self, **kwargs):$/;" m class:EmbeddedDocumentList +filter mongoengine/mongoengine/queryset/base.py /^ def filter(self, *q_objs, **query):$/;" m class:BaseQuerySet +finalize_f mongoengine/tests/queryset/queryset.py /^ finalize_f=finalize_f,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +first mongoengine/mongoengine/base/datastructures.py /^ def first(self):$/;" m class:EmbeddedDocumentList +first mongoengine/mongoengine/queryset/base.py /^ def first(self):$/;" m class:BaseQuerySet +first_name mongoengine/docs/code/tumblelog.py /^ first_name = StringField(max_length=50)$/;" v class:User +flip mongoengine/tests/document/instance.py /^ def flip(widget):$/;" f function:InstanceTest.test_save_atomicity_condition +float_field mongoengine/tests/document/instance.py /^ float_field = FloatField(default=1.1)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +float_field mongoengine/tests/document/json_serialisation.py /^ float_field = FloatField(default=1.1)$/;" v class:TestJson.test_json_complex.Doc +float_field mongoengine/tests/queryset/queryset.py /^ float_field = FloatField(default=1.1)$/;" v class:QuerySetTest.test_json_complex.Doc +float_fld mongoengine/tests/fields/fields.py /^ float_fld = FloatField()$/;" v class:FieldTest.test_int_and_float_ne_operator.TestDocument +float_fld tests/fields/fields.py /^ float_fld = FloatField()$/;" v class:FieldTest.test_int_and_float_ne_operator.TestDocument +float_value mongoengine/tests/fields/fields.py /^ float_value = DecimalField(precision=4)$/;" v class:FieldTest.test_decimal_storage.Person +float_value tests/fields/fields.py /^ float_value = DecimalField(precision=4)$/;" v class:FieldTest.test_decimal_storage.Person +flt_fld mongoengine/tests/document/instance.py /^ flt_fld = FloatField(null=True)$/;" v class:InstanceTest.test_null_field.User +flt_fld mongoengine/tests/fields/fields.py /^ flt_fld = FloatField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +flt_fld mongoengine/tests/fields/fields.py /^ flt_fld = FloatField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields +flt_fld tests/fields/fields.py /^ flt_fld = FloatField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +flt_fld tests/fields/fields.py /^ flt_fld = FloatField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields +folded_ears mongoengine/tests/queryset/queryset.py /^ folded_ears = BooleanField()$/;" v class:QuerySetTest.test_subclass_field_query.ScottishCat +foo mongoengine/tests/document/instance.py /^ foo = BooleanField(unique=True)$/;" v class:InstanceTest.subclasses_and_unique_keys_works.B +foo mongoengine/tests/document/instance.py /^ foo = EmbeddedDocumentField(Foo)$/;" v class:InstanceTest.test_shard_key_in_embedded_document.Bar +foo mongoengine/tests/document/instance.py /^ foo = ListField(StringField())$/;" v class:InstanceTest.test_update_list_field.Doc +foo mongoengine/tests/document/instance.py /^ foo = ReferenceField('Foo')$/;" v class:InstanceTest.test_two_way_reverse_delete_rule.Bar +foo mongoengine/tests/document/instance.py /^ foo = StringField()$/;" v class:InstanceTest.test_can_save_false_values.Doc +foo mongoengine/tests/document/instance.py /^ foo = StringField()$/;" v class:InstanceTest.test_can_save_false_values_dynamic.Doc +foo mongoengine/tests/document/instance.py /^ foo = StringField()$/;" v class:InstanceTest.test_shard_key_in_embedded_document.Foo +foo mongoengine/tests/document/instance.py /^ foo = StringField(default=None)$/;" v class:InstanceTest.test_set_unset_one_operation.FooBar +foo mongoengine/tests/fields/fields.py /^ foo = StringField()$/;" v class:FieldTest.test_undefined_field_exception.Doc +foo mongoengine/tests/fields/fields.py /^ foo = StringField()$/;" v class:FieldTest.test_undefined_field_exception_with_strict.Doc +foo mongoengine/tests/queryset/queryset.py /^ foo = ListField(EmbeddedDocumentField(Foo))$/;" v class:QuerySetTest.test_elem_match.Bar +foo mongoengine/tests/queryset/transform.py /^ foo = ListField(StringField())$/;" v class:TransformTest.test_transform_update.LisDoc +foo tests/fields/fields.py /^ foo = StringField()$/;" v class:FieldTest.test_undefined_field_exception.Doc +foo tests/fields/fields.py /^ foo = StringField()$/;" v class:FieldTest.test_undefined_field_exception_with_strict.Doc +food mongoengine/tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_embedded_document_validation.PersonPreferences +food mongoengine/tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_embedded_document.Dish +food mongoengine/tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_embedded_document_choices.Dish +food mongoengine/tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Dish +food tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_embedded_document_validation.PersonPreferences +food tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_embedded_document.Dish +food tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_embedded_document_choices.Dish +food tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Dish +foos mongoengine/tests/queryset/queryset.py /^ foos = ListField(GenericEmbeddedDocumentField($/;" v class:QuerySetTest.test_pull_in_genericembedded_field.Bar +format mongoengine/fields.py /^ def format(self):$/;" m class:ImageGridFsProxy +format mongoengine/mongoengine/fields.py /^ def format(self):$/;" m class:ImageGridFsProxy +forms mongoengine/tests/document/instance.py /^ forms = ListField(StringField(), default=list)$/;" v class:InstanceTest.test_invalid_son.Word +friend mongoengine/tests/document/instance.py /^ friend = ReferenceField('self')$/;" v class:InstanceTest.test_save_max_recursion_not_hit.Person +friends mongoengine/tests/fields/fields.py /^ friends = ListField(ReferenceField('self'))$/;" v class:FieldTest.test_recursive_reference.Employee +friends mongoengine/tests/test_dereference.py /^ friends = ListField(ReferenceField('Person'))$/;" v class:FieldTest.test_circular_tree_reference.Other +friends mongoengine/tests/test_dereference.py /^ friends = ListField(ReferenceField('self'))$/;" v class:FieldTest.test_recursive_reference.Employee +friends tests/fields/fields.py /^ friends = ListField(ReferenceField('self'))$/;" v class:FieldTest.test_recursive_reference.Employee +from_json mongoengine/mongoengine/base/document.py /^ def from_json(cls, json_data, created=False):$/;" m class:BaseDocument +from_json mongoengine/mongoengine/queryset/base.py /^ def from_json(self, json_data):$/;" m class:BaseQuerySet +fs mongoengine/fields.py /^ def fs(self):$/;" m class:GridFSProxy +fs mongoengine/mongoengine/fields.py /^ def fs(self):$/;" m class:GridFSProxy +gender mongoengine/tests/queryset/queryset.py /^ gender = StringField()$/;" v class:QuerySetTest.test_mapfield_update.Member +generate mongoengine/fields.py /^ def generate(self):$/;" m class:SequenceField +generate mongoengine/mongoengine/fields.py /^ def generate(self):$/;" m class:SequenceField +generate_key mongoengine/mongoengine/errors.py /^ def generate_key(value, prefix=''):$/;" f function:ValidationError._format_errors +generated mongoengine/tests/document/instance.py /^ generated = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_reference_inheritance.CompareStats +generic mongoengine/tests/fields/fields.py /^ generic = ListField(GenericReferenceField())$/;" v class:FieldTest.test_list_validation.BlogPost +generic mongoengine/tests/test_context_managers.py /^ generic = GenericReferenceField()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_dbref.Group +generic mongoengine/tests/test_context_managers.py /^ generic = GenericReferenceField()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_object_id.Group +generic tests/fields/fields.py /^ generic = ListField(GenericReferenceField())$/;" v class:FieldTest.test_list_validation.BlogPost +generic_as_lazy mongoengine/tests/fields/fields.py /^ generic_as_lazy = ListField(GenericLazyReferenceField())$/;" v class:FieldTest.test_list_validation.BlogPost +generic_as_lazy tests/fields/fields.py /^ generic_as_lazy = ListField(GenericLazyReferenceField())$/;" v class:FieldTest.test_list_validation.BlogPost +generic_embedded_document_field mongoengine/tests/document/instance.py /^ generic_embedded_document_field = GenericEmbeddedDocumentField($/;" v class:InstanceTest.test_can_save_if_not_included.Doc +generic_embedded_document_field mongoengine/tests/document/json_serialisation.py /^ generic_embedded_document_field = GenericEmbeddedDocumentField($/;" v class:TestJson.test_json_complex.Doc +generic_embedded_document_field mongoengine/tests/queryset/queryset.py /^ generic_embedded_document_field = GenericEmbeddedDocumentField($/;" v class:QuerySetTest.test_json_complex.Doc +generic_ref mongoengine/tests/fields/fields.py /^ generic_ref = GenericReferenceField()$/;" v class:FieldTest.test_reference_miss.Bar +generic_ref tests/fields/fields.py /^ generic_ref = GenericReferenceField()$/;" v class:FieldTest.test_reference_miss.Bar +generic_reference_field mongoengine/tests/document/instance.py /^ generic_reference_field = GenericReferenceField($/;" v class:InstanceTest.test_can_save_if_not_included.Doc +generic_reference_field mongoengine/tests/document/json_serialisation.py /^ generic_reference_field = GenericReferenceField($/;" v class:TestJson.test_json_complex.Doc +generic_reference_field mongoengine/tests/queryset/queryset.py /^ generic_reference_field = GenericReferenceField($/;" v class:QuerySetTest.test_json_complex.Doc +genus mongoengine/tests/fields/file_tests.py /^ genus = StringField()$/;" v class:FileTest.test_complex_field_filefield.Animal +genus mongoengine/tests/fields/file_tests.py /^ genus = StringField()$/;" v class:FileTest.test_file_saving.Animal +geo_point_field mongoengine/tests/document/instance.py /^ geo_point_field = GeoPointField(default=lambda: [1, 2])$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +geo_point_field mongoengine/tests/document/json_serialisation.py /^ geo_point_field = GeoPointField(default=lambda: [1, 2])$/;" v class:TestJson.test_json_complex.Doc +geo_point_field mongoengine/tests/queryset/queryset.py /^ geo_point_field = GeoPointField(default=lambda: [1, 2])$/;" v class:QuerySetTest.test_json_complex.Doc +get mongoengine/fields.py /^ def get(self, grid_id=None):$/;" m class:GridFSProxy +get mongoengine/mongoengine/base/datastructures.py /^ def get(self, **kwargs):$/;" m class:EmbeddedDocumentList +get mongoengine/mongoengine/base/datastructures.py /^ def get(self, key, default=None):$/;" m class:StrictDict +get mongoengine/mongoengine/fields.py /^ def get(self, grid_id=None):$/;" m class:GridFSProxy +get mongoengine/mongoengine/queryset/base.py /^ def get(self, *q_objs, **query):$/;" m class:BaseQuerySet +get_auto_id_names mongoengine/mongoengine/base/metaclasses.py /^ def get_auto_id_names(cls, new_class):$/;" m class:TopLevelDocumentMetaclass +get_classes mongoengine/mongoengine/document.py /^ def get_classes(cls):$/;" f function:Document.list_indexes +get_connection mongoengine/mongoengine/connection.py /^def get_connection(alias=DEFAULT_CONNECTION_NAME, reconnect=False):$/;" f +get_db mongoengine/mongoengine/connection.py /^def get_db(alias=DEFAULT_CONNECTION_NAME, reconnect=False):$/;" f +get_document mongoengine/mongoengine/base/common.py /^def get_document(name):$/;" f +get_indexes_spec mongoengine/mongoengine/document.py /^ def get_indexes_spec(cls):$/;" f function:Document.list_indexes +get_mongodb_version mongoengine/tests/utils.py /^def get_mongodb_version():$/;" f +get_next_value mongoengine/fields.py /^ def get_next_value(self):$/;" m class:SequenceField +get_next_value mongoengine/mongoengine/fields.py /^ def get_next_value(self):$/;" m class:SequenceField +get_ops mongoengine/tests/queryset/queryset.py /^ def get_ops(self):$/;" m class:db_ops_tracker +get_proxy_obj mongoengine/fields.py /^ def get_proxy_obj(self, key, instance, db_alias=None, collection_name=None):$/;" m class:FileField +get_proxy_obj mongoengine/mongoengine/fields.py /^ def get_proxy_obj(self, key, instance, db_alias=None, collection_name=None):$/;" m class:FileField +get_queryset mongoengine/mongoengine/queryset/manager.py /^ get_queryset = None$/;" v class:QuerySetManager +get_queryset mongoengine/tests/queryset/queryset.py /^ def get_queryset(doc_cls, queryset):$/;" m class:QuerySetTest.test_custom_querysets_managers_directly.CustomQuerySetManager +get_sequence_name mongoengine/fields.py /^ def get_sequence_name(self):$/;" m class:SequenceField +get_sequence_name mongoengine/mongoengine/fields.py /^ def get_sequence_name(self):$/;" m class:SequenceField +get_signal_output mongoengine/tests/test_signals.py /^ def get_signal_output(self, fn, *args, **kwargs):$/;" m class:SignalTests +get_text_score mongoengine/mongoengine/base/document.py /^ def get_text_score(self):$/;" m class:BaseDocument +get_tz_awareness mongoengine/tests/test_connection.py /^def get_tz_awareness(connection):$/;" f +get_version mongoengine/mongoengine/__init__.py /^def get_version():$/;" f +get_version mongoengine/setup.py /^def get_version(version_tuple):$/;" f +group mongoengine/tests/document/instance.py /^ group = Group.objects.first()$/;" v class:InstanceTest.test_switch_db_instance.Group +group mongoengine/tests/fields/fields.py /^ group = ReferenceField(Group)$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Person +group mongoengine/tests/fields/fields.py /^ group = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest +group mongoengine/tests/test_context_managers.py /^ group = Group.objects.first()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_dbref.Group +group mongoengine/tests/test_context_managers.py /^ group = Group.objects.first()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_object_id.Group +group tests/fields/fields.py /^ group = ReferenceField(Group)$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Person +group tests/fields/fields.py /^ group = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_dict_field.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_dict_field_no_field_inheritance.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_generic_reference.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_generic_reference_map_field.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_list_field_complex.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_list_item_dereference.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_list_item_dereference_dref_false.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_map_field_reference.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_dict_field.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_dict_field_no_field_inheritance.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_generic_reference.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_generic_reference_map_field.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_list_field_complex.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_list_item_dereference.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_list_item_dereference_dref_false.Group +group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_map_field_reference.Group +group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_dict_field.Group +group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_dict_field_no_field_inheritance.Group +group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_generic_reference.Group +group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_generic_reference_map_field.Group +group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_list_field_complex.Group +group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_list_item_dereference.Group +group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_list_item_dereference_dref_false.Group +group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_map_field_reference.Group +groups mongoengine/tests/fields/fields.py /^ groups = ListField(EmbeddedDocumentField(Group))$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Basedoc +groups tests/fields/fields.py /^ groups = ListField(EmbeddedDocumentField(Group))$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Basedoc +height mongoengine/tests/document/instance.py /^ height = FloatField()$/;" v class:InstanceTest.test_falsey_pk.Person +height mongoengine/tests/document/instance.py /^ height = IntField(default=184, null=True)$/;" v class:InstanceTest.test_null_field.User +height mongoengine/tests/document/instance.py /^ height = IntField(default=189)$/;" v class:InstanceTest.test_default_values.Person +height mongoengine/tests/fields/fields.py /^ height = DecimalField(min_value=Decimal('0.1'),$/;" v class:FieldTest.test_decimal_validation.Person +height mongoengine/tests/fields/fields.py /^ height = FloatField()$/;" v class:FieldTest.test_float_validation.BigPerson +height mongoengine/tests/fields/fields.py /^ height = FloatField(min_value=0.1, max_value=3.5)$/;" v class:FieldTest.test_float_validation.Person +height tests/fields/fields.py /^ height = DecimalField(min_value=Decimal('0.1'),$/;" v class:FieldTest.test_decimal_validation.Person +height tests/fields/fields.py /^ height = FloatField()$/;" v class:FieldTest.test_float_validation.BigPerson +height tests/fields/fields.py /^ height = FloatField(min_value=0.1, max_value=3.5)$/;" v class:FieldTest.test_float_validation.Person +helpful mongoengine/tests/queryset/queryset.py /^ helpful = ListField(EmbeddedDocumentField(User))$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Collaborator +high_score mongoengine/tests/queryset/queryset.py /^ high_score = IntField()$/;" v class:QuerySetTest.test_update_min_max.Scores +hint mongoengine/mongoengine/queryset/base.py /^ def hint(self, index=None):$/;" m class:BaseQuerySet +hits mongoengine/tests/queryset/queryset.py /^ hits = IntField()$/;" v class:QuerySetTest.test_exec_js_query.BlogPost +hits mongoengine/tests/queryset/queryset.py /^ hits = IntField()$/;" v class:QuerySetTest.test_item_frequencies.BlogPost +hits mongoengine/tests/queryset/queryset.py /^ hits = IntField()$/;" v class:QuerySetTest.test_update.BlogPost +html_favicon mongoengine/docs/conf.py /^html_favicon = "favicon.ico"$/;" v +html_sidebars mongoengine/docs/conf.py /^html_sidebars = {$/;" v +html_theme mongoengine/docs/conf.py /^html_theme = 'sphinx_rtd_theme'$/;" v +html_theme_options mongoengine/docs/conf.py /^html_theme_options = {$/;" v +html_theme_path mongoengine/docs/conf.py /^html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]$/;" v +html_use_smartypants mongoengine/docs/conf.py /^html_use_smartypants = True$/;" v +htmlhelp_basename mongoengine/docs/conf.py /^htmlhelp_basename = 'MongoEnginedoc'$/;" v +id mongoengine/tests/document/delta.py /^ id = StringField()$/;" v class:DeltaTest.delta_recursive.Embedded +id mongoengine/tests/document/inheritance.py /^ id = IntField()$/;" v class:InheritanceTest.test_auto_id_vs_non_pk_id_field.City +id mongoengine/tests/document/instance.py /^ id = IntField(primary_key=True)$/;" v class:InstanceTest.test_reverse_delete_rule_with_shared_id_among_collections.Book +id mongoengine/tests/document/instance.py /^ id = IntField(primary_key=True)$/;" v class:InstanceTest.test_reverse_delete_rule_with_shared_id_among_collections.User +id mongoengine/tests/document/instance.py /^ id = StringField(required=True)$/;" v class:InstanceTest.test_embedded_document_to_mongo_id.SubDoc +id mongoengine/tests/document/validation.py /^ id = StringField(primary_key=True)$/;" v class:ValidatorErrorTest.test_embedded_db_field_validate.Doc +id mongoengine/tests/fields/fields.py /^ id = BinaryField(primary_key=True)$/;" v class:FieldTest.test_binary_field_primary.Attachment +id mongoengine/tests/fields/fields.py /^ id = BinaryField(primary_key=True)$/;" v class:FieldTest.test_binary_field_primary_filter_by_binary_pk_as_str.Attachment +id mongoengine/tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbed +id mongoengine/tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent +id mongoengine/tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbed +id mongoengine/tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent +id mongoengine/tests/fields/fields.py /^ id = SequenceField()$/;" v class:FieldTest.test_embedded_sequence_field.Comment +id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields.Person +id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Animal +id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Person +id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_sequence_field.Person +id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_sequence_field_get_next_value.Person +id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True, sequence_name='jelly')$/;" v class:FieldTest.test_sequence_field_sequence_name.Person +id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True, value_decorator=str)$/;" v class:FieldTest.test_sequence_field_get_next_value.Person +id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True, value_decorator=str)$/;" v class:FieldTest.test_sequence_field_value_decorator.Person +id mongoengine/tests/queryset/modify.py /^ id = IntField(primary_key=True)$/;" v class:Doc +id mongoengine/tests/queryset/queryset.py /^ id = IntField($/;" v class:QuerySetTest.test_map_reduce_custom_output.Family +id mongoengine/tests/queryset/queryset.py /^ id = IntField($/;" v class:QuerySetTest.test_map_reduce_custom_output.Person +id mongoengine/tests/queryset/queryset.py /^ id = ObjectIdField('_id')$/;" v class:QuerySetTest.test_as_pymongo.User +id mongoengine/tests/queryset/queryset.py /^ id = StringField(unique=True, primary_key=True)$/;" v class:QuerySetTest.test_filter_chaining.Blog +id mongoengine/tests/queryset/queryset.py /^ id = StringField(unique=True, primary_key=True)$/;" v class:QuerySetTest.test_query_reference_to_custom_pk_doc.A +id mongoengine/tests/test_dereference.py /^ id = IntField(primary_key=True)$/;" v class:FieldTest.test_document_reload_reference_integrity.Message +id mongoengine/tests/test_dereference.py /^ id = IntField(primary_key=True)$/;" v class:FieldTest.test_document_reload_reference_integrity.Topic +id mongoengine/tests/test_dereference.py /^ id = IntField(primary_key=True)$/;" v class:FieldTest.test_document_reload_reference_integrity.User +id mongoengine/tests/test_dereference.py /^ id = IntField(primary_key=True)$/;" v class:FieldTest.test_list_lookup_not_checked_in_map.Comment +id mongoengine/tests/test_dereference.py /^ id = IntField(primary_key=True)$/;" v class:FieldTest.test_list_lookup_not_checked_in_map.Message +id mongoengine/tests/test_signals.py /^ id = IntField(primary_key=True)$/;" v class:SignalTests.setUp.ExplicitId +id mongoengine/tests/test_signals.py /^ id = SequenceField(primary_key=True)$/;" v class:SignalTests.setUp.Author +id tests/fields/fields.py /^ id = BinaryField(primary_key=True)$/;" v class:FieldTest.test_binary_field_primary.Attachment +id tests/fields/fields.py /^ id = BinaryField(primary_key=True)$/;" v class:FieldTest.test_binary_field_primary_filter_by_binary_pk_as_str.Attachment +id tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbed +id tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent +id tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbed +id tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent +id tests/fields/fields.py /^ id = SequenceField()$/;" v class:FieldTest.test_embedded_sequence_field.Comment +id tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields.Person +id tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Animal +id tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Person +id tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_sequence_field.Person +id tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_sequence_field_get_next_value.Person +id tests/fields/fields.py /^ id = SequenceField(primary_key=True, sequence_name='jelly')$/;" v class:FieldTest.test_sequence_field_sequence_name.Person +id tests/fields/fields.py /^ id = SequenceField(primary_key=True, value_decorator=str)$/;" v class:FieldTest.test_sequence_field_get_next_value.Person +id tests/fields/fields.py /^ id = SequenceField(primary_key=True, value_decorator=str)$/;" v class:FieldTest.test_sequence_field_value_decorator.Person +image mongoengine/tests/fields/file_tests.py /^ image = ImageField()$/;" v class:FileTest.test_image_field.TestImage +image mongoengine/tests/fields/file_tests.py /^ image = ImageField(size=(185, 37))$/;" v class:FileTest.test_image_field_resize.TestImage +image mongoengine/tests/fields/file_tests.py /^ image = ImageField(size=(185, 37, True))$/;" v class:FileTest.test_image_field_resize_force.TestImage +image mongoengine/tests/fields/file_tests.py /^ image = ImageField(thumbnail_size=(92, 18))$/;" v class:FileTest.test_image_field_thumbnail.TestImage +image1 mongoengine/tests/fields/file_tests.py /^ image1 = ImageField()$/;" v class:FileTest.test_get_image_by_grid_id.TestImage +image2 mongoengine/tests/fields/file_tests.py /^ image2 = ImageField()$/;" v class:FileTest.test_get_image_by_grid_id.TestImage +image_path mongoengine/docs/code/tumblelog.py /^ image_path = StringField()$/;" v class:ImagePost +in_bulk mongoengine/mongoengine/queryset/base.py /^ def in_bulk(self, object_ids):$/;" m class:BaseQuerySet +in_embedded mongoengine/tests/fields/fields.py /^ in_embedded = EmbeddedDocumentField(EmbeddedOcurrence)$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence +in_embedded mongoengine/tests/fields/fields.py /^ in_embedded = EmbeddedDocumentField(EmbeddedOcurrence)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence +in_embedded tests/fields/fields.py /^ in_embedded = EmbeddedDocumentField(EmbeddedOcurrence)$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence +in_embedded tests/fields/fields.py /^ in_embedded = EmbeddedDocumentField(EmbeddedOcurrence)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence +in_list mongoengine/tests/fields/fields.py /^ in_list = ListField(GenericLazyReferenceField())$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.EmbeddedOcurrence +in_list mongoengine/tests/fields/fields.py /^ in_list = ListField(GenericLazyReferenceField())$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence +in_list mongoengine/tests/fields/fields.py /^ in_list = ListField(LazyReferenceField(Animal))$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.EmbeddedOcurrence +in_list mongoengine/tests/fields/fields.py /^ in_list = ListField(LazyReferenceField(Animal))$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence +in_list tests/fields/fields.py /^ in_list = ListField(GenericLazyReferenceField())$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.EmbeddedOcurrence +in_list tests/fields/fields.py /^ in_list = ListField(GenericLazyReferenceField())$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence +in_list tests/fields/fields.py /^ in_list = ListField(LazyReferenceField(Animal))$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.EmbeddedOcurrence +in_list tests/fields/fields.py /^ in_list = ListField(LazyReferenceField(Animal))$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence +includes_cls mongoengine/mongoengine/document.py /^def includes_cls(fields):$/;" f +info mongoengine/tests/document/delta.py /^ info = ReferenceField(UInfoDocument)$/;" v class:DeltaTest.test_delta_for_nested_map_fields.EmbeddedUser +info mongoengine/tests/fields/fields.py /^ info = DictField()$/;" v class:FieldTest.test_dict_field.BlogPost +info mongoengine/tests/fields/fields.py /^ info = ListField()$/;" v class:FieldTest.test_list_assignment.BlogPost +info mongoengine/tests/fields/fields.py /^ info = ListField()$/;" v class:FieldTest.test_list_field.BlogPost +info mongoengine/tests/fields/fields.py /^ info = ListField(StringField())$/;" v class:FieldTest.test_list_field_invalid_operators.BlogPost +info mongoengine/tests/fields/fields.py /^ info = ListField(StringField())$/;" v class:FieldTest.test_list_field_manipulative_operators.BlogPost +info mongoengine/tests/queryset/queryset.py /^ info = DictField()$/;" v class:QuerySetTest.test_find_dict_item.BlogPost +info tests/fields/fields.py /^ info = DictField()$/;" v class:FieldTest.test_dict_field.BlogPost +info tests/fields/fields.py /^ info = ListField()$/;" v class:FieldTest.test_list_assignment.BlogPost +info tests/fields/fields.py /^ info = ListField()$/;" v class:FieldTest.test_list_field.BlogPost +info tests/fields/fields.py /^ info = ListField(StringField())$/;" v class:FieldTest.test_list_field_invalid_operators.BlogPost +info tests/fields/fields.py /^ info = ListField(StringField())$/;" v class:FieldTest.test_list_field_manipulative_operators.BlogPost +info_dict mongoengine/tests/fields/fields.py /^ info_dict = MapField(field=EmbeddedDocumentField(Info))$/;" v class:FieldTest.test_map_field_unicode.BlogPost +info_dict tests/fields/fields.py /^ info_dict = MapField(field=EmbeddedDocumentField(Info))$/;" v class:FieldTest.test_map_field_unicode.BlogPost +init mongoengine/setup.py /^init = os.path.join(os.path.dirname(__file__), 'mongoengine', '__init__.py')$/;" v +insert mongoengine/mongoengine/base/datastructures.py /^ def insert(self, *args, **kwargs):$/;" m class:BaseList +insert mongoengine/mongoengine/queryset/base.py /^ def insert(self, doc_or_docs, load_bulk=True,$/;" m class:BaseQuerySet +int_field mongoengine/tests/document/delta.py /^ int_field = IntField()$/;" v class:DeltaTest.delta.Doc +int_field mongoengine/tests/document/delta.py /^ int_field = IntField()$/;" v class:DeltaTest.delta_recursive.Doc +int_field mongoengine/tests/document/delta.py /^ int_field = IntField()$/;" v class:DeltaTest.delta_recursive.Embedded +int_field mongoengine/tests/document/delta.py /^ int_field = IntField(db_field='db_int_field')$/;" v class:DeltaTest.delta_db_field.Doc +int_field mongoengine/tests/document/delta.py /^ int_field = IntField(db_field='db_int_field')$/;" v class:DeltaTest.delta_recursive_db_field.Doc +int_field mongoengine/tests/document/delta.py /^ int_field = IntField(db_field='db_int_field')$/;" v class:DeltaTest.delta_recursive_db_field.Embedded +int_field mongoengine/tests/document/instance.py /^ int_field = IntField(default=1)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +int_field mongoengine/tests/document/json_serialisation.py /^ int_field = IntField(default=1)$/;" v class:TestJson.test_json_complex.Doc +int_field mongoengine/tests/queryset/queryset.py /^ int_field = IntField(default=1)$/;" v class:QuerySetTest.test_json_complex.Doc +int_fld mongoengine/tests/document/instance.py /^ int_fld = IntField(null=True)$/;" v class:InstanceTest.test_null_field.User +int_fld mongoengine/tests/fields/fields.py /^ int_fld = IntField()$/;" v class:FieldTest.test_int_and_float_ne_operator.TestDocument +int_fld mongoengine/tests/fields/fields.py /^ int_fld = IntField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +int_fld mongoengine/tests/fields/fields.py /^ int_fld = IntField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields +int_fld tests/fields/fields.py /^ int_fld = IntField()$/;" v class:FieldTest.test_int_and_float_ne_operator.TestDocument +int_fld tests/fields/fields.py /^ int_fld = IntField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +int_fld tests/fields/fields.py /^ int_fld = IntField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields +invalid_index mongoengine/tests/document/indexes.py /^ def invalid_index():$/;" m class:IndexesTest.test_hint.BlogPost +invalid_index_2 mongoengine/tests/document/indexes.py /^ def invalid_index_2():$/;" f function:IndexesTest.test_hint +ip mongoengine/tests/queryset/queryset.py /^ ip='104.107.108.116'$/;" v class:QuerySetTest.test_as_pymongo.User +ip mongoengine/tests/queryset/queryset.py /^ ip = StringField()$/;" v class:QuerySetTest.test_as_pymongo.LastLogin +is_active mongoengine/tests/queryset/queryset.py /^ is_active=False).save()$/;" v class:QuerySetTest.test_text_indexes.News +is_active mongoengine/tests/queryset/queryset.py /^ is_active = BooleanField(default=True)$/;" v class:QuerySetTest.test_text_indexes.News +is_mamal mongoengine/tests/queryset/queryset.py /^ is_mamal = BooleanField()$/;" v class:QuerySetTest.test_subclass_field_query.Animal +is_published mongoengine/tests/queryset/queryset.py /^ is_published = BooleanField()$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +is_published mongoengine/tests/queryset/queryset.py /^ is_published = BooleanField(default=False)$/;" v class:QuerySetTest.test_custom_querysets_managers_directly.Post +is_published mongoengine/tests/queryset/queryset.py /^ is_published=True,$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +item mongoengine/tests/queryset/transform.py /^ item = EmbeddedDocumentField(EmbeddedItem)$/;" v class:TransformTest.test_last_field_name_like_operator.Doc +item_frequencies mongoengine/mongoengine/queryset/base.py /^ def item_frequencies(self, field, normalize=False, map_reduce=True):$/;" m class:BaseQuerySet +items mongoengine/mongoengine/base/datastructures.py /^ def items(self):$/;" m class:StrictDict +items mongoengine/tests/document/instance.py /^ items = ListField()$/;" v class:InstanceTest.test_reload_of_non_strict_with_special_field_name.Post +items mongoengine/tests/fields/fields.py /^ items = ListField(EnumField())$/;" v class:FieldTest.test_tuples_as_tuples.TestDoc +items mongoengine/tests/test_dereference.py /^ items = ListField(EmbeddedDocumentField("PlaylistItem"))$/;" v class:FieldTest.test_select_related_follows_embedded_referencefields.Playlist +items tests/fields/fields.py /^ items = ListField(EnumField())$/;" v class:FieldTest.test_tuples_as_tuples.TestDoc +iteritems mongoengine/mongoengine/base/datastructures.py /^ def iteritems(self):$/;" m class:StrictDict +iterkeys mongoengine/mongoengine/base/datastructures.py /^ def iterkeys(self):$/;" m class:StrictDict +job mongoengine/tests/document/instance.py /^ job = EmbeddedDocumentField(Job)$/;" v class:InstanceTest.setUp.Person +job mongoengine/tests/document/instance.py /^ job = ReferenceField(Job)$/;" v class:InstanceTest.test_do_not_save_unchanged_references.Person +john mongoengine/docs/code/tumblelog.py /^john = User(email='jdoe@example.com', first_name='John', last_name='Doe')$/;" v +key mongoengine/tests/document/indexes.py /^ key = DictField(primary_key=True)$/;" v class:IndexesTest.test_compound_key_dictfield.ReportDictField +key mongoengine/tests/document/indexes.py /^ key = EmbeddedDocumentField(CompoundKey, primary_key=True)$/;" v class:IndexesTest.test_compound_key_embedded.ReportEmbedded +key mongoengine/tests/queryset/queryset.py /^ key = StringField(primary_key=True)$/;" v class:QuerySetTest.test_scalar_primary_key.SettingValue +key_has_dot_or_dollar mongoengine/fields.py /^def key_has_dot_or_dollar(d):$/;" f +key_has_dot_or_dollar mongoengine/mongoengine/fields.py /^def key_has_dot_or_dollar(d):$/;" f +key_not_string mongoengine/fields.py /^def key_not_string(d):$/;" f +key_not_string mongoengine/mongoengine/fields.py /^def key_not_string(d):$/;" f +keys mongoengine/mongoengine/base/datastructures.py /^ def keys(self):$/;" m class:StrictDict +keywords mongoengine/tests/document/indexes.py /^ keywords = StringField()$/;" v class:IndexesTest.test_build_index_spec_is_not_destructive.MyDoc +l mongoengine/tests/document/instance.py /^ l = ListField(EmbeddedDocumentField(B))$/;" v class:InstanceTest.test_list_iter.A +last_login mongoengine/tests/queryset/queryset.py /^ last_login = EmbeddedDocumentField(LastLogin)$/;" v class:QuerySetTest.test_as_pymongo.User +last_login mongoengine/tests/queryset/queryset.py /^ last_login=LastLogin($/;" v class:QuerySetTest.test_as_pymongo.User +last_name mongoengine/docs/code/tumblelog.py /^ last_name = StringField(max_length=50)$/;" v class:User +latex_documents mongoengine/docs/conf.py /^latex_documents = [$/;" v +latex_paper_size mongoengine/docs/conf.py /^latex_paper_size = 'a4'$/;" v +like mongoengine/tests/fields/fields.py /^ like = GenericEmbeddedDocumentField()$/;" v class:FieldTest.test_generic_embedded_document.Person +like mongoengine/tests/fields/fields.py /^ like = GenericEmbeddedDocumentField(choices=(Dish,))$/;" v class:FieldTest.test_generic_embedded_document_choices.Person +like tests/fields/fields.py /^ like = GenericEmbeddedDocumentField()$/;" v class:FieldTest.test_generic_embedded_document.Person +like tests/fields/fields.py /^ like = GenericEmbeddedDocumentField(choices=(Dish,))$/;" v class:FieldTest.test_generic_embedded_document_choices.Person +likes mongoengine/tests/fields/fields.py /^ likes = ListField(GenericEmbeddedDocumentField(choices=(Dish,)))$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Person +likes tests/fields/fields.py /^ likes = ListField(GenericEmbeddedDocumentField(choices=(Dish,)))$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Person +limit mongoengine/mongoengine/queryset/base.py /^ def limit(self, n):$/;" m class:BaseQuerySet +line mongoengine/tests/fields/geo.py /^ line = LineStringField()$/;" v class:GeoFieldTest.test_indexes_2dsphere.Event +line mongoengine/tests/fields/geo.py /^ line = LineStringField()$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Venue +line mongoengine/tests/queryset/geo.py /^ line = LineStringField()$/;" v class:GeoQueriesTest.test_2dsphere_linestring_sets_correctly.Location +line mongoengine/tests/queryset/geo.py /^ line = LineStringField()$/;" v class:GeoQueriesTest.test_linestring.Road +line mongoengine/tests/queryset/transform.py /^ line = LineStringField()$/;" v class:TransformTest.test_geojson_LineStringField.Location +link_url mongoengine/docs/code/tumblelog.py /^ link_url = StringField()$/;" v class:LinkPost +list_field mongoengine/tests/document/delta.py /^ list_field = ListField()$/;" v class:DeltaTest.delta.Doc +list_field mongoengine/tests/document/delta.py /^ list_field = ListField()$/;" v class:DeltaTest.delta_recursive.Doc +list_field mongoengine/tests/document/delta.py /^ list_field = ListField()$/;" v class:DeltaTest.delta_recursive.Embedded +list_field mongoengine/tests/document/delta.py /^ list_field = ListField(db_field='db_list_field')$/;" v class:DeltaTest.delta_db_field.Doc +list_field mongoengine/tests/document/delta.py /^ list_field = ListField(db_field='db_list_field')$/;" v class:DeltaTest.delta_recursive_db_field.Doc +list_field mongoengine/tests/document/delta.py /^ list_field = ListField(db_field='db_list_field')$/;" v class:DeltaTest.delta_recursive_db_field.Embedded +list_field mongoengine/tests/document/instance.py /^ list_field = ListField()$/;" v class:InstanceTest.test_reload_referencing.Doc +list_field mongoengine/tests/document/instance.py /^ list_field = ListField()$/;" v class:InstanceTest.test_reload_referencing.Embedded +list_field mongoengine/tests/document/instance.py /^ list_field = ListField(default=lambda: [1, 2, 3])$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +list_field mongoengine/tests/document/json_serialisation.py /^ list_field = ListField(default=lambda: [1, 2, 3])$/;" v class:TestJson.test_json_complex.Doc +list_field mongoengine/tests/queryset/queryset.py /^ list_field = ListField(default=lambda: [1, 2, 3])$/;" v class:QuerySetTest.test_json_complex.Doc +list_indexes mongoengine/mongoengine/document.py /^ def list_indexes(cls):$/;" m class:Document +lists mongoengine/tests/fixtures.py /^ lists = ListField(StringField())$/;" v class:NewDocumentPickleTest +lists mongoengine/tests/fixtures.py /^ lists = ListField(StringField())$/;" v class:PickleSignalsTest +lists mongoengine/tests/fixtures.py /^ lists = ListField(StringField())$/;" v class:PickleTest +live_and_let_die mongoengine/tests/test_signals.py /^ def live_and_let_die():$/;" f function:SignalTests.test_signal_kwargs +living_thing mongoengine/tests/fields/fields.py /^ living_thing = GenericLazyReferenceField(choices=[Animal, Vegetal])$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Ocurrence +living_thing tests/fields/fields.py /^ living_thing = GenericLazyReferenceField(choices=[Animal, Vegetal])$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Ocurrence +load_existing_author mongoengine/tests/test_signals.py /^ def load_existing_author():$/;" f function:SignalTests.test_model_signals +loc mongoengine/tests/fields/geo.py /^ loc = GeoPointField()$/;" v class:GeoFieldTest.test_geopoint_validation.Location +loc mongoengine/tests/fields/geo.py /^ loc = LineStringField()$/;" v class:GeoFieldTest.test_linestring_validation.Location +loc mongoengine/tests/fields/geo.py /^ loc = MultiLineStringField()$/;" v class:GeoFieldTest.test_multilinestring_validation.Location +loc mongoengine/tests/fields/geo.py /^ loc = MultiPointField()$/;" v class:GeoFieldTest.test_multipoint_validation.Location +loc mongoengine/tests/fields/geo.py /^ loc = MultiPolygonField()$/;" v class:GeoFieldTest.test_multipolygon_validation.Location +loc mongoengine/tests/fields/geo.py /^ loc = PointField()$/;" v class:GeoFieldTest.test_point_validation.Location +loc mongoengine/tests/fields/geo.py /^ loc = PolygonField()$/;" v class:GeoFieldTest.test_polygon_validation.Location +loc mongoengine/tests/queryset/geo.py /^ loc = PointField()$/;" v class:GeoQueriesTest.test_2dsphere_point_sets_correctly.Location +loc mongoengine/tests/queryset/transform.py /^ loc = PointField()$/;" v class:TransformTest.test_geojson_PointField.Location +locale mongoengine/tests/queryset/queryset.py /^ locale=Locale(city="Belo Horizonte", country="Brazil")).save()$/;" v class:QuerySetTest.test_scalar_embedded.Person +locale mongoengine/tests/queryset/queryset.py /^ locale=Locale(city="Brasilia", country="Brazil")).save()$/;" v class:QuerySetTest.test_scalar_embedded.Person +locale mongoengine/tests/queryset/queryset.py /^ locale=Locale(city="Corumba-GO", country="Brazil")).save()$/;" v class:QuerySetTest.test_scalar_embedded.Person +locale mongoengine/tests/queryset/queryset.py /^ locale=Locale(city="New York", country="USA")).save()$/;" v class:QuerySetTest.test_scalar_embedded.Person +locale mongoengine/tests/queryset/queryset.py /^ locale = EmbeddedDocumentField(Locale)$/;" v class:QuerySetTest.test_scalar_embedded.Person +location mongoengine/tests/document/indexes.py /^ location = DictField()$/;" v class:IndexesTest.test_create_geohaystack_index.Place +location mongoengine/tests/document/indexes.py /^ location = DictField()$/;" v class:IndexesTest.test_explicit_geo2d_index.Place +location mongoengine/tests/document/indexes.py /^ location = DictField()$/;" v class:IndexesTest.test_explicit_geo2d_index_embedded.EmbeddedLocation +location mongoengine/tests/document/indexes.py /^ location = DictField()$/;" v class:IndexesTest.test_explicit_geohaystack_index.Place +location mongoengine/tests/document/indexes.py /^ location = DictField()$/;" v class:IndexesTest.test_explicit_geosphere_index.Place +location mongoengine/tests/document/instance.py /^ location = ReferenceField('Location', dbref=True)$/;" v class:InstanceTest.test_document_registry_regressions.Area +location mongoengine/tests/fields/geo.py /^ location = GeoPointField()$/;" v class:GeoFieldTest.test_geo_indexes_recursion.Location +location mongoengine/tests/fields/geo.py /^ location = GeoPointField()$/;" v class:GeoFieldTest.test_geopoint_embedded_indexes.Venue +location mongoengine/tests/fields/geo.py /^ location = GeoPointField()$/;" v class:GeoFieldTest.test_indexes_geopoint.Event +location mongoengine/tests/fields/geo.py /^ location = PointField(auto_index=False)$/;" v class:GeoFieldTest.test_geo_indexes_auto_index.Log +location mongoengine/tests/fields/geo.py /^ location = ReferenceField(Location)$/;" v class:GeoFieldTest.test_geo_indexes_recursion.Parent +location mongoengine/tests/queryset/geo.py /^ location = GeoPointField()$/;" v class:GeoQueriesTest.test_spherical_geospatial_operators.Point +location mongoengine/tests/queryset/geo.py /^ location = PointField()$/;" v class:GeoQueriesTest.test_aspymongo_with_only.Place +location mongoengine/tests/queryset/geo.py /^ location = point_field_class()$/;" v class:GeoQueriesTest._create_event_data.Event +location mongoengine/tests/queryset/geo.py /^ location = point_field_class()$/;" v class:GeoQueriesTest._test_embedded.Venue +location mongoengine/tests/queryset/geo.py /^ location=[-122.4194155, 37.7749295])$/;" v class:GeoQueriesTest._create_event_data.Event +location mongoengine/tests/queryset/geo.py /^ location=[-87.677137, 41.909889])$/;" v class:GeoQueriesTest._create_event_data.Event +location mongoengine/tests/queryset/geo.py /^ location=[-87.686638, 41.900474])$/;" v class:GeoQueriesTest._create_event_data.Event +location mongoengine/tests/queryset/queryset.py /^ location='White House',$/;" v class:QuerySetTest.test_as_pymongo.User +location mongoengine/tests/queryset/queryset.py /^ location = StringField()$/;" v class:QuerySetTest.test_as_pymongo.LastLogin +location mongoengine/tests/queryset/transform.py /^ location = GeoPointField()$/;" v class:TransformTest.test_understandable_error_raised.Event +location__max_distance mongoengine/tests/queryset/geo.py /^ location__max_distance=60 \/ earth_radius)$/;" v class:GeoQueriesTest.test_spherical_geospatial_operators.Point +location__min_distance mongoengine/tests/queryset/geo.py /^ location__min_distance=60 \/ earth_radius)$/;" v class:GeoQueriesTest.test_spherical_geospatial_operators.Point +location__within_spherical_distance mongoengine/tests/queryset/geo.py /^ location__within_spherical_distance=[$/;" v class:GeoQueriesTest.test_spherical_geospatial_operators.Point +log mongoengine/tests/document/instance.py /^ log = StringField()$/;" v class:InstanceTest.test_shard_key.LogEntry +log mongoengine/tests/document/instance.py /^ log = StringField()$/;" v class:InstanceTest.test_shard_key_primary.LogEntry +log mongoengine/tests/queryset/queryset.py /^ log = StringField()$/;" v class:QuerySetTest.test_map_reduce_custom_output.Family +log1 mongoengine/tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=d1)$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry +log1 mongoengine/tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=d1.isoformat('T'))$/;" v class:FieldTest.test_datetime_usage.LogEntry +log1 mongoengine/tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=query)$/;" v class:FieldTest.test_datetime_usage.LogEntry +log1 tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=d1)$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry +log1 tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=d1.isoformat('T'))$/;" v class:FieldTest.test_datetime_usage.LogEntry +log1 tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=query)$/;" v class:FieldTest.test_datetime_usage.LogEntry +log_message mongoengine/tests/document/instance.py /^ log_message = StringField(verbose_name="Log message",$/;" v class:InstanceTest.test_embedded_update.Page +log_message mongoengine/tests/document/instance.py /^ log_message = StringField(verbose_name="Log message",$/;" v class:InstanceTest.test_embedded_update_after_save.Page +log_message mongoengine/tests/document/instance.py /^ log_message = StringField(verbose_name="Log message",$/;" v class:InstanceTest.test_embedded_update_db_field.Page +long_fld mongoengine/tests/fields/fields.py /^ long_fld = LongField()$/;" v class:FieldTest.test_long_ne_operator.TestDocument +long_fld tests/fields/fields.py /^ long_fld = LongField()$/;" v class:FieldTest.test_long_ne_operator.TestDocument +lookup mongoengine/mongoengine/queryset/base.py /^ def lookup(obj, name):$/;" f function:BaseQuerySet._get_scalar +lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:CachedReferenceField +lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:DictField +lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:DynamicField +lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:EmbeddedDocumentField +lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:GenericEmbeddedDocumentField +lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:LazyReferenceField +lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:ReferenceField +lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:StringField +lookup_member mongoengine/mongoengine/base/fields.py /^ def lookup_member(self, member_name):$/;" m class:ComplexBaseField +lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:CachedReferenceField +lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:DictField +lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:DynamicField +lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:EmbeddedDocumentField +lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:GenericEmbeddedDocumentField +lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:LazyReferenceField +lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:ReferenceField +lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:StringField +low_score mongoengine/tests/queryset/queryset.py /^ low_score = IntField()$/;" v class:QuerySetTest.test_update_min_max.Scores +machine mongoengine/tests/document/instance.py /^ machine = StringField()$/;" v class:InstanceTest.test_shard_key.LogEntry +machine mongoengine/tests/document/instance.py /^ machine = StringField(primary_key=True)$/;" v class:InstanceTest.test_shard_key_primary.LogEntry +macros mongoengine/tests/document/instance.py /^ macros = MapField(EmbeddedDocumentField(Macro))$/;" v class:InstanceTest.test_complex_nesting_document_and_embedded_document.Parameter +main mongoengine/benchmark.py /^def main():$/;" f +map_f mongoengine/tests/queryset/queryset.py /^ map_f=map_family,$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person +map_f mongoengine/tests/queryset/queryset.py /^ map_f=map_person,$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person +map_field mongoengine/tests/document/instance.py /^ map_field = MapField(IntField(), default=lambda: {"simple": 1})$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +map_field mongoengine/tests/document/json_serialisation.py /^ map_field = MapField(IntField(), default=lambda: {"simple": 1})$/;" v class:TestJson.test_json_complex.Doc +map_field mongoengine/tests/queryset/queryset.py /^ map_field = MapField(IntField(), default=lambda: {"simple": 1})$/;" v class:QuerySetTest.test_json_complex.Doc +map_reduce mongoengine/mongoengine/queryset/base.py /^ def map_reduce(self, map_f, reduce_f, output, finalize_f=None, limit=None,$/;" m class:BaseQuerySet +mapping mongoengine/tests/fields/fields.py /^ mapping = MapField()$/;" v class:FieldTest.test_mapfield.Simple.NoDeclaredType +mapping mongoengine/tests/fields/fields.py /^ mapping = DictField()$/;" v class:FieldTest.test_complex_field_same_value_not_changed.Simple +mapping mongoengine/tests/fields/fields.py /^ mapping = DictField()$/;" v class:FieldTest.test_dictfield_complex.Simple +mapping mongoengine/tests/fields/fields.py /^ mapping = DictField(field=IntField())$/;" v class:FieldTest.test_dictfield_strict.Simple +mapping mongoengine/tests/fields/fields.py /^ mapping = DictField(field=ListField(IntField(required=True)))$/;" v class:FieldTest.test_atomic_update_dict_field.Simple +mapping mongoengine/tests/fields/fields.py /^ mapping = DictField(required=True)$/;" v class:FieldTest.test_complex_field_required.Simple +mapping mongoengine/tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_complex_field_same_value_not_changed.Simple +mapping mongoengine/tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_list_field_complex.Simple +mapping mongoengine/tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_list_field_rejects_strings.Simple +mapping mongoengine/tests/fields/fields.py /^ mapping = ListField(field=IntField())$/;" v class:FieldTest.test_list_field_strict.Simple +mapping mongoengine/tests/fields/fields.py /^ mapping = ListField(required=True)$/;" v class:FieldTest.test_complex_field_required.Simple +mapping mongoengine/tests/fields/fields.py /^ mapping = MapField(EmbeddedDocumentField(SettingBase))$/;" v class:FieldTest.test_complex_mapfield.Extensible +mapping mongoengine/tests/fields/fields.py /^ mapping = MapField(IntField())$/;" v class:FieldTest.test_mapfield.Simple +mapping tests/fields/fields.py /^ mapping = MapField()$/;" v class:FieldTest.test_mapfield.Simple.NoDeclaredType +mapping tests/fields/fields.py /^ mapping = DictField()$/;" v class:FieldTest.test_complex_field_same_value_not_changed.Simple +mapping tests/fields/fields.py /^ mapping = DictField()$/;" v class:FieldTest.test_dictfield_complex.Simple +mapping tests/fields/fields.py /^ mapping = DictField(field=IntField())$/;" v class:FieldTest.test_dictfield_strict.Simple +mapping tests/fields/fields.py /^ mapping = DictField(field=ListField(IntField(required=True)))$/;" v class:FieldTest.test_atomic_update_dict_field.Simple +mapping tests/fields/fields.py /^ mapping = DictField(required=True)$/;" v class:FieldTest.test_complex_field_required.Simple +mapping tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_complex_field_same_value_not_changed.Simple +mapping tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_list_field_complex.Simple +mapping tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_list_field_rejects_strings.Simple +mapping tests/fields/fields.py /^ mapping = ListField(field=IntField())$/;" v class:FieldTest.test_list_field_strict.Simple +mapping tests/fields/fields.py /^ mapping = ListField(required=True)$/;" v class:FieldTest.test_complex_field_required.Simple +mapping tests/fields/fields.py /^ mapping = MapField(EmbeddedDocumentField(SettingBase))$/;" v class:FieldTest.test_complex_mapfield.Extensible +mapping tests/fields/fields.py /^ mapping = MapField(IntField())$/;" v class:FieldTest.test_mapfield.Simple +master_doc mongoengine/docs/conf.py /^master_doc = 'index'$/;" v +max_time_ms mongoengine/mongoengine/queryset/base.py /^ def max_time_ms(self, ms):$/;" m class:BaseQuerySet +max_value mongoengine/tests/fields/fields.py /^ max_value=Decimal('3.5'))$/;" v class:FieldTest.test_decimal_validation.Person +max_value tests/fields/fields.py /^ max_value=Decimal('3.5'))$/;" v class:FieldTest.test_decimal_validation.Person +member mongoengine/tests/queryset/queryset.py /^ member = EmbeddedDocumentField(Member)$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Organization +members mongoengine/tests/fields/fields.py /^ members = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_item_dereference.Group +members mongoengine/tests/queryset/queryset.py /^ members = DictField()$/;" v class:QuerySetTest.test_dictfield_update.Club +members mongoengine/tests/queryset/queryset.py /^ members = ListField(EmbeddedDocumentField(Member))$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Organization +members mongoengine/tests/queryset/queryset.py /^ members = ListField(ReferenceField(self.Person))$/;" v class:QuerySetTest.test_update_value_conversion.Group +members mongoengine/tests/queryset/queryset.py /^ members = MapField(EmbeddedDocumentField(Member))$/;" v class:QuerySetTest.test_mapfield_update.Club +members mongoengine/tests/test_context_managers.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:ContextManagersTest.test_no_dereference_context_manager_object_id.Group +members mongoengine/tests/test_context_managers.py /^ members = ListField(ReferenceField(User, dbref=True))$/;" v class:ContextManagersTest.test_no_dereference_context_manager_dbref.Group +members mongoengine/tests/test_dereference.py /^ members = DictField()$/;" v class:FieldTest.test_dict_field.Group +members mongoengine/tests/test_dereference.py /^ members = DictField()$/;" v class:FieldTest.test_dict_field_no_field_inheritance.Group +members mongoengine/tests/test_dereference.py /^ members = ListField()$/;" v class:FieldTest.test_list_field_complex.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_item_dereference.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:FieldTest.test_handle_old_style_references.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:FieldTest.test_list_item_dereference_dref_false.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:FieldTest.test_list_item_dereference_dref_false_stores_as_type.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:FieldTest.test_migrate_references.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=True))$/;" v class:FieldTest.test_handle_old_style_references.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=True))$/;" v class:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries.Group +members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=True))$/;" v class:FieldTest.test_migrate_references.Group +members mongoengine/tests/test_dereference.py /^ members = MapField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_map_field.Group +members mongoengine/tests/test_dereference.py /^ members = MapField(ReferenceField(User))$/;" v class:FieldTest.test_map_field_reference.Group +members tests/fields/fields.py /^ members = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_item_dereference.Group +merge mongoengine/mongoengine/base/metaclasses.py /^ def merge(self, new_options):$/;" m class:MetaDict +merge_index_specs mongoengine/mongoengine/base/document.py /^ def merge_index_specs(index_specs, indices):$/;" f function:BaseDocument._build_index_specs +message mongoengine/mongoengine/errors.py /^ message = property(_get_message, _set_message)$/;" v class:ValidationError +message mongoengine/tests/fields/fields.py /^ message = StringField()$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.Comments +message mongoengine/tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents.UserComments +message mongoengine/tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments +message mongoengine/tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.ModeratorComments +message mongoengine/tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.UserComments +message mongoengine/tests/queryset/queryset.py /^ message = StringField()$/;" v class:QuerySetTest.test_ensure_index.Comment +message tests/fields/fields.py /^ message = StringField()$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.Comments +message tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents.UserComments +message tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments +message tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.ModeratorComments +message tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.UserComments +meta mongoengine/docs/code/tumblelog.py /^ meta = {'allow_inheritance': True}$/;" v class:Post +meta mongoengine/tests/all_warnings/__init__.py /^ meta = {'allow_inheritance': True}$/;" v class:AllWarnings.test_document_collection_syntax_warning.NonAbstractBase +meta mongoengine/tests/all_warnings/__init__.py /^ meta = {'collection': 'fail'}$/;" v class:AllWarnings.test_document_collection_syntax_warning.InheritedDocumentFailTest +meta mongoengine/tests/document/class_methods.py /^ meta = {"allow_inheritance": True, "indexes": ["family"]}$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Animal +meta mongoengine/tests/document/class_methods.py /^ meta = {"allow_inheritance": True}$/;" v class:ClassMethodsTest.setUp.Person +meta mongoengine/tests/document/class_methods.py /^ meta = {"indexes": ["name"]}$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Vaccine +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_collection_naming.BaseDocument +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_collection_naming.BaseMixin +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes.BlogPost +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPost +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPostWithTags +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPost +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPostWithCustomField +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPostWithTags +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPost +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPostWithTags +meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPostWithTagsAndExtraText +meta mongoengine/tests/document/class_methods.py /^ meta = {'allow_inheritance': True}$/;" v class:ClassMethodsTest.test_collection_naming.BaseDocument +meta mongoengine/tests/document/class_methods.py /^ meta = {'collection': 'app'}$/;" v class:ClassMethodsTest.test_collection_name_and_primary.Person +meta mongoengine/tests/document/class_methods.py /^ meta = {'collection': 'pimp_my_collection'}$/;" v class:ClassMethodsTest.test_collection_naming.CustomNamingTest +meta mongoengine/tests/document/class_methods.py /^ meta = {'collection': 'wibble'}$/;" v class:ClassMethodsTest.test_collection_naming.InheritedAbstractNamingTest +meta mongoengine/tests/document/class_methods.py /^ meta = {'collection': collection_name}$/;" v class:ClassMethodsTest.test_custom_collection_name_operations.Person +meta mongoengine/tests/document/class_methods.py /^ meta = {'collection': lambda c: "DYNAMO"}$/;" v class:ClassMethodsTest.test_collection_naming.DynamicNamingTest +meta mongoengine/tests/document/delta.py /^ meta = {"allow_inheritance": True}$/;" v class:DeltaTest.setUp.Person +meta mongoengine/tests/document/delta.py /^ meta = {'allow_inheritance': True}$/;" v class:DeltaTest.test_delta_for_dynamic_documents.Person +meta mongoengine/tests/document/dynamic.py /^ meta = {'allow_inheritance': True}$/;" v class:DynamicTest.setUp.Person +meta mongoengine/tests/document/indexes.py /^ meta = {'indexes': [$/;" v class:IndexesTest.test_index_with_pk.Comment.BlogPost +meta mongoengine/tests/document/indexes.py /^ meta = {"allow_inheritance": True}$/;" v class:IndexesTest.setUp.Person +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest._index_test.BlogPost +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest._index_test_inheritance.BlogPost +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_abstract_index_inheritance.Person +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_abstract_index_inheritance.UserBase +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_build_index_spec_is_not_destructive.MyDoc +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_compound_index_underscore_cls_not_overwritten.TestDoc +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_covered_index.Test +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_dictionary_indexes.BlogPost +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_disable_index_creation.User +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_embedded_document_index.BlogPost +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_embedded_document_index_meta.Person +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_explicit_geo2d_index.Place +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_explicit_geo2d_index_embedded.Place +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_explicit_geohaystack_index.Place +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_explicit_geosphere_index.Place +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_hashed_indexes.Book +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_hint.BlogPost +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_index_dont_send_cls_option.TestChildDoc +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_index_dont_send_cls_option.TestDoc +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_index_no_cls.A +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_index_no_cls.B +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_index_on_id.BlogPost +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_inherited_index.A +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_list_embedded_document_index.BlogPost +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_sparse_compound_indexes.MyDoc +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_string_indexes.MyDoc +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_text_indexes.Book +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_ttl_indexes.Log +meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_unique_and_indexes.Customer +meta mongoengine/tests/document/indexes.py /^ meta = {'allow_inheritance': True}$/;" v class:IndexesTest.test_recursive_embedded_objects_dont_break_indexes.RecursiveDocument +meta mongoengine/tests/document/indexes.py /^ meta = {'db_alias': 'test_indexes_after_database_drop'}$/;" v class:IndexesTest.test_indexes_after_database_drop.BlogPost +meta mongoengine/tests/document/indexes.py /^ meta = {'indexes': ['title']}$/;" v class:IndexesTest._index_test_inheritance.ExtendedBlogPost +meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True}$/;" v class:InheritanceTest.test_abstract_documents.Human.EvilHuman +meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': False}$/;" v class:InheritanceTest.test_cant_turn_off_inheritance_on_subclass.Animal.Mammal +meta mongoengine/tests/document/inheritance.py /^ meta = {'collection': 'booze'}$/;" v class:InheritanceTest.test_inherited_collections.Drinker.AcloholicDrink +meta mongoengine/tests/document/inheritance.py /^ meta = {'collection': 'booze'}$/;" v class:InheritanceTest.test_inherited_collections.Drinker.AlcoholicDrink +meta mongoengine/tests/document/inheritance.py /^ meta = meta_settings$/;" v class:InheritanceTest.test_abstract_documents.Animal +meta mongoengine/tests/document/inheritance.py /^ meta = {"abstract": True}$/;" v class:InheritanceTest.test_abstract_embedded_documents.A +meta mongoengine/tests/document/inheritance.py /^ meta = {$/;" v class:InheritanceTest.test_document_inheritance.DateCreatedDocument +meta mongoengine/tests/document/inheritance.py /^ meta = {$/;" v class:InheritanceTest.test_document_inheritance.DateUpdatedDocument +meta mongoengine/tests/document/inheritance.py /^ meta = {$/;" v class:InheritanceTest.test_indexes_and_multiple_inheritance.A +meta mongoengine/tests/document/inheritance.py /^ meta = {$/;" v class:InheritanceTest.test_indexes_and_multiple_inheritance.B +meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True,$/;" v class:InheritanceTest.test_abstract_document_creation_does_not_fail.City +meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True,$/;" v class:InheritanceTest.test_abstract_handle_ids_in_metaclass_properly.City +meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True,$/;" v class:InheritanceTest.test_allow_inheritance_abstract_document.FinalDocument +meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True,$/;" v class:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class.City +meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True,$/;" v class:InheritanceTest.test_auto_id_vs_non_pk_id_field.City +meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True}$/;" v class:InheritanceTest.test_abstract_documents.Mammal +meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_allow_inheritance_embedded_document.Comment +meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_cant_turn_off_inheritance_on_subclass.Animal +meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_dynamic_declarations.Animal +meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_inheritance_meta_data.Person +meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_inheritance_to_mongo_keys.Person +meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_inherited_collections.Drink +meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_polymorphic_queries.Animal +meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_subclasses.Animal +meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_superclasses.Animal +meta mongoengine/tests/document/instance.py /^ meta = dict(shard_key=["id"])$/;" v class:InstanceTest.test_from_son.MyPerson +meta mongoengine/tests/document/instance.py /^ meta = {"allow_inheritance": True}$/;" v class:InstanceTest.setUp.Person +meta mongoengine/tests/document/instance.py /^ meta = {"allow_inheritance": True}$/;" v class:InstanceTest.test_db_alias_overrides.A +meta mongoengine/tests/document/instance.py /^ meta = {"allow_inheritance": True}$/;" v class:InstanceTest.test_embedded_document_to_mongo.Person +meta mongoengine/tests/document/instance.py /^ meta = {"db_alias": "testdb-1", "allow_inheritance": True}$/;" v class:InstanceTest.test_db_alias_propagates.A +meta mongoengine/tests/document/instance.py /^ meta = {"db_alias": "testdb-1"}$/;" v class:InstanceTest.test_db_alias_tests.User +meta mongoengine/tests/document/instance.py /^ meta = {"db_alias": "testdb-2"}$/;" v class:InstanceTest.test_db_alias_overrides.B +meta mongoengine/tests/document/instance.py /^ meta = {"db_alias": "testdb-2"}$/;" v class:InstanceTest.test_db_alias_tests.Book +meta mongoengine/tests/document/instance.py /^ meta = {"db_alias": "testdb-3"}$/;" v class:InstanceTest.test_db_alias_tests.AuthorBooks +meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_capped_collection.Log +meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_capped_collection_default.Log +meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_capped_collection_no_max_size_problems.Log +meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_db_ref_usage.Book +meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_reload_of_non_strict_with_special_field_name.Post +meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_shard_key.LogEntry +meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_shard_key_in_embedded_document.Bar +meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_shard_key_primary.LogEntry +meta mongoengine/tests/document/instance.py /^ meta = {'abstract': True}$/;" v class:InstanceTest.test_save_abstract_document.Doc +meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': False,$/;" v class:InstanceTest.test_list_search_by_embedded.Page +meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': False}$/;" v class:InstanceTest.test_document_embedded_clean.TestEmbeddedDocument +meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': False}$/;" v class:InstanceTest.test_list_search_by_embedded.Comment +meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': False}$/;" v class:InstanceTest.test_list_search_by_embedded.User +meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': False}$/;" v class:InstanceTest.test_reference_inheritance.Stats +meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': True}$/;" v class:InstanceTest.test_custom_id_field.User +meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': True}$/;" v class:InstanceTest.test_document_not_registered.Place +meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': True}$/;" v class:InstanceTest.test_document_registry_regressions.Location +meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': True}$/;" v class:InstanceTest.test_polymorphic_references.Animal +meta mongoengine/tests/document/instance.py /^ meta = {'cascade': False}$/;" v class:InstanceTest.test_save_cascade_meta_false.Person +meta mongoengine/tests/document/instance.py /^ meta = {'cascade': False}$/;" v class:InstanceTest.test_save_cascade_meta_true.Person +meta mongoengine/tests/document/instance.py /^ meta = {'collection': 'blogpost_1'}$/;" v class:InstanceTest.test_save_reference.BlogPost +meta mongoengine/tests/document/instance.py /^ meta = {'shard_key': ('superphylum',)}$/;" v class:InstanceTest.test_reload_sharded.Animal +meta mongoengine/tests/document/instance.py /^ meta = {'shard_key': ('superphylum.name',)}$/;" v class:InstanceTest.test_reload_sharded_nested.Animal +meta mongoengine/tests/document/instance.py /^ meta = {'strict': False}$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false.Thing +meta mongoengine/tests/document/instance.py /^ meta = {'strict': False}$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc.User +meta mongoengine/tests/document/instance.py /^ meta = {'strict': False}$/;" v class:InstanceTest.test_load_undefined_fields_with_strict_false.User +meta mongoengine/tests/document/validation.py /^ meta = {'abstract': True}$/;" v class:ValidatorErrorTest.test_fields_rewrite.BasePerson +meta mongoengine/tests/document/validation.py /^ meta = {'allow_inheritance': True}$/;" v class:ValidatorErrorTest.test_parent_reference_in_child_document.Parent +meta mongoengine/tests/document/validation.py /^ meta = {'allow_inheritance': True}$/;" v class:ValidatorErrorTest.test_parent_reference_set_as_attribute_in_child_document.Parent +meta mongoengine/tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_abstract_reference_base_type.Sibling +meta mongoengine/tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_drop_abstract_document.AbstractDoc +meta mongoengine/tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_reference_abstract_class.Sibling +meta mongoengine/tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Sibling +meta mongoengine/tests/fields/fields.py /^ meta = {"allow_inheritance": True}$/;" v class:FieldTest.test_complex_mapfield.SettingBase +meta mongoengine/tests/fields/fields.py /^ meta = {$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments +meta mongoengine/tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Basedoc +meta mongoengine/tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_inherited_sequencefield.Base +meta mongoengine/tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_no_inherited_sequencefield.Base +meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_generic_reference.Link +meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_cls_field.Animal +meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dictfield_complex.SettingBase +meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent +meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent +meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_embedded_document_inheritance.User +meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_list_field_complex.SettingBase +meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal +meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal +meta mongoengine/tests/fields/fields.py /^ meta = {'strict': False}$/;" v class:FieldTest.test_undefined_field_exception_with_strict.Doc +meta mongoengine/tests/fields/geo.py /^ meta = {$/;" v class:GeoFieldTest.test_geo_indexes_auto_index.Log +meta mongoengine/tests/fixtures.py /^ meta = {'allow_inheritance': True}$/;" v class:Base +meta mongoengine/tests/queryset/field_list.py /^ meta = {'allow_inheritance': True}$/;" v class:OnlyExcludeAllTest.setUp.Person +meta mongoengine/tests/queryset/field_list.py /^ meta = {'allow_inheritance': True}$/;" v class:OnlyExcludeAllTest.test_exclude_from_subclasses_docs.Base +meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_bool_with_ordering_from_meta_dict.Person +meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_clear_ordering.BlogPost +meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_cls_query_in_subclassed_docs.Animal +meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_no_ordering_for_get.BlogPost +meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_ordering.BlogPost +meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_read_preference.Bar +meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True, 'queryset_class': CustomQuerySet}$/;" v class:QuerySetTest.test_custom_querysets_inherited.Base +meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True}$/;" v class:QuerySetTest.test_custom_querysets_inherited_direct.Base +meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True}$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_on_abstract_document.AbstractBlogPost +meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True}$/;" v class:QuerySetTest.test_reverse_delete_rule_deny_on_abstract_document.AbstractBlogPost +meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True}$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify_on_abstract_document.AbstractBlogPost +meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True}$/;" v class:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents.AbstractBlogPost +meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': False}$/;" v class:QuerySetTest.test_elem_match.Bar +meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': False}$/;" v class:QuerySetTest.test_elem_match.Foo +meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.setUp.Person +meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_ensure_index.Comment +meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_inherit_objects.Foo +meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_inherit_objects_override.Foo +meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_no_sub_classes.A +meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_subclass_field_query.Animal +meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_upsert_includes_cls.Test +meta mongoengine/tests/queryset/queryset.py /^ meta = {'collection': 'b'}$/;" v class:QuerySetTest.test_save_and_only_on_fields_with_default.B +meta mongoengine/tests/queryset/queryset.py /^ meta = {'db_alias': 'testdb'}$/;" v class:QuerySetTest.test_distinct_handles_references_to_alias.Bar +meta mongoengine/tests/queryset/queryset.py /^ meta = {'db_alias': 'testdb'}$/;" v class:QuerySetTest.test_distinct_handles_references_to_alias.Foo +meta mongoengine/tests/queryset/queryset.py /^ meta = {'indexes': [$/;" v class:QuerySetTest.test_text_indexes.News +meta mongoengine/tests/queryset/queryset.py /^ meta = {'queryset_class': CustomQuerySet}$/;" v class:QuerySetTest.test_custom_querysets.Post +meta mongoengine/tests/queryset/transform.py /^ meta = {$/;" v class:TransformTest.test_raw_query_and_Q_objects.Foo +meta mongoengine/tests/queryset/transform.py /^ meta = {'allow_inheritance': False}$/;" v class:TransformTest.test_raw_and_merging.Doc +meta mongoengine/tests/queryset/visitor.py /^ meta = {'allow_inheritance': True}$/;" v class:QTest.setUp.Person +meta mongoengine/tests/test_context_managers.py /^ meta = {'allow_inheritance': True}$/;" v class:ContextManagersTest.test_no_sub_classes.A +meta mongoengine/tests/test_dereference.py /^ meta = {"db_alias": "testdb-1"}$/;" v class:FieldTest.test_objectid_reference_across_databases.User +meta mongoengine/tests/test_dereference.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_dict_field_no_field_inheritance.UserA +meta mongoengine/tests/test_dereference.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_document_reload_no_inheritance.Bar +meta mongoengine/tests/test_dereference.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_document_reload_no_inheritance.Baz +meta mongoengine/tests/test_dereference.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_document_reload_no_inheritance.Foo +meta mongoengine/tests/test_dereference.py /^ meta = {'collection': 'pages'}$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Page +meta mongoengine/tests/test_dereference.py /^ meta = {'collection': 'tags'}$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Tag +meta tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_abstract_reference_base_type.Sibling +meta tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_drop_abstract_document.AbstractDoc +meta tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_reference_abstract_class.Sibling +meta tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Sibling +meta tests/fields/fields.py /^ meta = {"allow_inheritance": True}$/;" v class:FieldTest.test_complex_mapfield.SettingBase +meta tests/fields/fields.py /^ meta = {$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments +meta tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Basedoc +meta tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_inherited_sequencefield.Base +meta tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_no_inherited_sequencefield.Base +meta tests/fields/fields.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_generic_reference.Link +meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_cls_field.Animal +meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dictfield_complex.SettingBase +meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent +meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent +meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_embedded_document_inheritance.User +meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_list_field_complex.SettingBase +meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal +meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal +meta tests/fields/fields.py /^ meta = {'strict': False}$/;" v class:FieldTest.test_undefined_field_exception_with_strict.Doc +modify mongoengine/mongoengine/document.py /^ def modify(self, query=None, **update):$/;" m class:Document +modify mongoengine/mongoengine/queryset/base.py /^ def modify(self, upsert=False, full_response=False, remove=False, new=False, **update):$/;" m class:BaseQuerySet +money mongoengine/tests/fields/fields.py /^ money = DecimalField()$/;" v class:FieldTest.test_decimal_comparison.Person +money tests/fields/fields.py /^ money = DecimalField()$/;" v class:FieldTest.test_decimal_comparison.Person +mother mongoengine/tests/document/instance.py /^ mother = ReferenceField('Person', reverse_delete_rule=DENY)$/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Parents +msg mongoengine/tests/test_dereference.py /^ msg = StringField(required=True, default='Blammo!')$/;" v class:FieldTest.test_document_reload_no_inheritance.Bar +msg mongoengine/tests/test_dereference.py /^ msg = StringField(required=True, default='Kaboom!')$/;" v class:FieldTest.test_document_reload_no_inheritance.Baz +music_posts mongoengine/tests/queryset/queryset.py /^ def music_posts(doc_cls, queryset, deleted=False):$/;" m class:QuerySetTest.test_custom_manager.BlogPost +my_id mongoengine/tests/fields/fields.py /^ my_id = IntField(required=True, unique=True, primary_key=True)$/;" v class:FieldTest.test_dynamic_fields_class.Doc +my_id mongoengine/tests/fields/fields.py /^ my_id = IntField(required=True, unique=True, primary_key=True)$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc +my_id mongoengine/tests/test_dereference.py /^ my_id = IntField(primary_key=True)$/;" v class:FieldTest.test_list_item_dereference_dref_false_stores_as_type.User +my_id tests/fields/fields.py /^ my_id = IntField(required=True, unique=True, primary_key=True)$/;" v class:FieldTest.test_dynamic_fields_class.Doc +my_id tests/fields/fields.py /^ my_id = IntField(required=True, unique=True, primary_key=True)$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc +my_list mongoengine/tests/fields/fields.py /^ my_list = ListField(EmbeddedDocumentField(EmbeddedWithSparseUnique))$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.B +my_list mongoengine/tests/fields/fields.py /^ my_list = ListField(EmbeddedDocumentField(EmbeddedWithUnique))$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.A +my_list tests/fields/fields.py /^ my_list = ListField(EmbeddedDocumentField(EmbeddedWithSparseUnique))$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.B +my_list tests/fields/fields.py /^ my_list = ListField(EmbeddedDocumentField(EmbeddedWithUnique))$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.A +my_map mongoengine/tests/fields/fields.py /^ my_map = MapField(EmbeddedDocumentField(Embedded))$/;" v class:FieldTest.test_mapfield_numerical_index.Test +my_map mongoengine/tests/fields/fields.py /^ my_map = MapField(field=EmbeddedDocumentField(Embedded),$/;" v class:FieldTest.test_embedded_mapfield_db_field.Test +my_map tests/fields/fields.py /^ my_map = MapField(EmbeddedDocumentField(Embedded))$/;" v class:FieldTest.test_mapfield_numerical_index.Test +my_map tests/fields/fields.py /^ my_map = MapField(field=EmbeddedDocumentField(Embedded),$/;" v class:FieldTest.test_embedded_mapfield_db_field.Test +my_metaclass mongoengine/mongoengine/document.py /^ my_metaclass = DocumentMetaclass$/;" v class:DynamicEmbeddedDocument +my_metaclass mongoengine/mongoengine/document.py /^ my_metaclass = DocumentMetaclass$/;" v class:EmbeddedDocument +my_metaclass mongoengine/mongoengine/document.py /^ my_metaclass = TopLevelDocumentMetaclass$/;" v class:Document +my_metaclass mongoengine/mongoengine/document.py /^ my_metaclass = TopLevelDocumentMetaclass$/;" v class:DynamicDocument +n mongoengine/tests/queryset/field_list.py /^ n = ListField(IntField())$/;" v class:OnlyExcludeAllTest.test_slicing_fields.Numbers +n mongoengine/tests/queryset/field_list.py /^ n = ListField(IntField())$/;" v class:OnlyExcludeAllTest.test_slicing_nested_fields.EmbeddedNumber +n mongoengine/tests/queryset/queryset.py /^ n = IntField()$/;" v class:QuerySetTest.test_clone.Number +n mongoengine/tests/queryset/queryset.py /^ n = IntField()$/;" v class:QuerySetTest.test_order_then_filter.Number +n mongoengine/tests/queryset/queryset.py /^ n = IntField()$/;" v class:QuerySetTest.test_using.Number2 +n mongoengine/tests/queryset/queryset.py /^ n = IntField(db_field='number')$/;" v class:QuerySetTest.test_order_works_with_custom_db_field_names.Number +n mongoengine/tests/queryset/queryset.py /^ n = IntField(primary_key=True)$/;" v class:QuerySetTest.test_order_works_with_primary.Number +name mongoengine/docs/code/tumblelog.py /^ name = StringField(max_length=120)$/;" v class:Comment +name mongoengine/mongoengine/base/fields.py /^ name = None$/;" v class:BaseField +name mongoengine/tests/document/class_methods.py /^ name = StringField()$/;" v class:ClassMethodsTest.setUp.Person +name mongoengine/tests/document/class_methods.py /^ name = StringField()$/;" v class:ClassMethodsTest.test_custom_collection_name_operations.Person +name mongoengine/tests/document/class_methods.py /^ name = StringField(primary_key=True)$/;" v class:ClassMethodsTest.test_collection_name_and_primary.Person +name mongoengine/tests/document/class_methods.py /^ name = StringField(required=True)$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Cat +name mongoengine/tests/document/class_methods.py /^ name = StringField(required=True)$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Vaccine +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.circular_reference_deltas.Organization +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.circular_reference_deltas.Person +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.circular_reference_deltas_2.Organization +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.circular_reference_deltas_2.Person +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.setUp.Person +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_delta_for_dynamic_documents.Person +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_delta_for_nested_map_fields.EmbeddedUser +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_lower_level_mark_as_changed.EmbeddedDoc +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_nested_nested_fields_mark_as_changed.EmbeddedDoc +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_nested_nested_fields_mark_as_changed.MyDoc +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_referenced_object_changed_attributes.Organization +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_referenced_object_changed_attributes.User +name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_upper_level_mark_as_changed.EmbeddedDoc +name mongoengine/tests/document/dynamic.py /^ name = StringField()$/;" v class:DynamicTest.setUp.Person +name mongoengine/tests/document/dynamic.py /^ name = StringField()$/;" v class:DynamicTest.test_complex_dynamic_document_queries.Person +name mongoengine/tests/document/dynamic.py /^ name = StringField()$/;" v class:DynamicTest.test_dynamic_and_embedded.Person +name mongoengine/tests/document/dynamic.py /^ name = StringField()$/;" v class:DynamicTest.test_dynamic_and_embedded_dict_access.Person +name mongoengine/tests/document/indexes.py /^ name = StringField()$/;" v class:IndexesTest.setUp.Person +name mongoengine/tests/document/indexes.py /^ name = StringField()$/;" v class:IndexesTest.test_abstract_index_inheritance.Person +name mongoengine/tests/document/indexes.py /^ name = StringField()$/;" v class:IndexesTest.test_create_geohaystack_index.Place +name mongoengine/tests/document/indexes.py /^ name = StringField()$/;" v class:IndexesTest.test_explicit_geohaystack_index.Place +name mongoengine/tests/document/indexes.py /^ name = StringField(db_field='tag')$/;" v class:IndexesTest.test_list_embedded_document_index.Tag +name mongoengine/tests/document/indexes.py /^ name = StringField(primary_key=True)$/;" v class:IndexesTest.test_unique_and_primary_create.User +name mongoengine/tests/document/indexes.py /^ name = StringField(primary_key=True, unique=True)$/;" v class:IndexesTest.test_unique_and_primary.User +name mongoengine/tests/document/indexes.py /^ name = StringField(required=True)$/;" v class:IndexesTest.test_compound_key_embedded.CompoundKey +name mongoengine/tests/document/indexes.py /^ name = StringField(required=True)$/;" v class:IndexesTest.test_embedded_document_index_meta.Person +name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_abstract_documents.Animal +name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_abstract_handle_ids_in_metaclass_properly.EuropeanCity +name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_allow_inheritance.Animal +name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_allow_inheritance_abstract_document.Animal +name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class.EuropeanCity +name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_auto_id_vs_non_pk_id_field.EuropeanCity +name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_cant_turn_off_inheritance_on_subclass.Animal +name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_inheritance_meta_data.Person +name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_inheritance_to_mongo_keys.Person +name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_inherited_collections.Drink +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_duplicate_db_fields_raise_invalid_document_error.Foo +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.setUp.Job +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.setUp.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_custom_id_field.User +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_data_contains_id_field.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_alias_overrides.A +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_alias_propagates.A +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_alias_tests.Book +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_alias_tests.User +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_ref_usage.Book +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_ref_usage.User +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_dbref_equality.Test +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_dbref_equality.Test2 +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_dbref_equality.Test3 +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_default_values.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_do_not_save_unchanged_references.Job +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_do_not_save_unchanged_references.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_document_not_registered.Place +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_document_registry_regressions.Location +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_embedded_document_to_mongo.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_kwargs_complex.Embedded +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_kwargs_simple.Embedded +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields.User +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document.Thing +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document.User +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false.Thing +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false.User +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc.Thing +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc.User +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_with_strict_false.User +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_mixed_creation_dynamic.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_null_field.User +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_object_mixins.NameMixin +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_query_count_when_saving.Feed +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_query_count_when_saving.Organization +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_query_count_when_saving.User +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_reload_sharded_nested.SuperPhylum +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_pull.Record +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_abstract_document.Doc +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_cascade_kwargs.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_cascade_meta_false.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_cascade_meta_true.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_cascades.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_cascades_generically.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_max_recursion_not_hit.Person +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_max_recursion_not_hit_with_file_field.Foo +name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_switch_db_instance.Group +name mongoengine/tests/document/instance.py /^ name = StringField(primary_key=True)$/;" v class:InstanceTest.test_reverse_delete_rule_with_custom_id_field.User +name mongoengine/tests/document/instance.py /^ name = StringField(required=True)$/;" v class:InstanceTest.test_complex_nesting_document_and_embedded_document.NodesSystem +name mongoengine/tests/document/instance.py /^ name = StringField(required=True)$/;" v class:InstanceTest.test_db_embedded_doc_field_load.Person +name mongoengine/tests/document/instance.py /^ name = StringField(required=True)$/;" v class:InstanceTest.test_db_field_load.Person +name mongoengine/tests/document/instance.py /^ name = StringField(unique=True)$/;" v class:InstanceTest.test_update_unique_field.Doc +name mongoengine/tests/document/validation.py /^ name = StringField()$/;" v class:ValidatorErrorTest.test_fields_rewrite.BasePerson +name mongoengine/tests/document/validation.py /^ name = StringField(required=True)$/;" v class:ValidatorErrorTest.test_fields_rewrite.Person +name mongoengine/tests/document/validation.py /^ name = StringField(required=True)$/;" v class:ValidatorErrorTest.test_model_validation.User +name mongoengine/tests/fields/fields.py /^ name="Wilson Júnior")$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields_on_embedded_documents.Test +name mongoengine/tests/fields/fields.py /^ name = StringField(db_field='$name')$/;" v class:FieldTest.test_db_field_validation.User +name mongoengine/tests/fields/fields.py /^ name = StringField(db_field='name\\0')$/;" v class:FieldTest.test_db_field_validation.User +name mongoengine/tests/fields/fields.py /^ name = StringField(db_field='user.name')$/;" v class:FieldTest.test_db_field_validation.User +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Owner +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.PersonAuto +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields.Product +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Group +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_abstract_reference_base_type.Mother +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_abstract_reference_base_type.Sibling +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_dbref_reference_fields.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_dbref_to_mongo.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_nothing_set.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_set_to_None.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_when_deleting_value.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_drop_abstract_document.AbstractDoc +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance.User +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Group +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_validation.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document.Car +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Car +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Car +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_is_none.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_inherited_sequencefield.Base +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference.User +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_map_field_lookup.Log +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_mapfield_numerical_index.Embedded +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Base +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_object_id_validation.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_objectid_reference_fields.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_embedding.Tree +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_embedding.TreeNode +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_reference.Employee +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_abstract_class.Sibling +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Sibling +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_validation.User +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reverse_list_sorting.Category +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reverse_list_sorting.CategoryList +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_get_next_value.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_sequence_name.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_value_decorator.Person +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_fields_reload.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_undefined_reference.Company +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_undefined_reference.Product +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Mineral +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Vegetal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_equality.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Animal +name mongoengine/tests/fields/fields.py /^ name = StringField(max_length=20)$/;" v class:FieldTest.test_string_validation.Person +name mongoengine/tests/fields/fields.py /^ name = StringField(required=False, unique=True, sparse=True)$/;" v class:FieldTest.test_sparse_field.Doc +name mongoengine/tests/fields/fields.py /^ name = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Author +name mongoengine/tests/fields/fields.py /^ name = StringField(required=True)$/;" v class:FieldTest.test_required_values.Person +name mongoengine/tests/fields/fields.py /^ name='Steve',$/;" v class:FieldTest.test_dbref_to_mongo.Person +name mongoengine/tests/fields/file_tests.py /^ name="hello.txt")$/;" v class:FileTest.test_file_multidb.TestFile +name mongoengine/tests/fields/file_tests.py /^ name = StringField()$/;" v class:FileTest.test_copyable.TestFile +name mongoengine/tests/fields/file_tests.py /^ name = StringField()$/;" v class:FileTest.test_file_multidb.TestFile +name mongoengine/tests/fields/file_tests.py /^ name = StringField()$/;" v class:FileTest.test_file_uniqueness.TestFile +name mongoengine/tests/fields/geo.py /^ name = StringField()$/;" v class:GeoFieldTest.test_geo_indexes_recursion.Location +name mongoengine/tests/fields/geo.py /^ name = StringField()$/;" v class:GeoFieldTest.test_geo_indexes_recursion.Parent +name mongoengine/tests/fields/geo.py /^ name = StringField()$/;" v class:GeoFieldTest.test_geopoint_embedded_indexes.Venue +name mongoengine/tests/fields/geo.py /^ name = StringField()$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Venue +name mongoengine/tests/fixtures.py /^ name = StringField()$/;" v class:Mixin +name mongoengine/tests/queryset/field_list.py /^ name = StringField()$/;" v class:OnlyExcludeAllTest.setUp.Person +name mongoengine/tests/queryset/field_list.py /^ name = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude.User +name mongoengine/tests/queryset/field_list.py /^ name = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Attachment +name mongoengine/tests/queryset/field_list.py /^ name = StringField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.User +name mongoengine/tests/queryset/geo.py /^ name = StringField()$/;" v class:GeoQueriesTest._test_embedded.Venue +name mongoengine/tests/queryset/geo.py /^ name = StringField()$/;" v class:GeoQueriesTest.test_linestring.Road +name mongoengine/tests/queryset/geo.py /^ name = StringField()$/;" v class:GeoQueriesTest.test_polygon.Road +name mongoengine/tests/queryset/pickable.py /^ name = StringField()$/;" v class:Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_update_related_models.TestOrganization +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_update_related_models.TestPerson +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.setUp.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_as_pymongo.User +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_bool_performance.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_bool_with_ordering.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_bool_with_ordering_from_meta_dict.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_bulk_insert.Comment +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_cache_not_cloned.User +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_cached_queryset.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_can_have_field_same_name_as_query_operator.Size +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_cls_query_in_subclassed_docs.Animal +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField.Author +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Author +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_embedded_array_average.Doc +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_embedded_array_sum.Doc +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_embedded_average.Doc +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_embedded_sum.Doc +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_find_array_position.Comment +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_find_embedded.User +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_find_empty_embedded.User +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_generic_reference_field_with_only_and_as_pymongo.TestActivity +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_generic_reference_field_with_only_and_as_pymongo.TestPerson +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Organization +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Project +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_in_operator_on_non_iterable.User +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_item_frequencies_null_values.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_item_frequencies_on_embedded.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_item_frequencies_with_null_embedded.Data +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_loop_over_invalid_id_does_not_crash.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_nested_queryset_iterator.User +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_cached_queryset.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_dereference.Organization +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_dereference.User +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Member +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Organization +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.User +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_pull_from_nested_embedded.User +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_pull_in_genericembedded_field.Foo +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_queryset_aggregation_framework.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_complex_cycle.Category +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify.Category +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar.Organization +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar.User +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_decimal.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_embedded.Profile +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_generic_reference_field.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_generic_reference_field.State +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_reference_field.Person +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_reference_field.State +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_simple.UserDoc +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_set_generic_embedded_documents.Bar +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_set_list_embedded_documents.Author +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_update.BlogPost +name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_update_array_position.Comment +name mongoengine/tests/queryset/queryset.py /^ name = StringField(db_field='doc-name')$/;" v class:QuerySetTest.test_exec_js_field_sub.BlogPost +name mongoengine/tests/queryset/queryset.py /^ name = StringField(max_length=120)$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Comment +name mongoengine/tests/queryset/queryset.py /^ name = StringField(max_length=75, unique=True, required=True)$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Site +name mongoengine/tests/queryset/queryset.py /^ name = StringField(max_length=75, unique=True, required=True)$/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Site +name mongoengine/tests/queryset/queryset.py /^ name = StringField(max_length=75, unique=True, required=True)$/;" v class:QuerySetTest.test_pull_nested.Site +name mongoengine/tests/queryset/queryset.py /^ name = StringField(required=True)$/;" v class:QuerySetTest.test_add_to_set_each.Item +name mongoengine/tests/queryset/queryset.py /^ name = StringField(required=True)$/;" v class:QuerySetTest.test_editting_embedded_objects.BlogTag +name mongoengine/tests/queryset/queryset.py /^ name = StringField(required=True)$/;" v class:QuerySetTest.test_update_one_pop_generic_reference.BlogTag +name mongoengine/tests/queryset/queryset.py /^ name="Barack Obama",$/;" v class:QuerySetTest.test_as_pymongo.User +name mongoengine/tests/queryset/transform.py /^ name = StringField()$/;" v class:TransformTest.test_last_field_name_like_operator.EmbeddedItem +name mongoengine/tests/queryset/transform.py /^ name = StringField()$/;" v class:TransformTest.test_raw_query_and_Q_objects.Foo +name mongoengine/tests/queryset/visitor.py /^ name = StringField()$/;" v class:QTest.setUp.Person +name mongoengine/tests/queryset/visitor.py /^ name = StringField()$/;" v class:QTest.test_empty_q.Person +name mongoengine/tests/queryset/visitor.py /^ name = StringField()$/;" v class:QTest.test_q_merge_queries_edge_case.User +name mongoengine/tests/queryset/visitor.py /^ name = StringField(max_length=40)$/;" v class:QTest.test_multiple_occurence_in_field.Test +name mongoengine/tests/queryset/visitor.py /^ name = StringField(required=True)$/;" v class:QTest.test_chained_q_or_filtering.Post +name mongoengine/tests/test_context_managers.py /^ name = StringField()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_dbref.User +name mongoengine/tests/test_context_managers.py /^ name = StringField()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_object_id.User +name mongoengine/tests/test_context_managers.py /^ name = StringField()$/;" v class:ContextManagersTest.test_switch_collection_context_manager.Group +name mongoengine/tests/test_context_managers.py /^ name = StringField()$/;" v class:ContextManagersTest.test_switch_db_context_manager.Group +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_circular_reference.Person +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_circular_reference.Relation +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_circular_reference_on_self.Person +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_circular_tree_reference.Other +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_circular_tree_reference.Person +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Tag +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_dict_field.UserA +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_dict_field.UserB +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_dict_field.UserC +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_dict_field_no_field_inheritance.UserA +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_document_reload_reference_integrity.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference.UserA +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference.UserB +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference.UserC +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_map_field.UserA +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_map_field.UserB +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_map_field.UserC +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.UserA +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.UserB +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.UserC +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_handle_old_style_references.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_field_complex.UserA +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_field_complex.UserB +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_field_complex.UserC +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_false.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries.Group +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_false_stores_as_type.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries.Group +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_of_lists_of_references.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_map_field_reference.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_migrate_references.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_objectid_reference_across_databases.Book +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_objectid_reference_across_databases.User +name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_reference.Employee +name mongoengine/tests/test_dereference.py /^ name = StringField(max_length=250, required=True)$/;" v class:FieldTest.test_dict_in_dbref_instance.Person +name mongoengine/tests/test_dereference.py /^ name = StringField(max_length=250, required=True)$/;" v class:FieldTest.test_multidirectional_lists.Asset +name mongoengine/tests/test_signals.py /^ name = StringField()$/;" v class:SignalTests.setUp.Another +name mongoengine/tests/test_signals.py /^ name = StringField()$/;" v class:SignalTests.setUp.Author +name tests/fields/fields.py /^ name="Wilson Júnior")$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields_on_embedded_documents.Test +name tests/fields/fields.py /^ name = StringField(db_field='$name')$/;" v class:FieldTest.test_db_field_validation.User +name tests/fields/fields.py /^ name = StringField(db_field='name\\0')$/;" v class:FieldTest.test_db_field_validation.User +name tests/fields/fields.py /^ name = StringField(db_field='user.name')$/;" v class:FieldTest.test_db_field_validation.User +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Owner +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.PersonAuto +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields.Product +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Group +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_abstract_reference_base_type.Mother +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_abstract_reference_base_type.Sibling +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_dbref_reference_fields.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_dbref_to_mongo.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_nothing_set.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_set_to_None.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_when_deleting_value.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_drop_abstract_document.AbstractDoc +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance.User +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Group +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_validation.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document.Car +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Car +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Car +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_is_none.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_inherited_sequencefield.Base +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference.User +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_map_field_lookup.Log +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_mapfield_numerical_index.Embedded +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Base +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_object_id_validation.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_objectid_reference_fields.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_embedding.Tree +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_embedding.TreeNode +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_reference.Employee +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_abstract_class.Sibling +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Sibling +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_validation.User +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reverse_list_sorting.Category +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reverse_list_sorting.CategoryList +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_get_next_value.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_sequence_name.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_value_decorator.Person +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_fields_reload.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_undefined_reference.Company +name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_undefined_reference.Product +name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Mineral +name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Vegetal +name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_equality.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal +name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Animal +name tests/fields/fields.py /^ name = StringField(max_length=20)$/;" v class:FieldTest.test_string_validation.Person +name tests/fields/fields.py /^ name = StringField(required=False, unique=True, sparse=True)$/;" v class:FieldTest.test_sparse_field.Doc +name tests/fields/fields.py /^ name = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Author +name tests/fields/fields.py /^ name = StringField(required=True)$/;" v class:FieldTest.test_required_values.Person +name tests/fields/fields.py /^ name='Steve',$/;" v class:FieldTest.test_dbref_to_mongo.Person +name2 mongoengine/tests/document/instance.py /^ name2 = StringField(db_field='name')$/;" v class:InstanceTest.test_duplicate_db_fields_raise_invalid_document_error.Foo +needs_mongodb_v26 mongoengine/tests/utils.py /^def needs_mongodb_v26(func):$/;" f +needs_mongodb_v3 mongoengine/tests/utils.py /^def needs_mongodb_v3(func):$/;" f +new mongoengine/tests/queryset/modify.py /^ new=True)$/;" v class:FindAndModifyTest.test_modify_with_push.BlogPost +new_field mongoengine/tests/fixtures.py /^ new_field = StringField()$/;" v class:NewDocumentPickleTest +new_file mongoengine/fields.py /^ def new_file(self, **kwargs):$/;" m class:GridFSProxy +new_file mongoengine/mongoengine/fields.py /^ def new_file(self, **kwargs):$/;" m class:GridFSProxy +next mongoengine/mongoengine/queryset/base.py /^ def next(self):$/;" m class:BaseQuerySet +next_log mongoengine/tests/fields/fields.py /^ next_log = logs[next_idx]$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +next_log tests/fields/fields.py /^ next_log = logs[next_idx]$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry +nick mongoengine/tests/fields/fields.py /^ nick = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.SubAnimal +nick mongoengine/tests/fields/fields.py /^ nick = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.SubAnimal +nick tests/fields/fields.py /^ nick = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.SubAnimal +nick tests/fields/fields.py /^ nick = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.SubAnimal +no_cache mongoengine/mongoengine/queryset/queryset.py /^ def no_cache(self):$/;" m class:QuerySet +no_dereference mongoengine/mongoengine/context_managers.py /^class no_dereference(object):$/;" c +no_dereference mongoengine/mongoengine/queryset/base.py /^ def no_dereference(self):$/;" m class:BaseQuerySet +no_sub_classes mongoengine/mongoengine/context_managers.py /^class no_sub_classes(object):$/;" c +no_sub_classes mongoengine/mongoengine/queryset/base.py /^ def no_sub_classes(self):$/;" m class:BaseQuerySet +noddy mongoengine/tests/queryset/queryset.py /^ noddy = Noddy()$/;" v class:QuerySetTest.test_no_cache.Noddy +nodes mongoengine/tests/document/instance.py /^ nodes = MapField(ReferenceField(Node, dbref=False))$/;" v class:InstanceTest.test_complex_nesting_document_and_embedded_document.NodesSystem +non_field mongoengine/tests/document/class_methods.py /^ non_field = True$/;" v class:ClassMethodsTest.setUp.Person +non_field mongoengine/tests/document/delta.py /^ non_field = True$/;" v class:DeltaTest.setUp.Person +non_field mongoengine/tests/document/indexes.py /^ non_field = True$/;" v class:IndexesTest.setUp.Person +non_field mongoengine/tests/document/instance.py /^ non_field = True$/;" v class:InstanceTest.setUp.Person +none mongoengine/mongoengine/queryset/base.py /^ def none(self):$/;" m class:BaseQuerySet +not_empty mongoengine/tests/queryset/queryset.py /^ def not_empty(self):$/;" m class:QuerySetTest.test_custom_querysets.CustomQuerySet +not_empty mongoengine/tests/queryset/queryset.py /^ def not_empty(self):$/;" m class:QuerySetTest.test_custom_querysets_inherited.CustomQuerySet +not_empty mongoengine/tests/queryset/queryset.py /^ def not_empty(self):$/;" m class:QuerySetTest.test_custom_querysets_inherited_direct.CustomQuerySet +not_empty mongoengine/tests/queryset/queryset.py /^ def not_empty(self):$/;" m class:QuerySetTest.test_custom_querysets_set_manager_directly.CustomQuerySet +num mongoengine/tests/document/delta.py /^ num = IntField(default=-1)$/;" v class:DeltaTest.test_delta_for_nested_map_fields.Doc +num_posts mongoengine/docs/code/tumblelog.py /^num_posts = Post.objects(tags='mongodb').count()$/;" v +num_visits mongoengine/tests/queryset/queryset.py /^ num_visits = IntField(db_field='visits')$/;" v class:QuerySetTest.test_average_over_db_field.UserVisit +num_visits mongoengine/tests/queryset/queryset.py /^ num_visits = IntField(db_field='visits')$/;" v class:QuerySetTest.test_sum_over_db_field.UserVisit +number mongoengine/tests/document/instance.py /^ number = IntField()$/;" v class:InstanceTest.test_invalid_son.Occurrence +number mongoengine/tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_embedded_document_validation.PersonPreferences +number mongoengine/tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_embedded_document.Dish +number mongoengine/tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Dish +number mongoengine/tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Dish +number mongoengine/tests/fields/fields.py /^ number = IntField(default=0, db_field='i')$/;" v class:FieldTest.test_embedded_db_field.Embedded +number mongoengine/tests/fields/fields.py /^ number = IntField(default=0, db_field='i')$/;" v class:FieldTest.test_embedded_mapfield_db_field.Embedded +number mongoengine/tests/fields/fields.py /^ number = IntField(unique=True)$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.EmbeddedWithUnique +number mongoengine/tests/fields/fields.py /^ number = IntField(unique=True, sparse=True)$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.EmbeddedWithSparseUnique +number mongoengine/tests/fixtures.py /^ number = IntField()$/;" v class:NewDocumentPickleTest +number mongoengine/tests/fixtures.py /^ number = IntField()$/;" v class:PickleDynamicTest +number mongoengine/tests/fixtures.py /^ number = IntField()$/;" v class:PickleSignalsTest +number mongoengine/tests/fixtures.py /^ number = IntField()$/;" v class:PickleTest +number mongoengine/tests/queryset/queryset.py /^ number = IntField()$/;" v class:QuerySetTest.test_repr.Doc +number mongoengine/tests/queryset/queryset.py /^ number = StringField()$/;" v class:QuerySetTest.test_item_frequencies_on_embedded.Phone +number mongoengine/tests/test_dereference.py /^ number = StringField(max_length=250, required=True)$/;" v class:FieldTest.test_dict_in_dbref_instance.Room +number tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_embedded_document_validation.PersonPreferences +number tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_embedded_document.Dish +number tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Dish +number tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Dish +number tests/fields/fields.py /^ number = IntField(default=0, db_field='i')$/;" v class:FieldTest.test_embedded_db_field.Embedded +number tests/fields/fields.py /^ number = IntField(default=0, db_field='i')$/;" v class:FieldTest.test_embedded_mapfield_db_field.Embedded +number tests/fields/fields.py /^ number = IntField(unique=True)$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.EmbeddedWithUnique +number tests/fields/fields.py /^ number = IntField(unique=True, sparse=True)$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.EmbeddedWithSparseUnique +obj mongoengine/tests/document/indexes.py /^ obj = EmbeddedDocumentField('self')$/;" v class:IndexesTest.test_recursive_embedded_objects_dont_break_indexes.RecursiveObject +object mongoengine/mongoengine/document.py /^ def object(self):$/;" m class:MapReduceDocument +object mongoengine/tests/fields/fields.py /^ object = StringField()$/;" v class:FieldTest.test_map_field_lookup.Action +object tests/fields/fields.py /^ object = StringField()$/;" v class:FieldTest.test_map_field_lookup.Action +objectid_field mongoengine/tests/document/instance.py /^ objectid_field = ObjectIdField(default=bson.ObjectId)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +objectid_field mongoengine/tests/document/json_serialisation.py /^ objectid_field = ObjectIdField(default=ObjectId)$/;" v class:TestJson.test_json_complex.Doc +objectid_field mongoengine/tests/queryset/queryset.py /^ objectid_field = ObjectIdField(default=ObjectId)$/;" v class:QuerySetTest.test_json_complex.Doc +objects mongoengine/tests/queryset/queryset.py /^ def objects(cls, qryset):$/;" m class:QuerySetTest.test_custom_manager.BlogPost +objects mongoengine/tests/queryset/queryset.py /^ def objects(doc_cls, queryset):$/;" m class:QuerySetTest.test_custom_manager_overriding_objects_works.Foo +objects mongoengine/tests/queryset/queryset.py /^ def objects(klass, queryset):$/;" m class:QuerySetTest.test_inherit_objects.Foo +objects mongoengine/tests/queryset/queryset.py /^ def objects(klass, queryset):$/;" m class:QuerySetTest.test_inherit_objects_override.Bar +objects mongoengine/tests/queryset/queryset.py /^ def objects(klass, queryset):$/;" m class:QuerySetTest.test_inherit_objects_override.Foo +objects mongoengine/tests/queryset/queryset.py /^ objects = CustomQuerySetManager()$/;" v class:QuerySetTest.test_custom_querysets_inherited_direct.Base +objects mongoengine/tests/queryset/queryset.py /^ objects = CustomQuerySetManager()$/;" v class:QuerySetTest.test_custom_querysets_set_manager_directly.Post +obs mongoengine/tests/fields/fields.py /^ obs = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData +obs tests/fields/fields.py /^ obs = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData +occurs mongoengine/tests/document/instance.py /^ occurs = ListField(EmbeddedDocumentField(Occurrence), default=list)$/;" v class:InstanceTest.test_invalid_son.Word +oid_info mongoengine/tests/fields/fields.py /^ oid_info = ListField(ObjectIdField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost +oid_info tests/fields/fields.py /^ oid_info = ListField(ObjectIdField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost +on_document_pre_save mongoengine/fields.py /^ def on_document_pre_save(self, sender, document, created, **kwargs):$/;" m class:CachedReferenceField +on_document_pre_save mongoengine/mongoengine/fields.py /^ def on_document_pre_save(self, sender, document, created, **kwargs):$/;" m class:CachedReferenceField +only mongoengine/mongoengine/queryset/base.py /^ def only(self, *fields):$/;" m class:BaseQuerySet +op mongoengine/tests/queryset/queryset.py /^ op = ops[0]$/;" v class:QuerySetTest.test_comment.User +op mongoengine/tests/queryset/queryset.py /^ op = p.db.system.profile.find({"ns":$/;" v class:QuerySetTest.test_bool_with_ordering.Person +op mongoengine/tests/queryset/queryset.py /^ op = q.db.system.profile.find({"ns":$/;" v class:QuerySetTest.test_bool_performance.Person +op mongoengine/tests/queryset/queryset.py /^ op = q.db.system.profile.find({"ns":$/;" v class:QuerySetTest.test_bool_with_ordering.Person +op mongoengine/tests/queryset/queryset.py /^ op = q.db.system.profile.find({"ns":$/;" v class:QuerySetTest.test_bool_with_ordering_from_meta_dict.Person +operation mongoengine/tests/fields/fields.py /^ operation = StringField()$/;" v class:FieldTest.test_map_field_lookup.Action +operation tests/fields/fields.py /^ operation = StringField()$/;" v class:FieldTest.test_map_field_lookup.Action +ops mongoengine/tests/queryset/queryset.py /^ ops = q.get_ops()$/;" v class:QuerySetTest.test_comment.User +order mongoengine/tests/fields/fields.py /^ order = IntField()$/;" v class:FieldTest.test_sorted_list_sorting.Comment +order tests/fields/fields.py /^ order = IntField()$/;" v class:FieldTest.test_sorted_list_sorting.Comment +order_by mongoengine/mongoengine/queryset/base.py /^ def order_by(self, *keys):$/;" m class:BaseQuerySet +ordering mongoengine/tests/fields/fields.py /^ ordering='order')$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost +ordering tests/fields/fields.py /^ ordering='order')$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost +org mongoengine/tests/document/delta.py /^ org = ReferenceField('Organization', required=True)$/;" v class:DeltaTest.test_referenced_object_changed_attributes.User +org mongoengine/tests/queryset/queryset.py /^ org = Organization.objects.get(id=o1.id)$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Project +organization mongoengine/tests/queryset/queryset.py /^ organization = ObjectIdField()$/;" v class:QuerySetTest.test_scalar.User +organization mongoengine/tests/queryset/queryset.py /^ organization = ReferenceField(Organization)$/;" v class:QuerySetTest.test_no_dereference.User +orgs mongoengine/tests/document/instance.py /^ orgs = ListField(ReferenceField('Organization'))$/;" v class:InstanceTest.test_query_count_when_saving.User +other mongoengine/tests/test_dereference.py /^ other = EmbeddedDocumentField(Other, default=lambda: Other())$/;" v class:FieldTest.test_circular_tree_reference.Person +other_field mongoengine/tests/fields/fields.py /^ other_field = StringField()$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Bookmark +other_field tests/fields/fields.py /^ other_field = StringField()$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Bookmark +output mongoengine/tests/queryset/queryset.py /^ output={'reduce': 'family_map', 'db_alias': 'test2'})$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person +output mongoengine/tests/queryset/queryset.py /^ output={'replace': 'family_map', 'db_alias': 'test2'})$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person +owner mongoengine/tests/document/delta.py /^ owner = ReferenceField('Person')$/;" v class:DeltaTest.circular_reference_deltas.Organization +owner mongoengine/tests/document/delta.py /^ owner = ReferenceField('Person', dbref=dbref)$/;" v class:DeltaTest.circular_reference_deltas_2.Organization +owner mongoengine/tests/fields/fields.py /^ owner=Owner(tags=['cool', 'funny'],$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +owner mongoengine/tests/fields/fields.py /^ owner=Owner(tp='u', name="Wilson Júnior")$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence +owner mongoengine/tests/fields/fields.py /^ owner = EmbeddedDocumentField(Owner)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal +owner mongoengine/tests/fields/fields.py /^ owner = EmbeddedDocumentField(Owner)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal +owner mongoengine/tests/queryset/queryset.py /^ owner = ReferenceField(TestPerson)$/;" v class:QuerySetTest.test_update_related_models.TestOrganization +owner mongoengine/tests/queryset/queryset.py /^ owner = GenericReferenceField()$/;" v class:QuerySetTest.test_generic_reference_field_with_only_and_as_pymongo.TestActivity +owner mongoengine/tests/queryset/queryset.py /^ owner = ReferenceField(Person)$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Organization +owner tests/fields/fields.py /^ owner=Owner(tags=['cool', 'funny'],$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +owner tests/fields/fields.py /^ owner=Owner(tp='u', name="Wilson Júnior")$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence +owner tests/fields/fields.py /^ owner = EmbeddedDocumentField(Owner)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal +owner tests/fields/fields.py /^ owner = EmbeddedDocumentField(Owner)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal +owner_document mongoengine/mongoengine/base/fields.py /^ def owner_document(self):$/;" m class:BaseField +owner_document mongoengine/mongoengine/base/fields.py /^ def owner_document(self, owner_document):$/;" m class:BaseField +owns mongoengine/tests/document/delta.py /^ owns = ListField(ReferenceField('Organization'))$/;" v class:DeltaTest.circular_reference_deltas.Person +owns mongoengine/tests/document/delta.py /^ owns = ListField(ReferenceField('Organization', dbref=dbref))$/;" v class:DeltaTest.circular_reference_deltas_2.Person +owns mongoengine/tests/queryset/queryset.py /^ owns = ListField(ReferenceField('Organization'))$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Person +p mongoengine/tests/fields/fields.py /^ p = Ocurrence(person="test", animal=bad).save()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.BadDoc +p mongoengine/tests/fields/fields.py /^ p = Ocurrence(person="test", animal=bad).save()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.BadDoc +p mongoengine/tests/fields/fields.py /^ p = Ocurrence(person="test", animal=ref).save()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.SubAnimal +p mongoengine/tests/fields/fields.py /^ p = Ocurrence(person="test", animal=ref).save()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.SubAnimal +p mongoengine/tests/fields/fields.py /^ p = Person(name="Person %s" % x)$/;" v class:FieldTest.test_sequence_field_value_decorator.Person +p tests/fields/fields.py /^ p = Ocurrence(person="test", animal=bad).save()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.BadDoc +p tests/fields/fields.py /^ p = Ocurrence(person="test", animal=bad).save()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.BadDoc +p tests/fields/fields.py /^ p = Ocurrence(person="test", animal=ref).save()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.SubAnimal +p tests/fields/fields.py /^ p = Ocurrence(person="test", animal=ref).save()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.SubAnimal +p tests/fields/fields.py /^ p = Person(name="Person %s" % x)$/;" v class:FieldTest.test_sequence_field_value_decorator.Person +page mongoengine/tests/document/instance.py /^ page = EmbeddedDocumentField(Page)$/;" v class:InstanceTest.test_embedded_update.Site +page mongoengine/tests/document/instance.py /^ page = EmbeddedDocumentField(Page)$/;" v class:InstanceTest.test_embedded_update_after_save.Site +page mongoengine/tests/document/instance.py /^ page = EmbeddedDocumentField(Page)$/;" v class:InstanceTest.test_embedded_update_db_field.Site +parameters mongoengine/tests/document/instance.py /^ parameters = MapField(EmbeddedDocumentField(Parameter))$/;" v class:InstanceTest.test_complex_nesting_document_and_embedded_document.Node +parent mongoengine/tests/document/instance.py /^ parent = GenericReferenceField()$/;" v class:InstanceTest.test_save_cascades_generically.Person +parent mongoengine/tests/document/instance.py /^ parent = ReferenceField('self')$/;" v class:InstanceTest.test_save_cascade_kwargs.Person +parent mongoengine/tests/document/instance.py /^ parent = ReferenceField('self')$/;" v class:InstanceTest.test_save_cascade_meta_false.Person +parent mongoengine/tests/document/instance.py /^ parent = ReferenceField('self')$/;" v class:InstanceTest.test_save_cascade_meta_true.Person +parent mongoengine/tests/document/instance.py /^ parent = ReferenceField('self')$/;" v class:InstanceTest.test_save_cascades.Person +parent mongoengine/tests/document/instance.py /^ parent = ReferenceField('self')$/;" v class:InstanceTest.test_save_max_recursion_not_hit.Person +parent mongoengine/tests/fields/fields.py /^ parent = ReferenceField('self')$/;" v class:FieldTest.test_objectid_reference_fields.Person +parent mongoengine/tests/fields/fields.py /^ parent = ReferenceField('self', dbref=False)$/;" v class:FieldTest.test_dbref_to_mongo.Person +parent mongoengine/tests/fields/fields.py /^ parent = ReferenceField('self', dbref=False)$/;" v class:FieldTest.test_objectid_reference_fields.Person +parent mongoengine/tests/fields/fields.py /^ parent = ReferenceField('self', dbref=True)$/;" v class:FieldTest.test_dbref_reference_fields.Person +parent mongoengine/tests/fields/fields.py /^ parent=DBRef('person', 'abcdefghijklmnop')$/;" v class:FieldTest.test_dbref_to_mongo.Person +parent mongoengine/tests/queryset/queryset.py /^ parent = ReferenceField('self', reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category +parent mongoengine/tests/test_dereference.py /^ parent = GenericReferenceField(default=None)$/;" v class:FieldTest.test_multidirectional_lists.Asset +parent tests/fields/fields.py /^ parent = ReferenceField('self')$/;" v class:FieldTest.test_objectid_reference_fields.Person +parent tests/fields/fields.py /^ parent = ReferenceField('self', dbref=False)$/;" v class:FieldTest.test_dbref_to_mongo.Person +parent tests/fields/fields.py /^ parent = ReferenceField('self', dbref=False)$/;" v class:FieldTest.test_objectid_reference_fields.Person +parent tests/fields/fields.py /^ parent = ReferenceField('self', dbref=True)$/;" v class:FieldTest.test_dbref_reference_fields.Person +parent tests/fields/fields.py /^ parent=DBRef('person', 'abcdefghijklmnop')$/;" v class:FieldTest.test_dbref_to_mongo.Person +parents mongoengine/tests/queryset/queryset.py /^ parents = ListField(ReferenceField('self'))$/;" v class:QuerySetTest.test_add_to_set_each.Item +parents mongoengine/tests/test_dereference.py /^ parents = ListField(GenericReferenceField())$/;" v class:FieldTest.test_multidirectional_lists.Asset +password mongoengine/tests/document/indexes.py /^ password = StringField()$/;" v class:IndexesTest.test_unique_and_primary.User +password mongoengine/tests/document/indexes.py /^ password = StringField()$/;" v class:IndexesTest.test_unique_and_primary_create.User +password mongoengine/tests/queryset/field_list.py /^ password = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_from_subclasses_docs.User +password_hash mongoengine/tests/queryset/queryset.py /^ password_hash="SomeHash").save()$/;" v class:QuerySetTest.test_as_pymongo_json_limit_fields.User +password_hash mongoengine/tests/queryset/queryset.py /^ password_hash = StringField($/;" v class:QuerySetTest.test_as_pymongo_json_limit_fields.User +password_salt mongoengine/tests/queryset/queryset.py /^ password_salt = StringField($/;" v class:QuerySetTest.test_as_pymongo_json_limit_fields.User +path mongoengine/tests/test_dereference.py /^ path = StringField()$/;" v class:FieldTest.test_multidirectional_lists.Asset +pay mongoengine/tests/queryset/queryset.py /^ pay = EmbeddedDocumentField($/;" v class:QuerySetTest.test_embedded_average.Doc +pay mongoengine/tests/queryset/queryset.py /^ pay = EmbeddedDocumentField(Pay)$/;" v class:QuerySetTest.test_embedded_array_average.Doc +pay mongoengine/tests/queryset/queryset.py /^ pay = EmbeddedDocumentField(Pay)$/;" v class:QuerySetTest.test_embedded_array_sum.Doc +pay mongoengine/tests/queryset/queryset.py /^ pay = EmbeddedDocumentField(Pay)$/;" v class:QuerySetTest.test_embedded_sum.Doc +people mongoengine/tests/queryset/queryset.py /^ people = Person.objects$/;" v class:QuerySetTest.test_cached_queryset.Person +people mongoengine/tests/queryset/queryset.py /^ people = Person.objects.no_cache()$/;" v class:QuerySetTest.test_no_cached_queryset.Person +person mongoengine/tests/fields/fields.py /^ person = Person.objects.create()$/;" v class:FieldTest.test_decimal_storage.Person +person mongoengine/tests/fields/fields.py /^ person = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest +person mongoengine/tests/fields/fields.py /^ person = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Ocorrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Ocurrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Ocurrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Ocurrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Ocurrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Ocurrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Ocurrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Ocurrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Ocurrence +person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Ocurrence +person mongoengine/tests/test_dereference.py /^ person = ReferenceField('Person')$/;" v class:FieldTest.test_circular_reference.Relation +person tests/fields/fields.py /^ person = Person.objects.create()$/;" v class:FieldTest.test_decimal_storage.Person +person tests/fields/fields.py /^ person = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest +person tests/fields/fields.py /^ person = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData +person tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Ocorrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Ocurrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Ocurrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Ocurrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Ocurrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Ocurrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Ocurrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Ocurrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Ocurrence +person tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Ocurrence +person_meta mongoengine/tests/queryset/queryset.py /^ person_meta = EmbeddedDocumentField(PersonMeta)$/;" v class:QuerySetTest.setUp.Person +peter mongoengine/tests/test_dereference.py /^ peter = Employee.objects.with_id(peter.id)$/;" v class:FieldTest.test_recursive_reference.Employee +peter mongoengine/tests/test_dereference.py /^ peter = Employee.objects.with_id(peter.id).select_related()$/;" v class:FieldTest.test_recursive_reference.Employee +phone mongoengine/tests/document/delta.py /^ phone = StringField()$/;" v class:DeltaTest.test_delta_for_nested_map_fields.UInfoDocument +phone mongoengine/tests/queryset/queryset.py /^ phone = EmbeddedDocumentField(Phone)$/;" v class:QuerySetTest.test_item_frequencies_on_embedded.Person +photo mongoengine/tests/fields/file_tests.py /^ photo = FileField()$/;" v class:FileTest.test_file_saving.Animal +photo mongoengine/tests/fixtures.py /^ photo = FileField()$/;" v class:NewDocumentPickleTest +photo mongoengine/tests/fixtures.py /^ photo = FileField()$/;" v class:PickleTest +photos mongoengine/tests/fields/file_tests.py /^ photos = ListField(FileField())$/;" v class:FileTest.test_complex_field_filefield.Animal +picture mongoengine/tests/document/instance.py /^ picture = FileField()$/;" v class:InstanceTest.test_save_max_recursion_not_hit_with_file_field.Foo +pk mongoengine/mongoengine/base/datastructures.py /^ def pk(self):$/;" m class:LazyReference +pk mongoengine/mongoengine/document.py /^ def pk(self):$/;" m class:Document +pk mongoengine/mongoengine/document.py /^ def pk(self, value):$/;" m class:Document +playlist mongoengine/tests/test_dereference.py /^ playlist = Playlist.objects.first().select_related()$/;" v class:FieldTest.test_select_related_follows_embedded_referencefields.Playlist +point mongoengine/tests/fields/geo.py /^ point = PointField()$/;" v class:GeoFieldTest.test_indexes_2dsphere.Event +point mongoengine/tests/fields/geo.py /^ point = PointField()$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Venue +poly mongoengine/tests/queryset/geo.py /^ poly = PolygonField()$/;" v class:GeoQueriesTest.test_geojson_PolygonField.Location +poly mongoengine/tests/queryset/geo.py /^ poly = PolygonField()$/;" v class:GeoQueriesTest.test_polygon.Road +poly mongoengine/tests/queryset/transform.py /^ poly = PolygonField()$/;" v class:TransformTest.test_geojson_PolygonField.Location +polygon mongoengine/tests/fields/geo.py /^ polygon = PolygonField()$/;" v class:GeoFieldTest.test_indexes_2dsphere.Event +polygon mongoengine/tests/fields/geo.py /^ polygon = PolygonField()$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Venue +pop mongoengine/mongoengine/base/datastructures.py /^ def pop(self, *args, **kwargs):$/;" m class:BaseDict +pop mongoengine/mongoengine/base/datastructures.py /^ def pop(self, *args, **kwargs):$/;" m class:BaseList +pop mongoengine/mongoengine/base/datastructures.py /^ def pop(self, key, default=None):$/;" m class:StrictDict +popitem mongoengine/mongoengine/base/datastructures.py /^ def popitem(self, *args, **kwargs):$/;" m class:BaseDict +position mongoengine/tests/document/instance.py /^ position = StringField()$/;" v class:InstanceTest.test_save_embedded_document.EmployeeDetails +position mongoengine/tests/document/instance.py /^ position = StringField()$/;" v class:InstanceTest.test_updating_an_embedded_document.EmployeeDetails +post mongoengine/tests/document/instance.py /^ post = ReferenceField(BlogPost, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_recurs.Comment +post1 mongoengine/docs/code/tumblelog.py /^post1 = TextPost(title='Fun with MongoEngine', author=john)$/;" v +post1 mongoengine/tests/document/indexes.py /^ post1 = BlogPost(title='test1', slug='test')$/;" v class:IndexesTest.test_indexes_after_database_drop.BlogPost +post1 mongoengine/tests/queryset/queryset.py /^ post1 = Post(comments=[comment1, comment2])$/;" v class:QuerySetTest.test_bulk_insert.Blog +post2 mongoengine/docs/code/tumblelog.py /^post2 = LinkPost(title='MongoEngine Documentation', author=john)$/;" v +post2 mongoengine/tests/document/indexes.py /^ post2 = BlogPost(title='test2', slug='test')$/;" v class:IndexesTest.test_indexes_after_database_drop.BlogPost +post2 mongoengine/tests/queryset/queryset.py /^ post2 = Post(comments=[comment2, comment2])$/;" v class:QuerySetTest.test_bulk_insert.Blog +post_bulk_insert mongoengine/mongoengine/signals.py /^post_bulk_insert = _signals.signal('post_bulk_insert')$/;" v +post_bulk_insert mongoengine/tests/test_signals.py /^ def post_bulk_insert(cls, sender, documents, **kwargs):$/;" m class:SignalTests.setUp.Author +post_bulk_insert mongoengine/tests/test_signals.py /^ def post_bulk_insert(cls, sender, documents, **kwargs):$/;" m class:SignalTests.setUp.Post +post_delete mongoengine/mongoengine/signals.py /^post_delete = _signals.signal('post_delete')$/;" v +post_delete mongoengine/tests/fixtures.py /^ def post_delete(self, sender, document, **kwargs):$/;" m class:PickleSignalsTest +post_delete mongoengine/tests/test_signals.py /^ def post_delete(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Another +post_delete mongoengine/tests/test_signals.py /^ def post_delete(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author +post_init mongoengine/mongoengine/signals.py /^post_init = _signals.signal('post_init')$/;" v +post_init mongoengine/tests/test_signals.py /^ def post_init(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author +post_save mongoengine/mongoengine/signals.py /^post_save = _signals.signal('post_save')$/;" v +post_save mongoengine/tests/fixtures.py /^ def post_save(self, sender, document, created, **kwargs):$/;" m class:PickleSignalsTest +post_save mongoengine/tests/test_signals.py /^ def post_save(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author +post_save mongoengine/tests/test_signals.py /^ def post_save(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.ExplicitId +postables mongoengine/tests/queryset/visitor.py /^ postables = ListField(EmbeddedDocumentField(Post))$/;" v class:QTest.test_chained_q_or_filtering.Item +posts mongoengine/tests/queryset/queryset.py /^ posts = ListField(EmbeddedDocumentField(Post))$/;" v class:QuerySetTest.test_bulk_insert.Blog +posts mongoengine/tests/queryset/queryset.py /^ posts = ListField(EmbeddedDocumentField(Post))$/;" v class:QuerySetTest.test_find_array_position.Blog +posts mongoengine/tests/queryset/queryset.py /^ posts = ListField(EmbeddedDocumentField(Post))$/;" v class:QuerySetTest.test_update_array_position.Blog +posts mongoengine/tests/test_dereference.py /^ posts = ListField(EmbeddedDocumentField(Post))$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Page +power mongoengine/tests/fields/fields.py /^ power = IntField()$/;" v class:FieldTest.test_embedded_document_inheritance.PowerUser +power tests/fields/fields.py /^ power = IntField()$/;" v class:FieldTest.test_embedded_document_inheritance.PowerUser +pre_bulk_insert mongoengine/mongoengine/signals.py /^pre_bulk_insert = _signals.signal('pre_bulk_insert')$/;" v +pre_bulk_insert mongoengine/tests/test_signals.py /^ def pre_bulk_insert(cls, sender, documents, **kwargs):$/;" m class:SignalTests.setUp.Author +pre_bulk_insert mongoengine/tests/test_signals.py /^ def pre_bulk_insert(cls, sender, documents, **kwargs):$/;" m class:SignalTests.setUp.Post +pre_delete mongoengine/mongoengine/signals.py /^pre_delete = _signals.signal('pre_delete')$/;" v +pre_delete mongoengine/tests/document/instance.py /^ def pre_delete(cls, sender, document, **kwargs):$/;" m class:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal.BlogPost +pre_delete mongoengine/tests/test_signals.py /^ def pre_delete(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Another +pre_delete mongoengine/tests/test_signals.py /^ def pre_delete(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author +pre_init mongoengine/mongoengine/signals.py /^pre_init = _signals.signal('pre_init')$/;" v +pre_init mongoengine/tests/test_signals.py /^ def pre_init(cls, sender, document, *args, **kwargs):$/;" m class:SignalTests.setUp.Author +pre_save mongoengine/mongoengine/signals.py /^pre_save = _signals.signal('pre_save')$/;" v +pre_save mongoengine/tests/test_signals.py /^ def pre_save(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author +pre_save_post_validation mongoengine/mongoengine/signals.py /^pre_save_post_validation = _signals.signal('pre_save_post_validation')$/;" v +pre_save_post_validation mongoengine/tests/test_signals.py /^ def pre_save_post_validation(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author +preferences mongoengine/tests/fields/fields.py /^ preferences = EmbeddedDocumentField(PersonPreferences)$/;" v class:FieldTest.test_embedded_document_validation.Person +preferences tests/fields/fields.py /^ preferences = EmbeddedDocumentField(PersonPreferences)$/;" v class:FieldTest.test_embedded_document_validation.Person +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:CachedReferenceField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ComplexDateTimeField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DateTimeField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DecimalField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DictField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DynamicField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:EmbeddedDocumentField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:FloatField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:GenericEmbeddedDocumentField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:GenericReferenceField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:IntField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:LazyReferenceField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ListField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:LongField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ReferenceField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:SequenceField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:StringField +prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:UUIDField +prepare_query_value mongoengine/mongoengine/base/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:BaseField +prepare_query_value mongoengine/mongoengine/base/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ComplexBaseField +prepare_query_value mongoengine/mongoengine/base/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ObjectIdField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:CachedReferenceField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ComplexDateTimeField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DateTimeField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DecimalField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DictField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DynamicField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:EmbeddedDocumentField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:FloatField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:GenericEmbeddedDocumentField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:GenericReferenceField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:IntField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:LazyReferenceField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ListField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:LongField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ReferenceField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:SequenceField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:StringField +prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:UUIDField +price mongoengine/tests/queryset/queryset.py /^ price = DecimalField()$/;" v class:QuerySetTest.test_as_pymongo.User +price mongoengine/tests/queryset/queryset.py /^ price=Decimal('2.22'),$/;" v class:QuerySetTest.test_as_pymongo.User +primary_key mongoengine/tests/queryset/queryset.py /^ primary_key=True)$/;" v class:QuerySetTest.test_map_reduce_custom_output.Family +primary_key mongoengine/tests/queryset/queryset.py /^ primary_key=True)$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person +product_id mongoengine/tests/queryset/queryset.py /^ product_id = IntField(db_field='pid')$/;" v class:QuerySetTest.test_distinct_handles_db_field.Product +products mongoengine/tests/fields/fields.py /^ products = ListField(CachedReferenceField(Product, fields=['name']))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields.Basket +products tests/fields/fields.py /^ products = ListField(CachedReferenceField(Product, fields=['name']))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields.Basket +profile mongoengine/tests/queryset/queryset.py /^ profile = EmbeddedDocumentField(Profile)$/;" v class:QuerySetTest.test_scalar_embedded.Person +project mongoengine/docs/conf.py /^project = u'MongoEngine'$/;" v +projects mongoengine/tests/queryset/queryset.py /^ projects = ListField(ReferenceField('Project'))$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Person +provider_ids mongoengine/tests/document/indexes.py /^ provider_ids = DictField()$/;" v class:IndexesTest.test_sparse_compound_indexes.MyDoc +provider_ids mongoengine/tests/document/indexes.py /^ provider_ids = DictField()$/;" v class:IndexesTest.test_string_indexes.MyDoc +proxy_class mongoengine/fields.py /^ proxy_class = GridFSProxy$/;" v class:FileField +proxy_class mongoengine/fields.py /^ proxy_class = ImageGridFsProxy$/;" v class:ImageField +proxy_class mongoengine/mongoengine/fields.py /^ proxy_class = GridFSProxy$/;" v class:FileField +proxy_class mongoengine/mongoengine/fields.py /^ proxy_class = ImageGridFsProxy$/;" v class:ImageField +pub_date mongoengine/tests/document/instance.py /^ pub_date = DateTimeField()$/;" v class:InstanceTest.test_document_clean.TestDocument +publish_date mongoengine/tests/queryset/visitor.py /^ publish_date = DateTimeField()$/;" v class:QTest.test_q.BlogPost +published mongoengine/tests/document/instance.py /^ published = BooleanField(default=True)$/;" v class:InstanceTest.test_save_only_changed_fields_recursive.Comment +published mongoengine/tests/queryset/queryset.py /^ def published(doc_cls, queryset):$/;" m class:QuerySetTest.test_filter_chaining.BlogPost +published mongoengine/tests/queryset/queryset.py /^ published = BooleanField()$/;" v class:QuerySetTest.test_exec_js_query.BlogPost +published mongoengine/tests/queryset/queryset.py /^ published = CustomQuerySetManager()$/;" v class:QuerySetTest.test_custom_querysets_managers_directly.Post +published mongoengine/tests/queryset/visitor.py /^ published = BooleanField()$/;" v class:QTest.test_q.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField()$/;" v class:QuerySetTest.test_clear_ordering.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField()$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField()$/;" v class:QuerySetTest.test_no_ordering_for_get.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField()$/;" v class:QuerySetTest.test_ordering.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField(required=False)$/;" v class:QuerySetTest.test_order_by_list.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField(required=False)$/;" v class:QuerySetTest.test_order_by_optional.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=None$/;" v class:QuerySetTest.test_order_by_optional.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 5, 0, 0, 0)$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 5, 0, 0, 0)$/;" v class:QuerySetTest.test_order_by_optional.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 5, 0, 0, 0)$/;" v class:QuerySetTest.test_ordering.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 6, 0, 0, 0)$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 6, 0, 0, 0)$/;" v class:QuerySetTest.test_order_by_list.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 6, 0, 0, 0)$/;" v class:QuerySetTest.test_order_by_optional.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 6, 0, 0, 0)$/;" v class:QuerySetTest.test_ordering.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 7, 0, 0, 0)$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 7, 0, 0, 0)$/;" v class:QuerySetTest.test_order_by_list.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 7, 0, 0, 0)$/;" v class:QuerySetTest.test_order_by_optional.BlogPost +published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 7, 0, 0, 0)$/;" v class:QuerySetTest.test_ordering.BlogPost +published_date__lt mongoengine/tests/queryset/queryset.py /^ published_date__lt=datetime.datetime(2010, 1, 7, 0, 0, 0))$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +pull__collaborators__helpful__user mongoengine/tests/queryset/queryset.py /^ pull__collaborators__helpful__user='Esteban')$/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Site +pull__collaborators__unhelpful mongoengine/tests/queryset/queryset.py /^ pull__collaborators__unhelpful={'name': 'Frank'})$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Site +pull__collaborators__unhelpful mongoengine/tests/queryset/queryset.py /^ pull__collaborators__unhelpful={'user': 'Frank'})$/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Site +pull_all__collaborators__helpful__name mongoengine/tests/queryset/queryset.py /^ pull_all__collaborators__helpful__name=['Ross'])$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Site +pull_all__collaborators__helpful__user mongoengine/tests/queryset/queryset.py /^ pull_all__collaborators__helpful__user=['Ross'])$/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Site +pull_all__collaborators__user mongoengine/tests/queryset/queryset.py /^ pull_all__collaborators__user=['Ross'])$/;" v class:QuerySetTest.test_pull_nested.Site +pull_all__tags mongoengine/tests/queryset/queryset.py /^ pull_all__tags=["mongodb", "code"])$/;" v class:QuerySetTest.test_update_push_and_pull_add_to_set.BlogPost +push__tags__0 mongoengine/tests/queryset/modify.py /^ push__tags__0='python',$/;" v class:FindAndModifyTest.test_modify_with_push.BlogPost +push__tags__1 mongoengine/tests/queryset/modify.py /^ push__tags__1=['go', 'rust'],$/;" v class:FindAndModifyTest.test_modify_with_push.BlogPost +push_all__tags mongoengine/tests/queryset/queryset.py /^ push_all__tags=["mongodb", "code"])$/;" v class:QuerySetTest.test_update_push_and_pull_add_to_set.BlogPost +put mongoengine/fields.py /^ def put(self, file_obj, **kwargs):$/;" m class:GridFSProxy +put mongoengine/fields.py /^ def put(self, file_obj, **kwargs):$/;" m class:ImageGridFsProxy +put mongoengine/mongoengine/fields.py /^ def put(self, file_obj, **kwargs):$/;" m class:GridFSProxy +put mongoengine/mongoengine/fields.py /^ def put(self, file_obj, **kwargs):$/;" m class:ImageGridFsProxy +pygments_style mongoengine/docs/conf.py /^pygments_style = 'sphinx'$/;" v +qs mongoengine/tests/queryset/queryset.py /^ qs = BlogPost.objects.filter(title='whatever').order_by('published_date')$/;" v class:QuerySetTest.test_clear_ordering.BlogPost +quantity mongoengine/tests/document/instance.py /^ quantity = IntField()$/;" v class:InstanceTest.test_object_mixins.Foo +query mongoengine/mongoengine/queryset/transform.py /^def query(_doc_cls=None, **kwargs):$/;" f +query_counter mongoengine/mongoengine/context_managers.py /^class query_counter(object):$/;" c +queryset_class mongoengine/tests/queryset/queryset.py /^ queryset_class = CustomQuerySet$/;" v class:QuerySetTest.test_custom_querysets_inherited_direct.CustomQuerySetManager +queryset_class mongoengine/tests/queryset/queryset.py /^ queryset_class = CustomQuerySet$/;" v class:QuerySetTest.test_custom_querysets_set_manager_directly.CustomQuerySetManager +queryset_manager mongoengine/mongoengine/queryset/manager.py /^def queryset_manager(func):$/;" f +rank mongoengine/tests/document/indexes.py /^ rank = EmbeddedDocumentField(Rank, required=False)$/;" v class:IndexesTest.test_embedded_document_index_meta.Person +rank mongoengine/tests/document/instance.py /^ def rank(self):$/;" m class:InstanceTest.test_db_embedded_doc_field_load.Person +rank mongoengine/tests/document/instance.py /^ def rank(self):$/;" m class:InstanceTest.test_db_field_load.Person +rank_ mongoengine/tests/document/instance.py /^ rank_ = EmbeddedDocumentField(Rank,$/;" v class:InstanceTest.test_db_embedded_doc_field_load.Person +rating mongoengine/tests/queryset/queryset.py /^ rating = DecimalField()$/;" v class:QuerySetTest.test_scalar_decimal.Person +read mongoengine/fields.py /^ def read(self, size=-1):$/;" m class:GridFSProxy +read mongoengine/mongoengine/fields.py /^ def read(self, size=-1):$/;" m class:GridFSProxy +read_preference mongoengine/mongoengine/queryset/base.py /^ def read_preference(self, read_preference):$/;" m class:BaseQuerySet +recursive mongoengine/tests/fields/fields.py /^ recursive = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbed +recursive mongoengine/tests/fields/fields.py /^ recursive = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent +recursive mongoengine/tests/fields/fields.py /^ recursive = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbed +recursive mongoengine/tests/fields/fields.py /^ recursive = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent +recursive tests/fields/fields.py /^ recursive = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbed +recursive tests/fields/fields.py /^ recursive = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent +recursive tests/fields/fields.py /^ recursive = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbed +recursive tests/fields/fields.py /^ recursive = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent +recursive_obj mongoengine/tests/document/indexes.py /^ recursive_obj = EmbeddedDocumentField(RecursiveObject)$/;" v class:IndexesTest.test_recursive_embedded_objects_dont_break_indexes.RecursiveDocument +reduce_f mongoengine/tests/queryset/queryset.py /^ reduce_f=reduce_f,$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person +ref mongoengine/tests/document/instance.py /^ ref = ReferenceField(Test)$/;" v class:InstanceTest.test_embedded_document_equality.Embedded +ref mongoengine/tests/fields/fields.py /^ ref = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_filter_by_dbref.Doc +ref mongoengine/tests/fields/fields.py /^ ref = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_filter_by_objectid.Doc +ref mongoengine/tests/fields/fields.py /^ ref = ReferenceField(Foo)$/;" v class:FieldTest.test_reference_miss.Bar +ref mongoengine/tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_invalid_operators.BlogPost +ref mongoengine/tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost +ref mongoengine/tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_manipulative_operators.BlogPost +ref mongoengine/tests/queryset/queryset.py /^ ref = ReferenceField(A)$/;" v class:QuerySetTest.test_chaining.B +ref mongoengine/tests/test_context_managers.py /^ ref = ReferenceField(User, dbref=False)$/;" v class:ContextManagersTest.test_no_dereference_context_manager_object_id.Group +ref mongoengine/tests/test_context_managers.py /^ ref = ReferenceField(User, dbref=True)$/;" v class:ContextManagersTest.test_no_dereference_context_manager_dbref.Group +ref tests/fields/fields.py /^ ref = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_filter_by_dbref.Doc +ref tests/fields/fields.py /^ ref = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_filter_by_objectid.Doc +ref tests/fields/fields.py /^ ref = ReferenceField(Foo)$/;" v class:FieldTest.test_reference_miss.Bar +ref tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_invalid_operators.BlogPost +ref tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost +ref tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_manipulative_operators.BlogPost +ref_id mongoengine/tests/document/indexes.py /^ ref_id = StringField()$/;" v class:IndexesTest.test_hashed_indexes.Book +reference mongoengine/tests/document/validation.py /^ reference = ReferenceField('self')$/;" v class:ValidatorErrorTest.test_parent_reference_in_child_document.Parent +reference mongoengine/tests/document/validation.py /^ reference = ReferenceField('self')$/;" v class:ValidatorErrorTest.test_parent_reference_set_as_attribute_in_child_document.Parent +reference mongoengine/tests/queryset/queryset.py /^ reference = ReferenceField('self', reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_complex_cycle.Dummy +reference mongoengine/tests/queryset/queryset.py /^ reference = ReferenceField('self', reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_cycle.Dummy +reference_field mongoengine/tests/document/instance.py /^ reference_field = ReferenceField(Simple, default=lambda:$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +reference_field mongoengine/tests/document/json_serialisation.py /^ reference_field = ReferenceField(Simple, default=lambda:$/;" v class:TestJson.test_json_complex.Doc +reference_field mongoengine/tests/queryset/queryset.py /^ reference_field = ReferenceField($/;" v class:QuerySetTest.test_json_complex.Doc +register_connection mongoengine/mongoengine/connection.py /^def register_connection(alias, db=None, name=None, host=None, port=None,$/;" f +register_delete_rule mongoengine/mongoengine/document.py /^ def register_delete_rule(cls, document_cls, field_name, rule):$/;" m class:Document +relations mongoengine/tests/test_dereference.py /^ relations = ListField(EmbeddedDocumentField('Relation'))$/;" v class:FieldTest.test_circular_reference.Person +relations mongoengine/tests/test_dereference.py /^ relations = ListField(ReferenceField('self'))$/;" v class:FieldTest.test_circular_reference_on_self.Person +release mongoengine/docs/conf.py /^release = mongoengine.get_version()$/;" v +reload mongoengine/mongoengine/document.py /^ def reload(self, *args, **kwargs):$/;" m class:EmbeddedDocument +reload mongoengine/mongoengine/document.py /^ def reload(self, *fields, **kwargs):$/;" m class:Document +remove mongoengine/mongoengine/base/datastructures.py /^ def remove(self, *args, **kwargs):$/;" m class:BaseList +replace mongoengine/fields.py /^ def replace(self, file_obj, **kwargs):$/;" m class:GridFSProxy +replace mongoengine/mongoengine/fields.py /^ def replace(self, file_obj, **kwargs):$/;" m class:GridFSProxy +required mongoengine/tests/document/instance.py /^ required=False,$/;" v class:InstanceTest.test_db_embedded_doc_field_load.Person +required mongoengine/tests/document/instance.py /^ required=True)$/;" v class:InstanceTest.test_embedded_update.Page +required mongoengine/tests/document/instance.py /^ required=True)$/;" v class:InstanceTest.test_embedded_update_after_save.Page +required mongoengine/tests/document/instance.py /^ required=True)$/;" v class:InstanceTest.test_embedded_update_db_field.Page +required mongoengine/tests/document/instance.py /^ required=True)$/;" v class:InstanceTest.test_list_search_by_embedded.Comment +reset mongoengine/mongoengine/queryset/field_list.py /^ def reset(self):$/;" m class:QueryFieldList +reset_post mongoengine/tests/fields/fields.py /^ def reset_post():$/;" f function:FieldTest.test_list_field_manipulative_operators +reset_post tests/fields/fields.py /^ def reset_post():$/;" f function:FieldTest.test_list_field_manipulative_operators +reverse mongoengine/mongoengine/base/datastructures.py /^ def reverse(self, *args, **kwargs):$/;" m class:BaseList +reverse_delete_rule mongoengine/tests/document/instance.py /^ reverse_delete_rule=NULLIFY))$/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Blog +reverse_delete_rule mongoengine/tests/queryset/queryset.py /^ reverse_delete_rule=PULL))$/;" v class:QuerySetTest.test_reverse_delete_rule_pull.BlogPost +reverse_delete_rule mongoengine/tests/queryset/queryset.py /^ reverse_delete_rule=PULL))$/;" v class:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents.AbstractBlogPost +review_queue mongoengine/tests/document/instance.py /^ review_queue = IntField(default=0)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal.Editor +reviewer mongoengine/tests/document/instance.py /^ reviewer = ReferenceField(User, reverse_delete_rule=NULLIFY)$/;" v class:InstanceTest.test_reverse_delete_rule_with_custom_id_field.Book +reviewer mongoengine/tests/document/instance.py /^ reviewer = ReferenceField(self.Person, reverse_delete_rule=NULLIFY)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify.BlogPost +reviewer mongoengine/tests/document/instance.py /^ reviewer = ReferenceField(self.Person, reverse_delete_rule=NULLIFY)$/;" v class:InstanceTest.test_reverse_delete_rule_with_document_inheritance.BlogPost +reviewers mongoengine/tests/document/instance.py /^ reviewers = DictField($/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Blog +reviewers mongoengine/tests/document/instance.py /^ reviewers = ListField(ReferenceField($/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify_complex_field.BlogPost +rewind mongoengine/mongoengine/queryset/base.py /^ def rewind(self):$/;" m class:BaseQuerySet +roles mongoengine/tests/document/delta.py /^ roles = MapField(field=EmbeddedDocumentField(EmbeddedRole))$/;" v class:DeltaTest.test_delta_for_nested_map_fields.EmbeddedUser +rolist mongoengine/tests/document/delta.py /^ rolist = ListField(field=EmbeddedDocumentField(EmbeddedRole))$/;" v class:DeltaTest.test_delta_for_nested_map_fields.EmbeddedUser +s mongoengine/tests/document/instance.py /^ s = Stats()$/;" v class:InstanceTest.test_reference_inheritance.CompareStats +s mongoengine/tests/queryset/queryset.py /^ s = StringField()$/;" v class:QuerySetTest.test_batch_size.A +s mongoengine/tests/queryset/queryset.py /^ s = StringField()$/;" v class:QuerySetTest.test_chaining.A +s mongoengine/tests/queryset/queryset.py /^ s = StringField()$/;" v class:QuerySetTest.test_none.A +salary mongoengine/tests/document/dynamic.py /^ salary = IntField()$/;" v class:DynamicTest.test_inheritance.Employee +salary mongoengine/tests/document/inheritance.py /^ salary = IntField()$/;" v class:InheritanceTest.test_inheritance_meta_data.Employee +salary mongoengine/tests/document/inheritance.py /^ salary = IntField()$/;" v class:InheritanceTest.test_inheritance_to_mongo_keys.Employee +salary mongoengine/tests/document/instance.py /^ salary = IntField()$/;" v class:InstanceTest.test_embedded_document_to_mongo.Employee +salary mongoengine/tests/document/instance.py /^ salary = IntField()$/;" v class:InstanceTest.test_save_embedded_document.Employee +salary mongoengine/tests/document/instance.py /^ salary = IntField()$/;" v class:InstanceTest.test_updating_an_embedded_document.Employee +salary mongoengine/tests/fields/fields.py /^ salary = DecimalField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.PersonAuto +salary mongoengine/tests/queryset/field_list.py /^ salary = IntField(db_field='wage')$/;" v class:OnlyExcludeAllTest.test_only.Employee +salary tests/fields/fields.py /^ salary = DecimalField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.PersonAuto +save mongoengine/mongoengine/base/datastructures.py /^ def save(self, *args, **kwargs):$/;" m class:EmbeddedDocumentList +save mongoengine/mongoengine/document.py /^ def save(self, *args, **kwargs):$/;" m class:EmbeddedDocument +save mongoengine/mongoengine/document.py /^ def save(self, force_insert=False, validate=True, clean=True,$/;" m class:Document +save mongoengine/tests/document/instance.py /^ def save(self, *args, **kwargs):$/;" m class:InstanceTest.test_complex_nesting_document_and_embedded_document.NodesSystem +save_id mongoengine/tests/document/instance.py /^ save_id = UUIDField()$/;" v class:InstanceTest.test_save_atomicity_condition.Widget +scalar mongoengine/mongoengine/queryset/base.py /^ def scalar(self, *fields):$/;" m class:BaseQuerySet +scope mongoengine/tests/queryset/queryset.py /^ scope=scope)$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +score mongoengine/tests/queryset/queryset.py /^ score = IntField()$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.Vote +search_text mongoengine/mongoengine/queryset/base.py /^ def search_text(self, text, language=None):$/;" m class:BaseQuerySet +select_related mongoengine/mongoengine/document.py /^ def select_related(self, max_depth=1):$/;" m class:Document +select_related mongoengine/mongoengine/queryset/base.py /^ def select_related(self, max_depth=1):$/;" m class:BaseQuerySet +send mongoengine/mongoengine/signals.py /^ send = lambda *a, **kw: None # noqa$/;" v class:_FakeSignal +sender mongoengine/tests/queryset/field_list.py /^ sender = StringField()$/;" v class:OnlyExcludeAllTest.test_all_fields.Email +sender mongoengine/tests/queryset/field_list.py /^ sender = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email +sequence_field mongoengine/tests/document/instance.py /^ sequence_field = SequenceField()$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +sequence_field mongoengine/tests/document/json_serialisation.py /^ sequence_field = SequenceField()$/;" v class:TestJson.test_json_complex.Doc +sequence_field mongoengine/tests/queryset/queryset.py /^ sequence_field = SequenceField()$/;" v class:QuerySetTest.test_json_complex.Doc +setUp mongoengine/tests/all_warnings/__init__.py /^ def setUp(self):$/;" m class:AllWarnings +setUp mongoengine/tests/document/class_methods.py /^ def setUp(self):$/;" m class:ClassMethodsTest +setUp mongoengine/tests/document/delta.py /^ def setUp(self):$/;" m class:DeltaTest +setUp mongoengine/tests/document/dynamic.py /^ def setUp(self):$/;" m class:DynamicTest +setUp mongoengine/tests/document/indexes.py /^ def setUp(self):$/;" m class:IndexesTest +setUp mongoengine/tests/document/inheritance.py /^ def setUp(self):$/;" m class:InheritanceTest +setUp mongoengine/tests/document/instance.py /^ def setUp(self):$/;" m class:InstanceTest +setUp mongoengine/tests/document/json_serialisation.py /^ def setUp(self):$/;" m class:TestJson +setUp mongoengine/tests/document/validation.py /^ def setUp(self):$/;" m class:ValidatorErrorTest +setUp mongoengine/tests/fields/fields.py /^ def setUp(self):$/;" m class:EmbeddedDocumentListFieldTestCase +setUp mongoengine/tests/fields/geo.py /^ def setUp(self):$/;" m class:GeoFieldTest +setUp mongoengine/tests/queryset/field_list.py /^ def setUp(self):$/;" m class:OnlyExcludeAllTest +setUp mongoengine/tests/queryset/modify.py /^ def setUp(self):$/;" m class:FindAndModifyTest +setUp mongoengine/tests/queryset/pickable.py /^ def setUp(self):$/;" m class:TestQuerysetPickable +setUp mongoengine/tests/queryset/queryset.py /^ def setUp(self):$/;" m class:QuerySetTest +setUp mongoengine/tests/queryset/transform.py /^ def setUp(self):$/;" m class:TransformTest +setUp mongoengine/tests/queryset/visitor.py /^ def setUp(self):$/;" m class:QTest +setUp mongoengine/tests/test_datastructures.py /^ def setUp(self):$/;" m class:TestStrictDict +setUp mongoengine/tests/test_replicaset_connection.py /^ def setUp(self):$/;" m class:ConnectionTest +setUp mongoengine/tests/test_signals.py /^ def setUp(self):$/;" m class:SignalTests +setUp tests/fields/fields.py /^ def setUp(self):$/;" m class:EmbeddedDocumentListFieldTestCase +setUpClass mongoengine/tests/test_dereference.py /^ def setUpClass(cls):$/;" m class:FieldTest +setUpClass mongoengine/tests/utils.py /^ def setUpClass(cls):$/;" m class:MongoDBTestCase +set__authors mongoengine/tests/queryset/queryset.py /^ set__authors=[Author(name="Harry"),$/;" v class:QuerySetTest.test_set_list_embedded_documents.Message +set__authors__S mongoengine/tests/queryset/queryset.py /^ set__authors__S=Author(name="Ross"))$/;" v class:QuerySetTest.test_set_list_embedded_documents.Message +set__bar mongoengine/tests/queryset/queryset.py /^ set__bar=Bar(name='test'), upsert=True)$/;" v class:QuerySetTest.test_set_generic_embedded_documents.User +set__comments__S__votes mongoengine/tests/queryset/queryset.py /^ set__comments__S__votes=Vote(score=4))$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.BlogPost +set__comp_dt_fld mongoengine/tests/fields/fields.py /^ set__comp_dt_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +set__comp_dt_fld tests/fields/fields.py /^ set__comp_dt_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +set__flt_fld mongoengine/tests/fields/fields.py /^ set__flt_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +set__flt_fld tests/fields/fields.py /^ set__flt_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +set__int_fld mongoengine/tests/fields/fields.py /^ set__int_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +set__int_fld tests/fields/fields.py /^ set__int_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +set__mapping mongoengine/tests/fields/fields.py /^ set__mapping={"someint": IntegerSetting(value=10)})$/;" v class:FieldTest.test_dictfield_complex.Simple +set__mapping tests/fields/fields.py /^ set__mapping={"someint": IntegerSetting(value=10)})$/;" v class:FieldTest.test_dictfield_complex.Simple +set__mapping__2__list__1 mongoengine/tests/fields/fields.py /^ set__mapping__2__list__1=StringSetting(value='Boo'))$/;" v class:FieldTest.test_list_field_complex.Simple +set__mapping__2__list__1 tests/fields/fields.py /^ set__mapping__2__list__1=StringSetting(value='Boo'))$/;" v class:FieldTest.test_list_field_complex.Simple +set__mapping__nested_dict__list__1 mongoengine/tests/fields/fields.py /^ set__mapping__nested_dict__list__1=StringSetting(value='Boo'))$/;" v class:FieldTest.test_dictfield_complex.Simple +set__mapping__nested_dict__list__1 tests/fields/fields.py /^ set__mapping__nested_dict__list__1=StringSetting(value='Boo'))$/;" v class:FieldTest.test_dictfield_complex.Simple +set__members mongoengine/tests/queryset/queryset.py /^ set__members={"John": Member(gender="F", age=14)})$/;" v class:QuerySetTest.test_mapfield_update.Club +set__members mongoengine/tests/queryset/queryset.py /^ set__members={"John": {'gender': 'F', 'age': 14}})$/;" v class:QuerySetTest.test_dictfield_update.Club +set__posts__1__comments__1__name mongoengine/tests/queryset/queryset.py /^ set__posts__1__comments__1__name='testc')$/;" v class:QuerySetTest.test_update_array_position.Blog +set__str_fld mongoengine/tests/fields/fields.py /^ set__str_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +set__str_fld tests/fields/fields.py /^ set__str_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +set_next_value mongoengine/fields.py /^ def set_next_value(self, value):$/;" m class:SequenceField +set_next_value mongoengine/mongoengine/fields.py /^ def set_next_value(self, value):$/;" m class:SequenceField +setdefault mongoengine/mongoengine/base/datastructures.py /^ def setdefault(self, *args, **kwargs):$/;" m class:BaseDict +shape mongoengine/tests/queryset/queryset.py /^ shape = StringField()$/;" v class:QuerySetTest.test_elem_match.Foo +shard_1 mongoengine/tests/document/indexes.py /^ shard_1 = StringField()$/;" v class:IndexesTest.test_compound_index_underscore_cls_not_overwritten.TestDoc +sibling mongoengine/tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_abstract_reference_base_type.Brother +sibling mongoengine/tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_reference_abstract_class.Brother +sibling mongoengine/tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Brother +sibling tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_abstract_reference_base_type.Brother +sibling tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_reference_abstract_class.Brother +sibling tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Brother +signal mongoengine/mongoengine/signals.py /^ def signal(self, name, doc=None):$/;" m class:Namespace +signal_output mongoengine/tests/test_signals.py /^signal_output = []$/;" v +signals_available mongoengine/mongoengine/signals.py /^ signals_available = True$/;" v +signals_available mongoengine/mongoengine/signals.py /^signals_available = False$/;" v +size mongoengine/fields.py /^ def size(self):$/;" m class:ImageGridFsProxy +size mongoengine/mongoengine/fields.py /^ def size(self):$/;" m class:ImageGridFsProxy +size mongoengine/tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_accept_possible_value.Shirt +size mongoengine/tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_allow_no_value.Shirt +size mongoengine/tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_reject_unknown_value.Shirt +size mongoengine/tests/fields/fields.py /^ size = StringField(choices={'M', 'L'})$/;" v class:FieldTest.test_choices_allow_using_sets_as_choices.Shirt +size mongoengine/tests/fields/fields.py /^ size = StringField(max_length=3, choices=($/;" v class:FieldTest.test_choices_get_field_display.Shirt +size mongoengine/tests/fields/fields.py /^ size = StringField(max_length=3, choices=SIZES)$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt +size mongoengine/tests/fields/fields.py /^ size = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt +size mongoengine/tests/fields/fields.py /^ size = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_validation.Shirt +size mongoengine/tests/queryset/queryset.py /^ size = ReferenceField(Size)$/;" v class:QuerySetTest.test_can_have_field_same_name_as_query_operator.Example +size tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_accept_possible_value.Shirt +size tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_allow_no_value.Shirt +size tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_reject_unknown_value.Shirt +size tests/fields/fields.py /^ size = StringField(choices={'M', 'L'})$/;" v class:FieldTest.test_choices_allow_using_sets_as_choices.Shirt +size tests/fields/fields.py /^ size = StringField(max_length=3, choices=($/;" v class:FieldTest.test_choices_get_field_display.Shirt +size tests/fields/fields.py /^ size = StringField(max_length=3, choices=SIZES)$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt +size tests/fields/fields.py /^ size = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt +size tests/fields/fields.py /^ size = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_validation.Shirt +skip mongoengine/mongoengine/queryset/base.py /^ def skip(self, n):$/;" m class:BaseQuerySet +skip_pymongo3 mongoengine/tests/utils.py /^def skip_pymongo3(f):$/;" f +slave_okay mongoengine/mongoengine/queryset/base.py /^ def slave_okay(self, enabled):$/;" m class:BaseQuerySet +slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique=True)$/;" v class:IndexesTest.test_indexes_after_database_drop.BlogPost +slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique=True)$/;" v class:IndexesTest.test_unique.BlogPost +slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique=True)$/;" v class:IndexesTest.test_unique_embedded_document.SubDocument +slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique=True)$/;" v class:IndexesTest.test_unique_embedded_document_in_list.SubDocument +slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique=True)$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.SubDocument +slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique_with='date.year')$/;" v class:IndexesTest.test_unique_with.BlogPost +slug mongoengine/tests/document/instance.py /^ slug = StringField()$/;" v class:InstanceTest.test_push_nested_list.BlogPost +slug mongoengine/tests/document/instance.py /^ slug = StringField()$/;" v class:InstanceTest.test_push_with_position.BlogPost +slug mongoengine/tests/queryset/queryset.py /^ slug = StringField()$/;" v class:QuerySetTest.test_editting_embedded_objects.BlogPost +slug mongoengine/tests/queryset/queryset.py /^ slug = StringField()$/;" v class:QuerySetTest.test_update_one_pop_generic_reference.BlogPost +slug mongoengine/tests/queryset/queryset.py /^ slug = StringField()$/;" v class:QuerySetTest.test_update_push_and_pull_add_to_set.BlogPost +slug mongoengine/tests/queryset/queryset.py /^ slug = StringField()$/;" v class:QuerySetTest.test_update_push_list_of_list.BlogPost +slug mongoengine/tests/queryset/queryset.py /^ slug = StringField()$/;" v class:QuerySetTest.test_update_push_with_position.BlogPost +snapshot mongoengine/mongoengine/queryset/base.py /^ def snapshot(self, enabled):$/;" m class:BaseQuerySet +some mongoengine/tests/queryset/field_list.py /^ some = BooleanField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.VariousData +some_long mongoengine/tests/fields/fields.py /^ some_long = LongField()$/;" v class:FieldTest.test_long_field_is_considered_as_int64.TestLongFieldConsideredAsInt64 +some_long tests/fields/fields.py /^ some_long = LongField()$/;" v class:FieldTest.test_long_field_is_considered_as_int64.TestLongFieldConsideredAsInt64 +song mongoengine/tests/test_dereference.py /^ song = ReferenceField("Song")$/;" v class:FieldTest.test_select_related_follows_embedded_referencefields.PlaylistItem +songs mongoengine/tests/test_dereference.py /^ songs = [item.song for item in playlist.items]$/;" v class:FieldTest.test_select_related_follows_embedded_referencefields.Playlist +sort mongoengine/mongoengine/base/datastructures.py /^ def sort(self, *args, **kwargs):$/;" m class:BaseList +sorted_list_field mongoengine/tests/document/instance.py /^ sorted_list_field = SortedListField(IntField(),$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +sorted_list_field mongoengine/tests/document/json_serialisation.py /^ sorted_list_field = SortedListField(IntField(),$/;" v class:TestJson.test_json_complex.Doc +sorted_list_field mongoengine/tests/queryset/queryset.py /^ sorted_list_field = SortedListField(IntField(),$/;" v class:QuerySetTest.test_json_complex.Doc +source_suffix mongoengine/docs/conf.py /^source_suffix = '.rst'$/;" v +staffs_with_position mongoengine/tests/test_dereference.py /^ staffs_with_position = ListField(DictField())$/;" v class:FieldTest.test_dict_in_dbref_instance.Room +start_listener mongoengine/fields.py /^ def start_listener(self):$/;" m class:CachedReferenceField +start_listener mongoengine/mongoengine/fields.py /^ def start_listener(self):$/;" m class:CachedReferenceField +state mongoengine/tests/queryset/queryset.py /^ state = GenericReferenceField()$/;" v class:QuerySetTest.test_scalar_generic_reference_field.Person +state mongoengine/tests/queryset/queryset.py /^ state = ReferenceField(State)$/;" v class:QuerySetTest.test_scalar_reference_field.Person +stats mongoengine/tests/document/instance.py /^ stats = ListField(ReferenceField(Stats))$/;" v class:InstanceTest.test_reference_inheritance.CompareStats +status mongoengine/tests/document/instance.py /^ status = StringField()$/;" v class:InstanceTest.test_document_clean.TestDocument +status mongoengine/tests/document/instance.py /^ status = StringField()$/;" v class:InstanceTest.test_document_embedded_clean.TestDocument +stem mongoengine/tests/document/instance.py /^ stem = StringField()$/;" v class:InstanceTest.test_invalid_son.Word +stored mongoengine/tests/fields/fields.py /^ stored = LogEntry(date=datetime.datetime(*values)).to_mongo()['date']$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry +stored tests/fields/fields.py /^ stored = LogEntry(date=datetime.datetime(*values)).to_mongo()['date']$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry +str_f mongoengine/tests/queryset/queryset.py /^ str_f = StringField()$/;" v class:QuerySetTest.test_update_validate.Doc +str_f mongoengine/tests/queryset/queryset.py /^ str_f = StringField()$/;" v class:QuerySetTest.test_update_validate.EmDoc +str_fld mongoengine/tests/document/instance.py /^ str_fld = StringField(null=True)$/;" v class:InstanceTest.test_null_field.User +str_fld mongoengine/tests/fields/fields.py /^ str_fld = StringField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +str_fld mongoengine/tests/fields/fields.py /^ str_fld = StringField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields +str_fld tests/fields/fields.py /^ str_fld = StringField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields +str_fld tests/fields/fields.py /^ str_fld = StringField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields +strict_dict_class mongoengine/tests/test_datastructures.py /^ def strict_dict_class(self, *args, **kwargs):$/;" m class:TestStrictDict +string mongoengine/tests/document/instance.py /^ string = StringField()$/;" v class:InstanceTest.test_embedded_document_complex_instance.Embedded +string mongoengine/tests/document/instance.py /^ string = StringField()$/;" v class:InstanceTest.test_embedded_document_instance.Embedded +string mongoengine/tests/document/instance.py /^ string = StringField(db_field='s')$/;" v class:InstanceTest.test_embedded_document_complex_instance_no_use_db_field.Embedded +string mongoengine/tests/document/json_serialisation.py /^ string = StringField()$/;" v class:TestJson.test_json_simple.Doc +string mongoengine/tests/document/json_serialisation.py /^ string = StringField()$/;" v class:TestJson.test_json_simple.Embedded +string mongoengine/tests/document/json_serialisation.py /^ string = StringField(db_field='s')$/;" v class:TestJson.test_json_names.Doc +string mongoengine/tests/document/json_serialisation.py /^ string = StringField(db_field='s')$/;" v class:TestJson.test_json_names.Embedded +string mongoengine/tests/fixtures.py /^ string = StringField(choices=(('One', '1'), ('Two', '2')))$/;" v class:NewDocumentPickleTest +string mongoengine/tests/fixtures.py /^ string = StringField(choices=(('One', '1'), ('Two', '2')))$/;" v class:PickleSignalsTest +string mongoengine/tests/fixtures.py /^ string = StringField(choices=(('One', '1'), ('Two', '2')))$/;" v class:PickleTest +string mongoengine/tests/queryset/queryset.py /^ string = StringField()$/;" v class:QuerySetTest.test_json_simple.Doc +string mongoengine/tests/queryset/queryset.py /^ string = StringField()$/;" v class:QuerySetTest.test_json_simple.Embedded +string_field mongoengine/tests/document/delta.py /^ string_field = StringField()$/;" v class:DeltaTest.delta.Doc +string_field mongoengine/tests/document/delta.py /^ string_field = StringField()$/;" v class:DeltaTest.delta_recursive.Doc +string_field mongoengine/tests/document/delta.py /^ string_field = StringField()$/;" v class:DeltaTest.delta_recursive.Embedded +string_field mongoengine/tests/document/delta.py /^ string_field = StringField(db_field='db_string_field')$/;" v class:DeltaTest.delta_db_field.Doc +string_field mongoengine/tests/document/delta.py /^ string_field = StringField(db_field='db_string_field')$/;" v class:DeltaTest.delta_recursive_db_field.Doc +string_field mongoengine/tests/document/delta.py /^ string_field = StringField(db_field='db_string_field')$/;" v class:DeltaTest.delta_recursive_db_field.Embedded +string_field mongoengine/tests/document/instance.py /^ string_field = StringField(default='1')$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +string_field mongoengine/tests/document/json_serialisation.py /^ string_field = StringField(default='1')$/;" v class:TestJson.test_json_complex.Doc +string_field mongoengine/tests/queryset/queryset.py /^ string_field = StringField(default='1')$/;" v class:QuerySetTest.test_json_complex.Doc +string_value mongoengine/tests/fields/fields.py /^ string_value = DecimalField(precision=4, force_string=True)$/;" v class:FieldTest.test_decimal_storage.Person +string_value tests/fields/fields.py /^ string_value = DecimalField(precision=4, force_string=True)$/;" v class:FieldTest.test_decimal_storage.Person +style mongoengine/tests/fields/fields.py /^ style = StringField(max_length=3, choices=($/;" v class:FieldTest.test_choices_get_field_display.Shirt +style mongoengine/tests/fields/fields.py /^ style = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt +style tests/fields/fields.py /^ style = StringField(max_length=3, choices=($/;" v class:FieldTest.test_choices_get_field_display.Shirt +style tests/fields/fields.py /^ style = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt +sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2009, slug="test"))$/;" v class:IndexesTest.test_unique_embedded_document.BlogPost +sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2009, slug="test"))$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost +sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2009, slug='test-1'))$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost +sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2010, slug='another-slug'))$/;" v class:IndexesTest.test_unique_embedded_document.BlogPost +sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2010, slug='another-slug'))$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost +sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2010, slug='test'))$/;" v class:IndexesTest.test_unique_embedded_document.BlogPost +sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2010, slug='test'))$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost +sub mongoengine/tests/document/indexes.py /^ sub = EmbeddedDocumentField(SubDocument)$/;" v class:IndexesTest.test_unique_embedded_document.BlogPost +sub mongoengine/tests/document/indexes.py /^ sub = EmbeddedDocumentField(SubDocument)$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost +sub mongoengine/tests/document/instance.py /^ sub = UserSubscription(user=u1.pk, feed=f1.pk)$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription +sub mongoengine/tests/document/instance.py /^ sub = UserSubscription(user=user, feed=feed)$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription +sub mongoengine/tests/document/instance.py /^ sub = UserSubscription.objects.first()$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription +subclasses_and_unique_keys_works mongoengine/tests/document/instance.py /^ def subclasses_and_unique_keys_works(self):$/;" m class:InstanceTest +subject mongoengine/tests/queryset/field_list.py /^ subject = StringField()$/;" v class:OnlyExcludeAllTest.test_all_fields.Email +subject mongoengine/tests/queryset/field_list.py /^ subject = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email +submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=10)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=13)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=2)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=4)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=5)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=6)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +submitted mongoengine/tests/queryset/queryset.py /^ submitted = DateTimeField(db_field='sTime')$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +subs mongoengine/tests/document/delta.py /^ subs = MapField(EmbeddedDocumentField(EmbeddedDoc))$/;" v class:DeltaTest.test_lower_level_mark_as_changed.MyDoc +subs mongoengine/tests/document/delta.py /^ subs = MapField(EmbeddedDocumentField(EmbeddedDoc))$/;" v class:DeltaTest.test_upper_level_mark_as_changed.MyDoc +subs mongoengine/tests/document/delta.py /^ subs = MapField(MapField(EmbeddedDocumentField(EmbeddedDoc)))$/;" v class:DeltaTest.test_nested_nested_fields_mark_as_changed.MyDoc +subs mongoengine/tests/document/indexes.py /^ subs = ListField(EmbeddedDocumentField(SubDocument))$/;" v class:IndexesTest.test_unique_embedded_document_in_list.BlogPost +sum mongoengine/mongoengine/queryset/base.py /^ def sum(self, field):$/;" m class:BaseQuerySet +superphylum mongoengine/tests/document/instance.py /^ superphylum = EmbeddedDocumentField(SuperPhylum)$/;" v class:InstanceTest.test_reload_sharded_nested.Animal +superphylum mongoengine/tests/document/instance.py /^ superphylum = StringField()$/;" v class:InstanceTest.test_reload_sharded.Animal +switch_collection mongoengine/mongoengine/context_managers.py /^class switch_collection(object):$/;" c +switch_collection mongoengine/mongoengine/document.py /^ def switch_collection(self, collection_name, keep_created=True):$/;" m class:Document +switch_db mongoengine/mongoengine/context_managers.py /^class switch_db(object):$/;" c +switch_db mongoengine/mongoengine/document.py /^ def switch_db(self, db_alias, keep_created=True):$/;" m class:Document +sync_all mongoengine/fields.py /^ def sync_all(self):$/;" m class:CachedReferenceField +sync_all mongoengine/mongoengine/fields.py /^ def sync_all(self):$/;" m class:CachedReferenceField +t mongoengine/benchmark.py /^ t = timeit.Timer(stmt=stmt, setup=setup)$/;" v +t mongoengine/tests/fields/file_tests.py /^ t = TestImage()$/;" v class:FileTest.test_image_field.TestImage +t mongoengine/tests/queryset/queryset.py /^ t = Number(n=i)$/;" v class:QuerySetTest.test_clone.Number +t mongoengine/tests/queryset/queryset.py /^ t = Number2(n=i)$/;" v class:QuerySetTest.test_using.Number2 +t mongoengine/tests/queryset/visitor.py /^ t = TestDoc(x=i)$/;" v class:QTest.test_q_clone.TestDoc +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_equality.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal +tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Animal +tag mongoengine/tests/queryset/queryset.py /^ tag = StringField()$/;" v class:QuerySetTest.test_item_frequencies_with_null_embedded.Extra +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_equality.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal +tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Animal +tag_list mongoengine/tests/document/class_methods.py /^ tag_list = ListField(StringField())$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPostWithTags +tag_list mongoengine/tests/document/class_methods.py /^ tag_list = ListField(StringField())$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPostWithTags +tags mongoengine/docs/code/tumblelog.py /^ tags = ListField(StringField(max_length=30))$/;" v class:Post +tags mongoengine/tests/document/class_methods.py /^ tags = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes.BlogPost +tags mongoengine/tests/document/class_methods.py /^ tags = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPostWithTags +tags mongoengine/tests/document/class_methods.py /^ tags = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPostWithTags +tags mongoengine/tests/document/class_methods.py /^ tags = StringField()$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPostWithTags +tags mongoengine/tests/document/indexes.py /^ tags=[Tag(name="about"), Tag(name="time")])$/;" v class:IndexesTest.test_list_embedded_document_index.BlogPost +tags mongoengine/tests/document/indexes.py /^ tags = ListField(EmbeddedDocumentField(Tag))$/;" v class:IndexesTest.test_list_embedded_document_index.BlogPost +tags mongoengine/tests/document/indexes.py /^ tags = ListField(StringField())$/;" v class:IndexesTest._index_test.BlogPost +tags mongoengine/tests/document/indexes.py /^ tags = ListField(StringField())$/;" v class:IndexesTest._index_test_inheritance.BlogPost +tags mongoengine/tests/document/indexes.py /^ tags = ListField(StringField())$/;" v class:IndexesTest.test_dictionary_indexes.BlogPost +tags mongoengine/tests/document/indexes.py /^ tags = ListField(StringField())$/;" v class:IndexesTest.test_hint.BlogPost +tags mongoengine/tests/document/indexes.py /^ tags = [("tag %i" % n) for n in range(0, i % 2)]$/;" v class:IndexesTest.test_hint.BlogPost +tags mongoengine/tests/document/instance.py /^ tags = ListField()$/;" v class:InstanceTest.test_push_nested_list.BlogPost +tags mongoengine/tests/document/instance.py /^ tags = ListField(StringField())$/;" v class:InstanceTest.test_modify_with_positional_push.BlogPost +tags mongoengine/tests/document/instance.py /^ tags = ListField(StringField())$/;" v class:InstanceTest.test_push_with_position.BlogPost +tags mongoengine/tests/document/instance.py /^ tags = ListField(StringField())$/;" v class:InstanceTest.test_save_list.BlogPost +tags mongoengine/tests/fields/fields.py /^ tags = ListField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData +tags mongoengine/tests/fields/fields.py /^ tags = ListField(StringField())$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Owner +tags mongoengine/tests/fields/fields.py /^ tags = ListField(StringField())$/;" v class:FieldTest.test_list_validation.BlogPost +tags mongoengine/tests/fields/fields.py /^ tags = SortedListField(StringField())$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost +tags mongoengine/tests/queryset/modify.py /^ tags = ListField(StringField())$/;" v class:FindAndModifyTest.test_modify_with_push.BlogPost +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField()$/;" v class:QuerySetTest.test_update_push_list_of_list.BlogPost +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(EmbeddedDocumentField(BlogTag), required=True)$/;" v class:QuerySetTest.test_editting_embedded_objects.BlogPost +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(ReferenceField(BlogTag), required=True)$/;" v class:QuerySetTest.test_update_one_pop_generic_reference.BlogPost +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_bulk_insert.Blog +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_custom_manager.BlogPost +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_find_array_position.Blog +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_map_reduce_with_custom_object_ids.BlogPost +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_update.BlogPost +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_update_array_position.Blog +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_update_push_and_pull_add_to_set.BlogPost +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_update_push_with_position.BlogPost +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Post +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField(), db_field='blogTags')$/;" v class:QuerySetTest.test_item_frequencies.BlogPost +tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField(), db_field='post-tag-list')$/;" v class:QuerySetTest.test_map_reduce.BlogPost +tags mongoengine/tests/queryset/visitor.py /^ tags = ListField(StringField())$/;" v class:QTest.test_q_lists.BlogPost +tags mongoengine/tests/test_dereference.py /^ tags = ListField(ReferenceField("Tag", dbref=True))$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Page +tags mongoengine/tests/test_dereference.py /^ tags = ListField(ReferenceField("Tag", dbref=True))$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Post +tags tests/fields/fields.py /^ tags = ListField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData +tags tests/fields/fields.py /^ tags = ListField(StringField())$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Owner +tags tests/fields/fields.py /^ tags = ListField(StringField())$/;" v class:FieldTest.test_list_validation.BlogPost +tags tests/fields/fields.py /^ tags = SortedListField(StringField())$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost +tearDown mongoengine/tests/all_warnings/__init__.py /^ def tearDown(self):$/;" m class:AllWarnings +tearDown mongoengine/tests/document/class_methods.py /^ def tearDown(self):$/;" m class:ClassMethodsTest +tearDown mongoengine/tests/document/delta.py /^ def tearDown(self):$/;" m class:DeltaTest +tearDown mongoengine/tests/document/indexes.py /^ def tearDown(self):$/;" m class:IndexesTest +tearDown mongoengine/tests/document/inheritance.py /^ def tearDown(self):$/;" m class:InheritanceTest +tearDown mongoengine/tests/document/instance.py /^ def tearDown(self):$/;" m class:InstanceTest +tearDown mongoengine/tests/fields/file_tests.py /^ def tearDown(self):$/;" m class:FileTest +tearDown mongoengine/tests/queryset/queryset.py /^ def tearDown(self):$/;" m class:QuerySetTest +tearDown mongoengine/tests/test_connection.py /^ def tearDown(self):$/;" m class:ConnectionTest +tearDown mongoengine/tests/test_replicaset_connection.py /^ def tearDown(self):$/;" m class:ConnectionTest +tearDown mongoengine/tests/test_signals.py /^ def tearDown(self):$/;" m class:SignalTests +tearDownClass mongoengine/tests/test_dereference.py /^ def tearDownClass(cls):$/;" m class:FieldTest +tearDownClass mongoengine/tests/utils.py /^ def tearDownClass(cls):$/;" m class:MongoDBTestCase +templates_path mongoengine/docs/conf.py /^templates_path = ['_templates']$/;" v +term mongoengine/tests/document/indexes.py /^ term = StringField(required=True)$/;" v class:IndexesTest.test_compound_key_embedded.CompoundKey +test mongoengine/tests/queryset/queryset.py /^ test = DictField()$/;" v class:QuerySetTest.test_dictfield_key_looks_like_a_digit.MyDoc +test mongoengine/tests/queryset/queryset.py /^ test = StringField()$/;" v class:QuerySetTest.test_upsert_includes_cls.Test +test2 mongoengine/tests/document/instance.py /^ test2 = ReferenceField('Test2')$/;" v class:InstanceTest.test_dbref_equality.Test +test3 mongoengine/tests/document/instance.py /^ test3 = ReferenceField('Test3')$/;" v class:InstanceTest.test_dbref_equality.Test +test_2dsphere_geo_within_box mongoengine/tests/queryset/geo.py /^ def test_2dsphere_geo_within_box(self):$/;" m class:GeoQueriesTest +test_2dsphere_geo_within_center mongoengine/tests/queryset/geo.py /^ def test_2dsphere_geo_within_center(self):$/;" m class:GeoQueriesTest +test_2dsphere_geo_within_polygon mongoengine/tests/queryset/geo.py /^ def test_2dsphere_geo_within_polygon(self):$/;" m class:GeoQueriesTest +test_2dsphere_linestring_sets_correctly mongoengine/tests/queryset/geo.py /^ def test_2dsphere_linestring_sets_correctly(self):$/;" m class:GeoQueriesTest +test_2dsphere_near mongoengine/tests/queryset/geo.py /^ def test_2dsphere_near(self):$/;" m class:GeoQueriesTest +test_2dsphere_near_and_max_distance mongoengine/tests/queryset/geo.py /^ def test_2dsphere_near_and_max_distance(self):$/;" m class:GeoQueriesTest +test_2dsphere_near_and_min_max_distance mongoengine/tests/queryset/geo.py /^ def test_2dsphere_near_and_min_max_distance(self):$/;" m class:GeoQueriesTest +test_2dsphere_point_embedded mongoengine/tests/queryset/geo.py /^ def test_2dsphere_point_embedded(self):$/;" m class:GeoQueriesTest +test_2dsphere_point_sets_correctly mongoengine/tests/queryset/geo.py /^ def test_2dsphere_point_sets_correctly(self):$/;" m class:GeoQueriesTest +test_abstract_document_creation_does_not_fail mongoengine/tests/document/inheritance.py /^ def test_abstract_document_creation_does_not_fail(self):$/;" m class:InheritanceTest +test_abstract_documents mongoengine/tests/document/inheritance.py /^ def test_abstract_documents(self):$/;" m class:InheritanceTest +test_abstract_embedded_documents mongoengine/tests/document/inheritance.py /^ def test_abstract_embedded_documents(self):$/;" m class:InheritanceTest +test_abstract_handle_ids_in_metaclass_properly mongoengine/tests/document/inheritance.py /^ def test_abstract_handle_ids_in_metaclass_properly(self):$/;" m class:InheritanceTest +test_abstract_index_inheritance mongoengine/tests/document/indexes.py /^ def test_abstract_index_inheritance(self):$/;" m class:IndexesTest +test_abstract_reference_base_type mongoengine/tests/fields/fields.py /^ def test_abstract_reference_base_type(self):$/;" m class:FieldTest +test_abstract_reference_base_type tests/fields/fields.py /^ def test_abstract_reference_base_type(self):$/;" m class:FieldTest +test_add_to_set_each mongoengine/tests/queryset/queryset.py /^ def test_add_to_set_each(self):$/;" m class:QuerySetTest +test_all_fields mongoengine/tests/queryset/field_list.py /^ def test_all_fields(self):$/;" m class:OnlyExcludeAllTest +test_allow_inheritance mongoengine/tests/document/inheritance.py /^ def test_allow_inheritance(self):$/;" m class:InheritanceTest +test_allow_inheritance_abstract_document mongoengine/tests/document/inheritance.py /^ def test_allow_inheritance_abstract_document(self):$/;" m class:InheritanceTest +test_allow_inheritance_embedded_document mongoengine/tests/document/inheritance.py /^ def test_allow_inheritance_embedded_document(self):$/;" m class:InheritanceTest +test_always_include mongoengine/tests/queryset/field_list.py /^ def test_always_include(self):$/;" m class:QueryFieldListTest +test_and_combination mongoengine/tests/queryset/visitor.py /^ def test_and_combination(self):$/;" m class:QTest +test_and_or_combination mongoengine/tests/queryset/visitor.py /^ def test_and_or_combination(self):$/;" m class:QTest +test_array_average mongoengine/tests/queryset/queryset.py /^ def test_array_average(self):$/;" m class:QuerySetTest +test_array_sum mongoengine/tests/queryset/queryset.py /^ def test_array_sum(self):$/;" m class:QuerySetTest +test_as_pymongo mongoengine/tests/queryset/queryset.py /^ def test_as_pymongo(self):$/;" m class:QuerySetTest +test_as_pymongo_json_limit_fields mongoengine/tests/queryset/queryset.py /^ def test_as_pymongo_json_limit_fields(self):$/;" m class:QuerySetTest +test_aspymongo_with_only mongoengine/tests/queryset/geo.py /^ def test_aspymongo_with_only(self):$/;" m class:GeoQueriesTest +test_assertions mongoengine/tests/queryset/queryset.py /^ def test_assertions(f):$/;" f function:QuerySetTest.test_item_frequencies +test_assertions mongoengine/tests/queryset/queryset.py /^ def test_assertions(f):$/;" f function:QuerySetTest.test_item_frequencies_on_embedded +test_atomic_update_dict_field mongoengine/tests/fields/fields.py /^ def test_atomic_update_dict_field(self):$/;" m class:FieldTest +test_atomic_update_dict_field tests/fields/fields.py /^ def test_atomic_update_dict_field(self):$/;" m class:FieldTest +test_auto_id_not_set_if_specific_in_parent_class mongoengine/tests/document/inheritance.py /^ def test_auto_id_not_set_if_specific_in_parent_class(self):$/;" m class:InheritanceTest +test_auto_id_vs_non_pk_id_field mongoengine/tests/document/inheritance.py /^ def test_auto_id_vs_non_pk_id_field(self):$/;" m class:InheritanceTest +test_average mongoengine/tests/queryset/queryset.py /^ def test_average(self):$/;" m class:QuerySetTest +test_average_over_db_field mongoengine/tests/queryset/queryset.py /^ def test_average_over_db_field(self):$/;" m class:QuerySetTest +test_bad_mixed_creation mongoengine/tests/document/instance.py /^ def test_bad_mixed_creation(self):$/;" m class:InstanceTest +test_batch_size mongoengine/tests/queryset/queryset.py /^ def test_batch_size(self):$/;" m class:QuerySetTest +test_binary_field_primary mongoengine/tests/fields/fields.py /^ def test_binary_field_primary(self):$/;" m class:FieldTest +test_binary_field_primary tests/fields/fields.py /^ def test_binary_field_primary(self):$/;" m class:FieldTest +test_binary_field_primary_filter_by_binary_pk_as_str mongoengine/tests/fields/fields.py /^ def test_binary_field_primary_filter_by_binary_pk_as_str(self):$/;" m class:FieldTest +test_binary_field_primary_filter_by_binary_pk_as_str tests/fields/fields.py /^ def test_binary_field_primary_filter_by_binary_pk_as_str(self):$/;" m class:FieldTest +test_binary_fields mongoengine/tests/fields/fields.py /^ def test_binary_fields(self):$/;" m class:FieldTest +test_binary_fields tests/fields/fields.py /^ def test_binary_fields(self):$/;" m class:FieldTest +test_binary_validation mongoengine/tests/fields/fields.py /^ def test_binary_validation(self):$/;" m class:FieldTest +test_binary_validation tests/fields/fields.py /^ def test_binary_validation(self):$/;" m class:FieldTest +test_bool_performance mongoengine/tests/queryset/queryset.py /^ def test_bool_performance(self):$/;" m class:QuerySetTest +test_bool_with_ordering mongoengine/tests/queryset/queryset.py /^ def test_bool_with_ordering(self):$/;" m class:QuerySetTest +test_bool_with_ordering_from_meta_dict mongoengine/tests/queryset/queryset.py /^ def test_bool_with_ordering_from_meta_dict(self):$/;" m class:QuerySetTest +test_boolean_validation mongoengine/tests/fields/fields.py /^ def test_boolean_validation(self):$/;" m class:FieldTest +test_boolean_validation tests/fields/fields.py /^ def test_boolean_validation(self):$/;" m class:FieldTest +test_build_index_spec_is_not_destructive mongoengine/tests/document/indexes.py /^ def test_build_index_spec_is_not_destructive(self):$/;" m class:IndexesTest +test_bulk mongoengine/tests/queryset/queryset.py /^ def test_bulk(self):$/;" m class:QuerySetTest +test_bulk_insert mongoengine/tests/queryset/queryset.py /^ def test_bulk_insert(self):$/;" m class:QuerySetTest +test_cache_not_cloned mongoengine/tests/queryset/queryset.py /^ def test_cache_not_cloned(self):$/;" m class:QuerySetTest +test_cached_queryset mongoengine/tests/queryset/queryset.py /^ def test_cached_queryset(self):$/;" m class:QuerySetTest +test_cached_reference_auto_sync mongoengine/tests/fields/fields.py /^ def test_cached_reference_auto_sync(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_auto_sync tests/fields/fields.py /^ def test_cached_reference_auto_sync(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_auto_sync_disabled mongoengine/tests/fields/fields.py /^ def test_cached_reference_auto_sync_disabled(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_auto_sync_disabled tests/fields/fields.py /^ def test_cached_reference_auto_sync_disabled(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_embedded_fields mongoengine/tests/fields/fields.py /^ def test_cached_reference_embedded_fields(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_embedded_fields tests/fields/fields.py /^ def test_cached_reference_embedded_fields(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_embedded_list_fields mongoengine/tests/fields/fields.py /^ def test_cached_reference_embedded_list_fields(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_embedded_list_fields tests/fields/fields.py /^ def test_cached_reference_embedded_list_fields(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_field_decimal mongoengine/tests/fields/fields.py /^ def test_cached_reference_field_decimal(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_field_decimal tests/fields/fields.py /^ def test_cached_reference_field_decimal(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_field_get_and_save mongoengine/tests/fields/fields.py /^ def test_cached_reference_field_get_and_save(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_field_get_and_save tests/fields/fields.py /^ def test_cached_reference_field_get_and_save(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_field_push_with_fields mongoengine/tests/fields/fields.py /^ def test_cached_reference_field_push_with_fields(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_field_push_with_fields tests/fields/fields.py /^ def test_cached_reference_field_push_with_fields(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_field_reference mongoengine/tests/fields/fields.py /^ def test_cached_reference_field_reference(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_field_reference tests/fields/fields.py /^ def test_cached_reference_field_reference(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_field_update_all mongoengine/tests/fields/fields.py /^ def test_cached_reference_field_update_all(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_field_update_all tests/fields/fields.py /^ def test_cached_reference_field_update_all(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_fields mongoengine/tests/fields/fields.py /^ def test_cached_reference_fields(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_fields tests/fields/fields.py /^ def test_cached_reference_fields(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_fields_on_embedded_documents mongoengine/tests/fields/fields.py /^ def test_cached_reference_fields_on_embedded_documents(self):$/;" m class:CachedReferenceFieldTest +test_cached_reference_fields_on_embedded_documents tests/fields/fields.py /^ def test_cached_reference_fields_on_embedded_documents(self):$/;" m class:CachedReferenceFieldTest +test_call_after_limits_set mongoengine/tests/queryset/queryset.py /^ def test_call_after_limits_set(self):$/;" m class:QuerySetTest +test_can_have_field_same_name_as_query_operator mongoengine/tests/queryset/queryset.py /^ def test_can_have_field_same_name_as_query_operator(self):$/;" m class:QuerySetTest +test_can_save_false_values mongoengine/tests/document/instance.py /^ def test_can_save_false_values(self):$/;" m class:InstanceTest +test_can_save_false_values_dynamic mongoengine/tests/document/instance.py /^ def test_can_save_false_values_dynamic(self):$/;" m class:InstanceTest +test_can_save_if_not_included mongoengine/tests/document/instance.py /^ def test_can_save_if_not_included(self):$/;" m class:InstanceTest +test_cannot_perform_joins_references mongoengine/tests/queryset/queryset.py /^ def test_cannot_perform_joins_references(self):$/;" m class:QuerySetTest +test_cant_turn_off_inheritance_on_subclass mongoengine/tests/document/inheritance.py /^ def test_cant_turn_off_inheritance_on_subclass(self):$/;" m class:InheritanceTest +test_capped_collection mongoengine/tests/document/instance.py /^ def test_capped_collection(self):$/;" m class:InstanceTest +test_capped_collection_default mongoengine/tests/document/instance.py /^ def test_capped_collection_default(self):$/;" m class:InstanceTest +test_capped_collection_no_max_size_problems mongoengine/tests/document/instance.py /^ def test_capped_collection_no_max_size_problems(self):$/;" m class:InstanceTest +test_chained_filter mongoengine/tests/fields/fields.py /^ def test_chained_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_chained_filter tests/fields/fields.py /^ def test_chained_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_chained_filter_exclude mongoengine/tests/fields/fields.py /^ def test_chained_filter_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_chained_filter_exclude tests/fields/fields.py /^ def test_chained_filter_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_chained_q_or_filtering mongoengine/tests/queryset/visitor.py /^ def test_chained_q_or_filtering(self):$/;" m class:QTest +test_chaining mongoengine/tests/queryset/queryset.py /^ def test_chaining(self):$/;" m class:QuerySetTest +test_chaining mongoengine/tests/queryset/transform.py /^ def test_chaining(self):$/;" m class:TransformTest +test_change_scope_of_variable mongoengine/tests/document/dynamic.py /^ def test_change_scope_of_variable(self):$/;" m class:DynamicTest +test_choices_allow_using_sets_as_choices mongoengine/tests/fields/fields.py /^ def test_choices_allow_using_sets_as_choices(self):$/;" m class:FieldTest +test_choices_allow_using_sets_as_choices tests/fields/fields.py /^ def test_choices_allow_using_sets_as_choices(self):$/;" m class:FieldTest +test_choices_get_field_display mongoengine/tests/fields/fields.py /^ def test_choices_get_field_display(self):$/;" m class:FieldTest +test_choices_get_field_display tests/fields/fields.py /^ def test_choices_get_field_display(self):$/;" m class:FieldTest +test_choices_validation_accept_possible_value mongoengine/tests/fields/fields.py /^ def test_choices_validation_accept_possible_value(self):$/;" m class:FieldTest +test_choices_validation_accept_possible_value tests/fields/fields.py /^ def test_choices_validation_accept_possible_value(self):$/;" m class:FieldTest +test_choices_validation_allow_no_value mongoengine/tests/fields/fields.py /^ def test_choices_validation_allow_no_value(self):$/;" m class:FieldTest +test_choices_validation_allow_no_value tests/fields/fields.py /^ def test_choices_validation_allow_no_value(self):$/;" m class:FieldTest +test_choices_validation_documents mongoengine/tests/fields/fields.py /^ def test_choices_validation_documents(self):$/;" m class:FieldTest +test_choices_validation_documents tests/fields/fields.py /^ def test_choices_validation_documents(self):$/;" m class:FieldTest +test_choices_validation_documents_inheritance mongoengine/tests/fields/fields.py /^ def test_choices_validation_documents_inheritance(self):$/;" m class:FieldTest +test_choices_validation_documents_inheritance tests/fields/fields.py /^ def test_choices_validation_documents_inheritance(self):$/;" m class:FieldTest +test_choices_validation_documents_invalid mongoengine/tests/fields/fields.py /^ def test_choices_validation_documents_invalid(self):$/;" m class:FieldTest +test_choices_validation_documents_invalid tests/fields/fields.py /^ def test_choices_validation_documents_invalid(self):$/;" m class:FieldTest +test_choices_validation_reject_unknown_value mongoengine/tests/fields/fields.py /^ def test_choices_validation_reject_unknown_value(self):$/;" m class:FieldTest +test_choices_validation_reject_unknown_value tests/fields/fields.py /^ def test_choices_validation_reject_unknown_value(self):$/;" m class:FieldTest +test_circular_reference mongoengine/tests/test_dereference.py /^ def test_circular_reference(self):$/;" m class:FieldTest +test_circular_reference_deltas mongoengine/tests/document/delta.py /^ def test_circular_reference_deltas(self):$/;" m class:DeltaTest +test_circular_reference_deltas_2 mongoengine/tests/document/delta.py /^ def test_circular_reference_deltas_2(self):$/;" m class:DeltaTest +test_circular_reference_on_self mongoengine/tests/test_dereference.py /^ def test_circular_reference_on_self(self):$/;" m class:FieldTest +test_circular_tree_reference mongoengine/tests/test_dereference.py /^ def test_circular_tree_reference(self):$/;" m class:FieldTest +test_clear_ordering mongoengine/tests/queryset/queryset.py /^ def test_clear_ordering(self):$/;" m class:QuerySetTest +test_clone mongoengine/tests/queryset/queryset.py /^ def test_clone(self):$/;" m class:QuerySetTest +test_cls_field mongoengine/tests/fields/fields.py /^ def test_cls_field(self):$/;" m class:FieldTest +test_cls_field tests/fields/fields.py /^ def test_cls_field(self):$/;" m class:FieldTest +test_cls_query_in_subclassed_docs mongoengine/tests/queryset/queryset.py /^ def test_cls_query_in_subclassed_docs(self):$/;" m class:QuerySetTest +test_collection_name_and_primary mongoengine/tests/document/class_methods.py /^ def test_collection_name_and_primary(self):$/;" m class:ClassMethodsTest +test_collection_naming mongoengine/tests/document/class_methods.py /^ def test_collection_naming(self):$/;" m class:ClassMethodsTest +test_comment mongoengine/tests/queryset/queryset.py /^ def test_comment(self):$/;" m class:QuerySetTest +test_compare_indexes mongoengine/tests/document/class_methods.py /^ def test_compare_indexes(self):$/;" m class:ClassMethodsTest +test_compare_indexes_inheritance mongoengine/tests/document/class_methods.py /^ def test_compare_indexes_inheritance(self):$/;" m class:ClassMethodsTest +test_compare_indexes_multiple_subclasses mongoengine/tests/document/class_methods.py /^ def test_compare_indexes_multiple_subclasses(self):$/;" m class:ClassMethodsTest +test_complex_data_lookups mongoengine/tests/document/dynamic.py /^ def test_complex_data_lookups(self):$/;" m class:DynamicTest +test_complex_dynamic_document_queries mongoengine/tests/document/dynamic.py /^ def test_complex_dynamic_document_queries(self):$/;" m class:DynamicTest +test_complex_embedded_document_validation mongoengine/tests/document/dynamic.py /^ def test_complex_embedded_document_validation(self):$/;" m class:DynamicTest +test_complex_embedded_documents mongoengine/tests/document/dynamic.py /^ def test_complex_embedded_documents(self):$/;" m class:DynamicTest +test_complex_field_filefield mongoengine/tests/fields/file_tests.py /^ def test_complex_field_filefield(self):$/;" m class:FileTest +test_complex_field_required mongoengine/tests/fields/fields.py /^ def test_complex_field_required(self):$/;" m class:FieldTest +test_complex_field_required tests/fields/fields.py /^ def test_complex_field_required(self):$/;" m class:FieldTest +test_complex_field_same_value_not_changed mongoengine/tests/fields/fields.py /^ def test_complex_field_same_value_not_changed(self):$/;" m class:FieldTest +test_complex_field_same_value_not_changed tests/fields/fields.py /^ def test_complex_field_same_value_not_changed(self):$/;" m class:FieldTest +test_complex_mapfield mongoengine/tests/fields/fields.py /^ def test_complex_mapfield(self):$/;" m class:FieldTest +test_complex_mapfield tests/fields/fields.py /^ def test_complex_mapfield(self):$/;" m class:FieldTest +test_complex_nesting_document_and_embedded_document mongoengine/tests/document/instance.py /^ def test_complex_nesting_document_and_embedded_document(self):$/;" m class:InstanceTest +test_complexdatetime_storage mongoengine/tests/fields/fields.py /^ def test_complexdatetime_storage(self):$/;" m class:FieldTest +test_complexdatetime_storage tests/fields/fields.py /^ def test_complexdatetime_storage(self):$/;" m class:FieldTest +test_complexdatetime_usage mongoengine/tests/fields/fields.py /^ def test_complexdatetime_usage(self):$/;" m class:FieldTest +test_complexdatetime_usage tests/fields/fields.py /^ def test_complexdatetime_usage(self):$/;" m class:FieldTest +test_compound_index_underscore_cls_not_overwritten mongoengine/tests/document/indexes.py /^ def test_compound_index_underscore_cls_not_overwritten(self):$/;" m class:IndexesTest +test_compound_key_dictfield mongoengine/tests/document/indexes.py /^ def test_compound_key_dictfield(self):$/;" m class:IndexesTest +test_compound_key_embedded mongoengine/tests/document/indexes.py /^ def test_compound_key_embedded(self):$/;" m class:IndexesTest +test_confirm_order_by_reference_wont_work mongoengine/tests/queryset/queryset.py /^ def test_confirm_order_by_reference_wont_work(self):$/;" m class:QuerySetTest +test_connect mongoengine/tests/test_connection.py /^ def test_connect(self):$/;" m class:ConnectionTest +test_connect_in_mocking mongoengine/tests/test_connection.py /^ def test_connect_in_mocking(self):$/;" m class:ConnectionTest +test_connect_uri mongoengine/tests/test_connection.py /^ def test_connect_uri(self):$/;" m class:ConnectionTest +test_connect_uri_default_db mongoengine/tests/test_connection.py /^ def test_connect_uri_default_db(self):$/;" m class:ConnectionTest +test_connect_uri_with_authsource mongoengine/tests/test_connection.py /^ def test_connect_uri_with_authsource(self):$/;" m class:ConnectionTest +test_connect_uri_without_db mongoengine/tests/test_connection.py /^ def test_connect_uri_without_db(self):$/;" m class:ConnectionTest +test_connect_with_host_list mongoengine/tests/test_connection.py /^ def test_connect_with_host_list(self):$/;" m class:ConnectionTest +test_connect_with_replicaset_via_kwargs mongoengine/tests/test_connection.py /^ def test_connect_with_replicaset_via_kwargs(self):$/;" m class:ConnectionTest +test_connect_with_replicaset_via_uri mongoengine/tests/test_connection.py /^ def test_connect_with_replicaset_via_uri(self):$/;" m class:ConnectionTest +test_connection_kwargs mongoengine/tests/test_connection.py /^ def test_connection_kwargs(self):$/;" m class:ConnectionTest +test_connection_pool_via_kwarg mongoengine/tests/test_connection.py /^ def test_connection_pool_via_kwarg(self):$/;" m class:ConnectionTest +test_connection_pool_via_uri mongoengine/tests/test_connection.py /^ def test_connection_pool_via_uri(self):$/;" m class:ConnectionTest +test_copyable mongoengine/tests/fields/file_tests.py /^ def test_copyable(self):$/;" m class:FileTest +test_count mongoengine/tests/fields/fields.py /^ def test_count(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_count tests/fields/fields.py /^ def test_count(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_count_and_none mongoengine/tests/queryset/queryset.py /^ def test_count_and_none(self):$/;" m class:QuerySetTest +test_count_limit_and_skip mongoengine/tests/queryset/queryset.py /^ def test_count_limit_and_skip(self):$/;" m class:QuerySetTest +test_count_list_embedded mongoengine/tests/queryset/queryset.py /^ def test_count_list_embedded(self):$/;" m class:QuerySetTest +test_covered_index mongoengine/tests/document/indexes.py /^ def test_covered_index(self):$/;" m class:IndexesTest +test_create mongoengine/tests/fields/fields.py /^ def test_create(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_create tests/fields/fields.py /^ def test_create(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_create_geohaystack_index mongoengine/tests/document/indexes.py /^ def test_create_geohaystack_index(self):$/;" m class:IndexesTest +test_creation mongoengine/tests/document/instance.py /^ def test_creation(self):$/;" m class:InstanceTest +test_cursor_args mongoengine/tests/queryset/queryset.py /^ def test_cursor_args(self):$/;" m class:QuerySetTest +test_cursor_in_an_if_stmt mongoengine/tests/queryset/queryset.py /^ def test_cursor_in_an_if_stmt(self):$/;" m class:QuerySetTest +test_custom_collection_name_operations mongoengine/tests/document/class_methods.py /^ def test_custom_collection_name_operations(self):$/;" m class:ClassMethodsTest +test_custom_data mongoengine/tests/fields/fields.py /^ def test_custom_data(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_custom_data tests/fields/fields.py /^ def test_custom_data(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_custom_id_field mongoengine/tests/document/instance.py /^ def test_custom_id_field(self):$/;" m class:InstanceTest +test_custom_manager mongoengine/tests/queryset/queryset.py /^ def test_custom_manager(self):$/;" m class:QuerySetTest +test_custom_manager_overriding_objects_works mongoengine/tests/queryset/queryset.py /^ def test_custom_manager_overriding_objects_works(self):$/;" m class:QuerySetTest +test_custom_querysets mongoengine/tests/queryset/queryset.py /^ def test_custom_querysets(self):$/;" m class:QuerySetTest +test_custom_querysets_inherited mongoengine/tests/queryset/queryset.py /^ def test_custom_querysets_inherited(self):$/;" m class:QuerySetTest +test_custom_querysets_inherited_direct mongoengine/tests/queryset/queryset.py /^ def test_custom_querysets_inherited_direct(self):$/;" m class:QuerySetTest +test_custom_querysets_managers_directly mongoengine/tests/queryset/queryset.py /^ def test_custom_querysets_managers_directly(self):$/;" m class:QuerySetTest +test_custom_querysets_set_manager_directly mongoengine/tests/queryset/queryset.py /^ def test_custom_querysets_set_manager_directly(self):$/;" m class:QuerySetTest +test_data_contains_id_field mongoengine/tests/document/instance.py /^ def test_data_contains_id_field(self):$/;" m class:InstanceTest +test_datetime mongoengine/tests/fields/fields.py /^ def test_datetime(self):$/;" m class:FieldTest +test_datetime mongoengine/tests/test_connection.py /^ def test_datetime(self):$/;" m class:ConnectionTest +test_datetime tests/fields/fields.py /^ def test_datetime(self):$/;" m class:FieldTest +test_datetime_from_empty_string mongoengine/tests/fields/fields.py /^ def test_datetime_from_empty_string(self):$/;" m class:FieldTest +test_datetime_from_empty_string tests/fields/fields.py /^ def test_datetime_from_empty_string(self):$/;" m class:FieldTest +test_datetime_from_whitespace_string mongoengine/tests/fields/fields.py /^ def test_datetime_from_whitespace_string(self):$/;" m class:FieldTest +test_datetime_from_whitespace_string tests/fields/fields.py /^ def test_datetime_from_whitespace_string(self):$/;" m class:FieldTest +test_datetime_tz_aware_mark_as_changed mongoengine/tests/fields/fields.py /^ def test_datetime_tz_aware_mark_as_changed(self):$/;" m class:FieldTest +test_datetime_tz_aware_mark_as_changed tests/fields/fields.py /^ def test_datetime_tz_aware_mark_as_changed(self):$/;" m class:FieldTest +test_datetime_usage mongoengine/tests/fields/fields.py /^ def test_datetime_usage(self):$/;" m class:FieldTest +test_datetime_usage tests/fields/fields.py /^ def test_datetime_usage(self):$/;" m class:FieldTest +test_datetime_validation mongoengine/tests/fields/fields.py /^ def test_datetime_validation(self):$/;" m class:FieldTest +test_datetime_validation tests/fields/fields.py /^ def test_datetime_validation(self):$/;" m class:FieldTest +test_db_alias_overrides mongoengine/tests/document/instance.py /^ def test_db_alias_overrides(self):$/;" m class:InstanceTest +test_db_alias_propagates mongoengine/tests/document/instance.py /^ def test_db_alias_propagates(self):$/;" m class:InstanceTest +test_db_alias_tests mongoengine/tests/document/instance.py /^ def test_db_alias_tests(self):$/;" m class:InstanceTest +test_db_embedded_doc_field_load mongoengine/tests/document/instance.py /^ def test_db_embedded_doc_field_load(self):$/;" m class:InstanceTest +test_db_field_load mongoengine/tests/document/instance.py /^ def test_db_field_load(self):$/;" m class:InstanceTest +test_db_field_validation mongoengine/tests/fields/fields.py /^ def test_db_field_validation(self):$/;" m class:FieldTest +test_db_field_validation tests/fields/fields.py /^ def test_db_field_validation(self):$/;" m class:FieldTest +test_db_ref_usage mongoengine/tests/document/instance.py /^ def test_db_ref_usage(self):$/;" m class:InstanceTest +test_dbref_equality mongoengine/tests/document/instance.py /^ def test_dbref_equality(self):$/;" m class:InstanceTest +test_dbref_reference_fields mongoengine/tests/fields/fields.py /^ def test_dbref_reference_fields(self):$/;" m class:FieldTest +test_dbref_reference_fields tests/fields/fields.py /^ def test_dbref_reference_fields(self):$/;" m class:FieldTest +test_dbref_to_mongo mongoengine/tests/fields/fields.py /^ def test_dbref_to_mongo(self):$/;" m class:FieldTest +test_dbref_to_mongo tests/fields/fields.py /^ def test_dbref_to_mongo(self):$/;" m class:FieldTest +test_decimal_comparison mongoengine/tests/fields/fields.py /^ def test_decimal_comparison(self):$/;" m class:FieldTest +test_decimal_comparison tests/fields/fields.py /^ def test_decimal_comparison(self):$/;" m class:FieldTest +test_decimal_storage mongoengine/tests/fields/fields.py /^ def test_decimal_storage(self):$/;" m class:FieldTest +test_decimal_storage tests/fields/fields.py /^ def test_decimal_storage(self):$/;" m class:FieldTest +test_decimal_validation mongoengine/tests/fields/fields.py /^ def test_decimal_validation(self):$/;" m class:FieldTest +test_decimal_validation tests/fields/fields.py /^ def test_decimal_validation(self):$/;" m class:FieldTest +test_default_values mongoengine/tests/document/instance.py /^ def test_default_values(self):$/;" m class:InstanceTest +test_default_values_nothing_set mongoengine/tests/fields/fields.py /^ def test_default_values_nothing_set(self):$/;" m class:FieldTest +test_default_values_nothing_set tests/fields/fields.py /^ def test_default_values_nothing_set(self):$/;" m class:FieldTest +test_default_values_set_to_None mongoengine/tests/fields/fields.py /^ def test_default_values_set_to_None(self):$/;" m class:FieldTest +test_default_values_set_to_None tests/fields/fields.py /^ def test_default_values_set_to_None(self):$/;" m class:FieldTest +test_default_values_when_deleting_value mongoengine/tests/fields/fields.py /^ def test_default_values_when_deleting_value(self):$/;" m class:FieldTest +test_default_values_when_deleting_value tests/fields/fields.py /^ def test_default_values_when_deleting_value(self):$/;" m class:FieldTest +test_default_values_when_setting_to_None mongoengine/tests/fields/fields.py /^ def test_default_values_when_setting_to_None(self):$/;" m class:FieldTest +test_default_values_when_setting_to_None tests/fields/fields.py /^ def test_default_values_when_setting_to_None(self):$/;" m class:FieldTest +test_definition mongoengine/tests/document/class_methods.py /^ def test_definition(self):$/;" m class:ClassMethodsTest +test_del_slice_marks_field_as_changed mongoengine/tests/fields/fields.py /^ def test_del_slice_marks_field_as_changed(self):$/;" m class:FieldTest +test_del_slice_marks_field_as_changed tests/fields/fields.py /^ def test_del_slice_marks_field_as_changed(self):$/;" m class:FieldTest +test_delete mongoengine/tests/document/instance.py /^ def test_delete(self):$/;" m class:InstanceTest +test_delete mongoengine/tests/fields/fields.py /^ def test_delete(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_delete mongoengine/tests/queryset/queryset.py /^ def test_delete(self):$/;" m class:QuerySetTest +test_delete tests/fields/fields.py /^ def test_delete(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_delete_count mongoengine/tests/queryset/queryset.py /^ def test_delete_count(self):$/;" m class:QuerySetTest +test_delete_dynamic_field mongoengine/tests/document/dynamic.py /^ def test_delete_dynamic_field(self):$/;" m class:DynamicTest +test_delete_with_limit_handles_delete_rules mongoengine/tests/queryset/queryset.py /^ def test_delete_with_limit_handles_delete_rules(self):$/;" m class:QuerySetTest +test_delete_with_limits mongoengine/tests/queryset/queryset.py /^ def test_delete_with_limits(self):$/;" m class:QuerySetTest +test_delta mongoengine/tests/document/delta.py /^ def test_delta(self):$/;" m class:DeltaTest +test_delta_db_field mongoengine/tests/document/delta.py /^ def test_delta_db_field(self):$/;" m class:DeltaTest +test_delta_for_dynamic_documents mongoengine/tests/document/delta.py /^ def test_delta_for_dynamic_documents(self):$/;" m class:DeltaTest +test_delta_for_nested_map_fields mongoengine/tests/document/delta.py /^ def test_delta_for_nested_map_fields(self):$/;" m class:DeltaTest +test_delta_recursive mongoengine/tests/document/delta.py /^ def test_delta_recursive(self):$/;" m class:DeltaTest +test_delta_recursive_db_field mongoengine/tests/document/delta.py /^ def test_delta_recursive_db_field(self):$/;" m class:DeltaTest +test_delta_with_dbref_false mongoengine/tests/document/delta.py /^ def test_delta_with_dbref_false(self):$/;" m class:DeltaTest +test_delta_with_dbref_true mongoengine/tests/document/delta.py /^ def test_delta_with_dbref_true(self):$/;" m class:DeltaTest +test_dereferencing_embedded_listfield_referencefield mongoengine/tests/test_dereference.py /^ def test_dereferencing_embedded_listfield_referencefield(self):$/;" m class:FieldTest +test_dict_field mongoengine/tests/fields/fields.py /^ def test_dict_field(self):$/;" m class:FieldTest +test_dict_field mongoengine/tests/test_dereference.py /^ def test_dict_field(self):$/;" m class:FieldTest +test_dict_field tests/fields/fields.py /^ def test_dict_field(self):$/;" m class:FieldTest +test_dict_field_no_field_inheritance mongoengine/tests/test_dereference.py /^ def test_dict_field_no_field_inheritance(self):$/;" m class:FieldTest +test_dict_in_dbref_instance mongoengine/tests/test_dereference.py /^ def test_dict_in_dbref_instance(self):$/;" m class:FieldTest +test_dict_with_custom_baseclass mongoengine/tests/queryset/queryset.py /^ def test_dict_with_custom_baseclass(self):$/;" m class:QuerySetTest +test_dictfield_complex mongoengine/tests/fields/fields.py /^ def test_dictfield_complex(self):$/;" m class:FieldTest +test_dictfield_complex tests/fields/fields.py /^ def test_dictfield_complex(self):$/;" m class:FieldTest +test_dictfield_dump_document mongoengine/tests/fields/fields.py /^ def test_dictfield_dump_document(self):$/;" m class:FieldTest +test_dictfield_dump_document tests/fields/fields.py /^ def test_dictfield_dump_document(self):$/;" m class:FieldTest +test_dictfield_key_looks_like_a_digit mongoengine/tests/queryset/queryset.py /^ def test_dictfield_key_looks_like_a_digit(self):$/;" m class:QuerySetTest +test_dictfield_strict mongoengine/tests/fields/fields.py /^ def test_dictfield_strict(self):$/;" m class:FieldTest +test_dictfield_strict tests/fields/fields.py /^ def test_dictfield_strict(self):$/;" m class:FieldTest +test_dictfield_update mongoengine/tests/queryset/queryset.py /^ def test_dictfield_update(self):$/;" m class:QuerySetTest +test_dictionary_access mongoengine/tests/document/instance.py /^ def test_dictionary_access(self):$/;" m class:InstanceTest +test_dictionary_indexes mongoengine/tests/document/indexes.py /^ def test_dictionary_indexes(self):$/;" m class:IndexesTest +test_disable_index_creation mongoengine/tests/document/indexes.py /^ def test_disable_index_creation(self):$/;" m class:IndexesTest +test_disconnect mongoengine/tests/test_connection.py /^ def test_disconnect(self):$/;" m class:ConnectionTest +test_distinct mongoengine/tests/queryset/queryset.py /^ def test_distinct(self):$/;" m class:QuerySetTest +test_distinct_ListField_EmbeddedDocumentField mongoengine/tests/queryset/queryset.py /^ def test_distinct_ListField_EmbeddedDocumentField(self):$/;" m class:QuerySetTest +test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField mongoengine/tests/queryset/queryset.py /^ def test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField(self):$/;" m class:QuerySetTest +test_distinct_ListField_ReferenceField mongoengine/tests/queryset/queryset.py /^ def test_distinct_ListField_ReferenceField(self):$/;" m class:QuerySetTest +test_distinct_handles_db_field mongoengine/tests/queryset/queryset.py /^ def test_distinct_handles_db_field(self):$/;" m class:QuerySetTest +test_distinct_handles_references mongoengine/tests/queryset/queryset.py /^ def test_distinct_handles_references(self):$/;" m class:QuerySetTest +test_distinct_handles_references_to_alias mongoengine/tests/queryset/queryset.py /^ def test_distinct_handles_references_to_alias(self):$/;" m class:QuerySetTest +test_do_not_save_unchanged_references mongoengine/tests/document/instance.py /^ def test_do_not_save_unchanged_references(self):$/;" m class:InstanceTest +test_document_clean mongoengine/tests/document/instance.py /^ def test_document_clean(self):$/;" m class:InstanceTest +test_document_collection_syntax_warning mongoengine/tests/all_warnings/__init__.py /^ def test_document_collection_syntax_warning(self):$/;" m class:AllWarnings +test_document_embedded_clean mongoengine/tests/document/instance.py /^ def test_document_embedded_clean(self):$/;" m class:InstanceTest +test_document_hash mongoengine/tests/document/instance.py /^ def test_document_hash(self):$/;" m class:InstanceTest +test_document_inheritance mongoengine/tests/document/inheritance.py /^ def test_document_inheritance(self):$/;" m class:InheritanceTest +test_document_not_registered mongoengine/tests/document/instance.py /^ def test_document_not_registered(self):$/;" m class:InstanceTest +test_document_registry_regressions mongoengine/tests/document/instance.py /^ def test_document_registry_regressions(self):$/;" m class:InstanceTest +test_document_reload_no_inheritance mongoengine/tests/test_dereference.py /^ def test_document_reload_no_inheritance(self):$/;" m class:FieldTest +test_document_reload_reference_integrity mongoengine/tests/test_dereference.py /^ def test_document_reload_reference_integrity(self):$/;" m class:FieldTest +test_document_update mongoengine/tests/document/instance.py /^ def test_document_update(self):$/;" m class:InstanceTest +test_double_embedded_db_field mongoengine/tests/fields/fields.py /^ def test_double_embedded_db_field(self):$/;" m class:FieldTest +test_double_embedded_db_field tests/fields/fields.py /^ def test_double_embedded_db_field(self):$/;" m class:FieldTest +test_double_embedded_db_field_from_son mongoengine/tests/fields/fields.py /^ def test_double_embedded_db_field_from_son(self):$/;" m class:FieldTest +test_double_embedded_db_field_from_son tests/fields/fields.py /^ def test_double_embedded_db_field_from_son(self):$/;" m class:FieldTest +test_drop_abstract_document mongoengine/tests/fields/fields.py /^ def test_drop_abstract_document(self):$/;" m class:FieldTest +test_drop_abstract_document tests/fields/fields.py /^ def test_drop_abstract_document(self):$/;" m class:FieldTest +test_drop_collection mongoengine/tests/document/class_methods.py /^ def test_drop_collection(self):$/;" m class:ClassMethodsTest +test_duplicate_db_fields_raise_invalid_document_error mongoengine/tests/document/instance.py /^ def test_duplicate_db_fields_raise_invalid_document_error(self):$/;" m class:InstanceTest +test_dynamic_and_embedded mongoengine/tests/document/dynamic.py /^ def test_dynamic_and_embedded(self):$/;" m class:DynamicTest +test_dynamic_and_embedded_dict_access mongoengine/tests/document/dynamic.py /^ def test_dynamic_and_embedded_dict_access(self):$/;" m class:DynamicTest +test_dynamic_declarations mongoengine/tests/document/inheritance.py /^ def test_dynamic_declarations(self):$/;" m class:InheritanceTest +test_dynamic_delta mongoengine/tests/document/delta.py /^ def test_dynamic_delta(self):$/;" m class:DeltaTest +test_dynamic_document_pickle mongoengine/tests/document/instance.py /^ def test_dynamic_document_pickle(self):$/;" m class:InstanceTest +test_dynamic_document_queries mongoengine/tests/document/dynamic.py /^ def test_dynamic_document_queries(self):$/;" m class:DynamicTest +test_dynamic_embedded_works_with_only mongoengine/tests/document/dynamic.py /^ def test_dynamic_embedded_works_with_only(self):$/;" m class:DynamicTest +test_dynamic_fields_class mongoengine/tests/fields/fields.py /^ def test_dynamic_fields_class(self):$/;" m class:FieldTest +test_dynamic_fields_class tests/fields/fields.py /^ def test_dynamic_fields_class(self):$/;" m class:FieldTest +test_dynamic_fields_embedded_class mongoengine/tests/fields/fields.py /^ def test_dynamic_fields_embedded_class(self):$/;" m class:FieldTest +test_dynamic_fields_embedded_class tests/fields/fields.py /^ def test_dynamic_fields_embedded_class(self):$/;" m class:FieldTest +test_dynamicfield_dump_document mongoengine/tests/fields/fields.py /^ def test_dynamicfield_dump_document(self):$/;" m class:FieldTest +test_dynamicfield_dump_document tests/fields/fields.py /^ def test_dynamicfield_dump_document(self):$/;" m class:FieldTest +test_editting_embedded_objects mongoengine/tests/queryset/queryset.py /^ def test_editting_embedded_objects(self):$/;" m class:QuerySetTest +test_elem_match mongoengine/tests/queryset/queryset.py /^ def test_elem_match(self):$/;" m class:QuerySetTest +test_email_field mongoengine/tests/fields/fields.py /^ def test_email_field(self):$/;" m class:FieldTest +test_email_field tests/fields/fields.py /^ def test_email_field(self):$/;" m class:FieldTest +test_email_field_domain_whitelist mongoengine/tests/fields/fields.py /^ def test_email_field_domain_whitelist(self):$/;" m class:FieldTest +test_email_field_domain_whitelist tests/fields/fields.py /^ def test_email_field_domain_whitelist(self):$/;" m class:FieldTest +test_email_field_honors_regex mongoengine/tests/fields/fields.py /^ def test_email_field_honors_regex(self):$/;" m class:FieldTest +test_email_field_honors_regex tests/fields/fields.py /^ def test_email_field_honors_regex(self):$/;" m class:FieldTest +test_email_field_ip_domain mongoengine/tests/fields/fields.py /^ def test_email_field_ip_domain(self):$/;" m class:FieldTest +test_email_field_ip_domain tests/fields/fields.py /^ def test_email_field_ip_domain(self):$/;" m class:FieldTest +test_email_field_unicode_user mongoengine/tests/fields/fields.py /^ def test_email_field_unicode_user(self):$/;" m class:FieldTest +test_email_field_unicode_user tests/fields/fields.py /^ def test_email_field_unicode_user(self):$/;" m class:FieldTest +test_embedded_array_average mongoengine/tests/queryset/queryset.py /^ def test_embedded_array_average(self):$/;" m class:QuerySetTest +test_embedded_array_sum mongoengine/tests/queryset/queryset.py /^ def test_embedded_array_sum(self):$/;" m class:QuerySetTest +test_embedded_average mongoengine/tests/queryset/queryset.py /^ def test_embedded_average(self):$/;" m class:QuerySetTest +test_embedded_db_field mongoengine/tests/fields/fields.py /^ def test_embedded_db_field(self):$/;" m class:FieldTest +test_embedded_db_field tests/fields/fields.py /^ def test_embedded_db_field(self):$/;" m class:FieldTest +test_embedded_db_field_validate mongoengine/tests/document/validation.py /^ def test_embedded_db_field_validate(self):$/;" m class:ValidatorErrorTest +test_embedded_document mongoengine/tests/document/instance.py /^ def test_embedded_document(self):$/;" m class:InstanceTest +test_embedded_document_complex_instance mongoengine/tests/document/instance.py /^ def test_embedded_document_complex_instance(self):$/;" m class:InstanceTest +test_embedded_document_complex_instance_no_use_db_field mongoengine/tests/document/instance.py /^ def test_embedded_document_complex_instance_no_use_db_field(self):$/;" m class:InstanceTest +test_embedded_document_equality mongoengine/tests/document/instance.py /^ def test_embedded_document_equality(self):$/;" m class:InstanceTest +test_embedded_document_index mongoengine/tests/document/indexes.py /^ def test_embedded_document_index(self):$/;" m class:IndexesTest +test_embedded_document_index_meta mongoengine/tests/document/indexes.py /^ def test_embedded_document_index_meta(self):$/;" m class:IndexesTest +test_embedded_document_inheritance mongoengine/tests/fields/fields.py /^ def test_embedded_document_inheritance(self):$/;" m class:FieldTest +test_embedded_document_inheritance tests/fields/fields.py /^ def test_embedded_document_inheritance(self):$/;" m class:FieldTest +test_embedded_document_inheritance_with_list mongoengine/tests/fields/fields.py /^ def test_embedded_document_inheritance_with_list(self):$/;" m class:FieldTest +test_embedded_document_inheritance_with_list tests/fields/fields.py /^ def test_embedded_document_inheritance_with_list(self):$/;" m class:FieldTest +test_embedded_document_instance mongoengine/tests/document/instance.py /^ def test_embedded_document_instance(self):$/;" m class:InstanceTest +test_embedded_document_to_mongo mongoengine/tests/document/instance.py /^ def test_embedded_document_to_mongo(self):$/;" m class:InstanceTest +test_embedded_document_to_mongo_id mongoengine/tests/document/instance.py /^ def test_embedded_document_to_mongo_id(self):$/;" m class:InstanceTest +test_embedded_document_validation mongoengine/tests/document/validation.py /^ def test_embedded_document_validation(self):$/;" m class:ValidatorErrorTest +test_embedded_document_validation mongoengine/tests/fields/fields.py /^ def test_embedded_document_validation(self):$/;" m class:FieldTest +test_embedded_document_validation tests/fields/fields.py /^ def test_embedded_document_validation(self):$/;" m class:FieldTest +test_embedded_dynamic_document mongoengine/tests/document/dynamic.py /^ def test_embedded_dynamic_document(self):$/;" m class:DynamicTest +test_embedded_mapfield_db_field mongoengine/tests/fields/fields.py /^ def test_embedded_mapfield_db_field(self):$/;" m class:FieldTest +test_embedded_mapfield_db_field tests/fields/fields.py /^ def test_embedded_mapfield_db_field(self):$/;" m class:FieldTest +test_embedded_sequence_field mongoengine/tests/fields/fields.py /^ def test_embedded_sequence_field(self):$/;" m class:FieldTest +test_embedded_sequence_field tests/fields/fields.py /^ def test_embedded_sequence_field(self):$/;" m class:FieldTest +test_embedded_sum mongoengine/tests/queryset/queryset.py /^ def test_embedded_sum(self):$/;" m class:QuerySetTest +test_embedded_update mongoengine/tests/document/instance.py /^ def test_embedded_update(self):$/;" m class:InstanceTest +test_embedded_update_after_save mongoengine/tests/document/instance.py /^ def test_embedded_update_after_save(self):$/;" m class:InstanceTest +test_embedded_update_db_field mongoengine/tests/document/instance.py /^ def test_embedded_update_db_field(self):$/;" m class:InstanceTest +test_embedded_weakref mongoengine/tests/document/validation.py /^ def test_embedded_weakref(self):$/;" m class:ValidatorErrorTest +test_empty mongoengine/tests/queryset/field_list.py /^ def test_empty(self):$/;" m class:QueryFieldListTest +test_empty_list_embedded_documents_with_unique_field mongoengine/tests/fields/fields.py /^ def test_empty_list_embedded_documents_with_unique_field(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_empty_list_embedded_documents_with_unique_field tests/fields/fields.py /^ def test_empty_list_embedded_documents_with_unique_field(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_empty_q mongoengine/tests/queryset/visitor.py /^ def test_empty_q(self):$/;" m class:QTest +test_ensure_index mongoengine/tests/queryset/queryset.py /^ def test_ensure_index(self):$/;" m class:QuerySetTest +test_ensure_unique_default_instances mongoengine/tests/fields/fields.py /^ def test_ensure_unique_default_instances(self):$/;" m class:FieldTest +test_ensure_unique_default_instances tests/fields/fields.py /^ def test_ensure_unique_default_instances(self):$/;" m class:FieldTest +test_eq mongoengine/tests/test_datastructures.py /^ def test_eq(self):$/;" m class:TestStrictDict +test_exclude mongoengine/tests/queryset/field_list.py /^ def test_exclude(self):$/;" m class:OnlyExcludeAllTest +test_exclude_exclude mongoengine/tests/queryset/field_list.py /^ def test_exclude_exclude(self):$/;" m class:QueryFieldListTest +test_exclude_from_subclasses_docs mongoengine/tests/queryset/field_list.py /^ def test_exclude_from_subclasses_docs(self):$/;" m class:OnlyExcludeAllTest +test_exclude_include mongoengine/tests/queryset/field_list.py /^ def test_exclude_include(self):$/;" m class:QueryFieldListTest +test_exclude_only_combining mongoengine/tests/queryset/field_list.py /^ def test_exclude_only_combining(self):$/;" m class:OnlyExcludeAllTest +test_exec_js_field_sub mongoengine/tests/queryset/queryset.py /^ def test_exec_js_field_sub(self):$/;" m class:QuerySetTest +test_exec_js_query mongoengine/tests/queryset/queryset.py /^ def test_exec_js_query(self):$/;" m class:QuerySetTest +test_explicit_geo2d_index mongoengine/tests/document/indexes.py /^ def test_explicit_geo2d_index(self):$/;" m class:IndexesTest +test_explicit_geo2d_index_embedded mongoengine/tests/document/indexes.py /^ def test_explicit_geo2d_index_embedded(self):$/;" m class:IndexesTest +test_explicit_geohaystack_index mongoengine/tests/document/indexes.py /^ def test_explicit_geohaystack_index(self):$/;" m class:IndexesTest +test_explicit_geosphere_index mongoengine/tests/document/indexes.py /^ def test_explicit_geosphere_index(self):$/;" m class:IndexesTest +test_external_subclasses mongoengine/tests/document/inheritance.py /^ def test_external_subclasses(self):$/;" m class:InheritanceTest +test_external_superclasses mongoengine/tests/document/inheritance.py /^ def test_external_superclasses(self):$/;" m class:InheritanceTest +test_falsey_pk mongoengine/tests/document/instance.py /^ def test_falsey_pk(self):$/;" m class:InstanceTest +test_field mongoengine/tests/queryset/queryset.py /^ test_field = StringField()$/;" v class:QuerySetTest.test_cursor_in_an_if_stmt.Test +test_fields_rewrite mongoengine/tests/document/validation.py /^ def test_fields_rewrite(self):$/;" m class:ValidatorErrorTest +test_file_boolean mongoengine/tests/fields/file_tests.py /^ def test_file_boolean(self):$/;" m class:FileTest +test_file_cmp mongoengine/tests/fields/file_tests.py /^ def test_file_cmp(self):$/;" m class:FileTest +test_file_disk_space mongoengine/tests/fields/file_tests.py /^ def test_file_disk_space(self):$/;" m class:FileTest +test_file_field_no_default mongoengine/tests/fields/file_tests.py /^ def test_file_field_no_default(self):$/;" m class:FileTest +test_file_field_optional mongoengine/tests/fields/file_tests.py /^ def test_file_field_optional(self):$/;" m class:FileTest +test_file_fields mongoengine/tests/fields/file_tests.py /^ def test_file_fields(self):$/;" m class:FileTest +test_file_fields_set mongoengine/tests/fields/file_tests.py /^ def test_file_fields_set(self):$/;" m class:FileTest +test_file_fields_stream mongoengine/tests/fields/file_tests.py /^ def test_file_fields_stream(self):$/;" m class:FileTest +test_file_fields_stream_after_none mongoengine/tests/fields/file_tests.py /^ def test_file_fields_stream_after_none(self):$/;" m class:FileTest +test_file_multidb mongoengine/tests/fields/file_tests.py /^ def test_file_multidb(self):$/;" m class:FileTest +test_file_reassigning mongoengine/tests/fields/file_tests.py /^ def test_file_reassigning(self):$/;" m class:FileTest +test_file_saving mongoengine/tests/fields/file_tests.py /^ def test_file_saving(self):$/;" m class:FileTest +test_file_uniqueness mongoengine/tests/fields/file_tests.py /^ def test_file_uniqueness(self):$/;" m class:FileTest +test_filter_chaining mongoengine/tests/queryset/queryset.py /^ def test_filter_chaining(self):$/;" m class:QuerySetTest +test_filtered_count mongoengine/tests/fields/fields.py /^ def test_filtered_count(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_filtered_count tests/fields/fields.py /^ def test_filtered_count(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_filtered_create mongoengine/tests/fields/fields.py /^ def test_filtered_create(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_filtered_create tests/fields/fields.py /^ def test_filtered_create(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_filtered_delete mongoengine/tests/fields/fields.py /^ def test_filtered_delete(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_filtered_delete tests/fields/fields.py /^ def test_filtered_delete(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_find mongoengine/tests/queryset/queryset.py /^ def test_find(self):$/;" m class:QuerySetTest +test_find_and_modify_with_remove_not_existing mongoengine/tests/queryset/modify.py /^ def test_find_and_modify_with_remove_not_existing(self):$/;" m class:FindAndModifyTest +test_find_array_position mongoengine/tests/queryset/queryset.py /^ def test_find_array_position(self):$/;" m class:QuerySetTest +test_find_dict_item mongoengine/tests/queryset/queryset.py /^ def test_find_dict_item(self):$/;" m class:QuerySetTest +test_find_embedded mongoengine/tests/queryset/queryset.py /^ def test_find_embedded(self):$/;" m class:QuerySetTest +test_find_empty_embedded mongoengine/tests/queryset/queryset.py /^ def test_find_empty_embedded(self):$/;" m class:QuerySetTest +test_find_one mongoengine/tests/queryset/queryset.py /^ def test_find_one(self):$/;" m class:QuerySetTest +test_find_only_one mongoengine/tests/queryset/queryset.py /^ def test_find_only_one(self):$/;" m class:QuerySetTest +test_first mongoengine/tests/fields/fields.py /^ def test_first(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_first tests/fields/fields.py /^ def test_first(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_float_validation mongoengine/tests/fields/fields.py /^ def test_float_validation(self):$/;" m class:FieldTest +test_float_validation tests/fields/fields.py /^ def test_float_validation(self):$/;" m class:FieldTest +test_from_son mongoengine/tests/document/instance.py /^ def test_from_son(self):$/;" m class:InstanceTest +test_generic_embedded_document mongoengine/tests/fields/fields.py /^ def test_generic_embedded_document(self):$/;" m class:FieldTest +test_generic_embedded_document tests/fields/fields.py /^ def test_generic_embedded_document(self):$/;" m class:FieldTest +test_generic_embedded_document_choices mongoengine/tests/fields/fields.py /^ def test_generic_embedded_document_choices(self):$/;" m class:FieldTest +test_generic_embedded_document_choices tests/fields/fields.py /^ def test_generic_embedded_document_choices(self):$/;" m class:FieldTest +test_generic_lazy_reference_bad_set mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_bad_set(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_bad_set tests/fields/fields.py /^ def test_generic_lazy_reference_bad_set(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_choices mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_choices(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_choices tests/fields/fields.py /^ def test_generic_lazy_reference_choices(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_embedded mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_embedded(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_embedded tests/fields/fields.py /^ def test_generic_lazy_reference_embedded(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_not_set mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_not_set(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_not_set tests/fields/fields.py /^ def test_generic_lazy_reference_not_set(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_query_conversion mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_query_conversion(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_query_conversion tests/fields/fields.py /^ def test_generic_lazy_reference_query_conversion(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_set mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_set(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_set tests/fields/fields.py /^ def test_generic_lazy_reference_set(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_simple mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_simple(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_lazy_reference_simple tests/fields/fields.py /^ def test_generic_lazy_reference_simple(self):$/;" m class:GenericLazyReferenceFieldTest +test_generic_list_embedded_document_choices mongoengine/tests/fields/fields.py /^ def test_generic_list_embedded_document_choices(self):$/;" m class:FieldTest +test_generic_list_embedded_document_choices tests/fields/fields.py /^ def test_generic_list_embedded_document_choices(self):$/;" m class:FieldTest +test_generic_reference mongoengine/tests/fields/fields.py /^ def test_generic_reference(self):$/;" m class:FieldTest +test_generic_reference mongoengine/tests/test_dereference.py /^ def test_generic_reference(self):$/;" m class:FieldTest +test_generic_reference tests/fields/fields.py /^ def test_generic_reference(self):$/;" m class:FieldTest +test_generic_reference_choices mongoengine/tests/fields/fields.py /^ def test_generic_reference_choices(self):$/;" m class:FieldTest +test_generic_reference_choices tests/fields/fields.py /^ def test_generic_reference_choices(self):$/;" m class:FieldTest +test_generic_reference_choices_no_dereference mongoengine/tests/fields/fields.py /^ def test_generic_reference_choices_no_dereference(self):$/;" m class:FieldTest +test_generic_reference_choices_no_dereference tests/fields/fields.py /^ def test_generic_reference_choices_no_dereference(self):$/;" m class:FieldTest +test_generic_reference_document_not_registered mongoengine/tests/fields/fields.py /^ def test_generic_reference_document_not_registered(self):$/;" m class:FieldTest +test_generic_reference_document_not_registered tests/fields/fields.py /^ def test_generic_reference_document_not_registered(self):$/;" m class:FieldTest +test_generic_reference_field_with_only_and_as_pymongo mongoengine/tests/queryset/queryset.py /^ def test_generic_reference_field_with_only_and_as_pymongo(self):$/;" m class:QuerySetTest +test_generic_reference_filter_by_dbref mongoengine/tests/fields/fields.py /^ def test_generic_reference_filter_by_dbref(self):$/;" m class:FieldTest +test_generic_reference_filter_by_dbref tests/fields/fields.py /^ def test_generic_reference_filter_by_dbref(self):$/;" m class:FieldTest +test_generic_reference_filter_by_objectid mongoengine/tests/fields/fields.py /^ def test_generic_reference_filter_by_objectid(self):$/;" m class:FieldTest +test_generic_reference_filter_by_objectid tests/fields/fields.py /^ def test_generic_reference_filter_by_objectid(self):$/;" m class:FieldTest +test_generic_reference_is_none mongoengine/tests/fields/fields.py /^ def test_generic_reference_is_none(self):$/;" m class:FieldTest +test_generic_reference_is_none tests/fields/fields.py /^ def test_generic_reference_is_none(self):$/;" m class:FieldTest +test_generic_reference_list mongoengine/tests/fields/fields.py /^ def test_generic_reference_list(self):$/;" m class:FieldTest +test_generic_reference_list tests/fields/fields.py /^ def test_generic_reference_list(self):$/;" m class:FieldTest +test_generic_reference_list_choices mongoengine/tests/fields/fields.py /^ def test_generic_reference_list_choices(self):$/;" m class:FieldTest +test_generic_reference_list_choices tests/fields/fields.py /^ def test_generic_reference_list_choices(self):$/;" m class:FieldTest +test_generic_reference_list_item_modification mongoengine/tests/fields/fields.py /^ def test_generic_reference_list_item_modification(self):$/;" m class:FieldTest +test_generic_reference_list_item_modification tests/fields/fields.py /^ def test_generic_reference_list_item_modification(self):$/;" m class:FieldTest +test_generic_reference_map_field mongoengine/tests/test_dereference.py /^ def test_generic_reference_map_field(self):$/;" m class:FieldTest +test_generic_reference_save_doesnt_cause_extra_queries mongoengine/tests/test_dereference.py /^ def test_generic_reference_save_doesnt_cause_extra_queries(self):$/;" m class:FieldTest +test_generic_reference_string_choices mongoengine/tests/fields/fields.py /^ def test_generic_reference_string_choices(self):$/;" m class:FieldTest +test_generic_reference_string_choices tests/fields/fields.py /^ def test_generic_reference_string_choices(self):$/;" m class:FieldTest +test_geo_indexes_auto_index mongoengine/tests/fields/geo.py /^ def test_geo_indexes_auto_index(self):$/;" m class:GeoFieldTest +test_geo_indexes_recursion mongoengine/tests/fields/geo.py /^ def test_geo_indexes_recursion(self):$/;" m class:GeoFieldTest +test_geo_spatial_embedded mongoengine/tests/queryset/geo.py /^ def test_geo_spatial_embedded(self):$/;" m class:GeoQueriesTest +test_geojson_LineStringField mongoengine/tests/queryset/transform.py /^ def test_geojson_LineStringField(self):$/;" m class:TransformTest +test_geojson_PointField mongoengine/tests/queryset/transform.py /^ def test_geojson_PointField(self):$/;" m class:TransformTest +test_geojson_PolygonField mongoengine/tests/queryset/geo.py /^ def test_geojson_PolygonField(self):$/;" m class:GeoQueriesTest +test_geojson_PolygonField mongoengine/tests/queryset/transform.py /^ def test_geojson_PolygonField(self):$/;" m class:TransformTest +test_geopoint_embedded_indexes mongoengine/tests/fields/geo.py /^ def test_geopoint_embedded_indexes(self):$/;" m class:GeoFieldTest +test_geopoint_validation mongoengine/tests/fields/geo.py /^ def test_geopoint_validation(self):$/;" m class:GeoFieldTest +test_get mongoengine/tests/test_datastructures.py /^ def test_get(self):$/;" m class:TestStrictDict +test_get_changed_fields_query_count mongoengine/tests/queryset/queryset.py /^ def test_get_changed_fields_query_count(self):$/;" m class:QuerySetTest +test_get_collection mongoengine/tests/document/class_methods.py /^ def test_get_collection(self):$/;" m class:ClassMethodsTest +test_get_collection_name mongoengine/tests/document/class_methods.py /^ def test_get_collection_name(self):$/;" m class:ClassMethodsTest +test_get_db mongoengine/tests/document/class_methods.py /^ def test_get_db(self):$/;" m class:ClassMethodsTest +test_get_image_by_grid_id mongoengine/tests/fields/file_tests.py /^ def test_get_image_by_grid_id(self):$/;" m class:FileTest +test_handle_old_style_references mongoengine/tests/test_dereference.py /^ def test_handle_old_style_references(self):$/;" m class:FieldTest +test_hashed_indexes mongoengine/tests/document/indexes.py /^ def test_hashed_indexes(self):$/;" m class:IndexesTest +test_hint mongoengine/tests/document/indexes.py /^ def test_hint(self):$/;" m class:IndexesTest +test_image_field mongoengine/tests/fields/file_tests.py /^ def test_image_field(self):$/;" m class:FileTest +test_image_field_reassigning mongoengine/tests/fields/file_tests.py /^ def test_image_field_reassigning(self):$/;" m class:FileTest +test_image_field_resize mongoengine/tests/fields/file_tests.py /^ def test_image_field_resize(self):$/;" m class:FileTest +test_image_field_resize_force mongoengine/tests/fields/file_tests.py /^ def test_image_field_resize_force(self):$/;" m class:FileTest +test_image_field_thumbnail mongoengine/tests/fields/file_tests.py /^ def test_image_field_thumbnail(self):$/;" m class:FileTest +test_in_operator_on_non_iterable mongoengine/tests/queryset/queryset.py /^ def test_in_operator_on_non_iterable(self):$/;" m class:QuerySetTest +test_include_exclude mongoengine/tests/queryset/field_list.py /^ def test_include_exclude(self):$/;" m class:QueryFieldListTest +test_include_include mongoengine/tests/queryset/field_list.py /^ def test_include_include(self):$/;" m class:QueryFieldListTest +test_index_dont_send_cls_option mongoengine/tests/document/indexes.py /^ def test_index_dont_send_cls_option(self):$/;" m class:IndexesTest +test_index_no_cls mongoengine/tests/document/indexes.py /^ def test_index_no_cls(self):$/;" m class:IndexesTest +test_index_on_id mongoengine/tests/document/indexes.py /^ def test_index_on_id(self):$/;" m class:IndexesTest +test_index_with_pk mongoengine/tests/document/indexes.py /^ def test_index_with_pk(self):$/;" m class:IndexesTest +test_indexes_2dsphere mongoengine/tests/fields/geo.py /^ def test_indexes_2dsphere(self):$/;" m class:GeoFieldTest +test_indexes_2dsphere_embedded mongoengine/tests/fields/geo.py /^ def test_indexes_2dsphere_embedded(self):$/;" m class:GeoFieldTest +test_indexes_after_database_drop mongoengine/tests/document/indexes.py /^ def test_indexes_after_database_drop(self):$/;" m class:IndexesTest +test_indexes_and_multiple_inheritance mongoengine/tests/document/inheritance.py /^ def test_indexes_and_multiple_inheritance(self):$/;" m class:InheritanceTest +test_indexes_document mongoengine/tests/document/indexes.py /^ def test_indexes_document(self):$/;" m class:IndexesTest +test_indexes_document_inheritance mongoengine/tests/document/indexes.py /^ def test_indexes_document_inheritance(self):$/;" m class:IndexesTest +test_indexes_dynamic_document mongoengine/tests/document/indexes.py /^ def test_indexes_dynamic_document(self):$/;" m class:IndexesTest +test_indexes_dynamic_document_inheritance mongoengine/tests/document/indexes.py /^ def test_indexes_dynamic_document_inheritance(self):$/;" m class:IndexesTest +test_indexes_geopoint mongoengine/tests/fields/geo.py /^ def test_indexes_geopoint(self):$/;" m class:GeoFieldTest +test_inherit_objects mongoengine/tests/queryset/queryset.py /^ def test_inherit_objects(self):$/;" m class:QuerySetTest +test_inherit_objects_override mongoengine/tests/queryset/queryset.py /^ def test_inherit_objects_override(self):$/;" m class:QuerySetTest +test_inheritance mongoengine/tests/document/dynamic.py /^ def test_inheritance(self):$/;" m class:DynamicTest +test_inheritance_meta_data mongoengine/tests/document/inheritance.py /^ def test_inheritance_meta_data(self):$/;" m class:InheritanceTest +test_inheritance_to_mongo_keys mongoengine/tests/document/inheritance.py /^ def test_inheritance_to_mongo_keys(self):$/;" m class:InheritanceTest +test_inherited_collections mongoengine/tests/document/inheritance.py /^ def test_inherited_collections(self):$/;" m class:InheritanceTest +test_inherited_index mongoengine/tests/document/indexes.py /^ def test_inherited_index(self):$/;" m class:IndexesTest +test_inherited_sequencefield mongoengine/tests/fields/fields.py /^ def test_inherited_sequencefield(self):$/;" m class:FieldTest +test_inherited_sequencefield tests/fields/fields.py /^ def test_inherited_sequencefield(self):$/;" m class:FieldTest +test_init mongoengine/tests/test_datastructures.py /^ def test_init(self):$/;" m class:TestStrictDict +test_init_fails_on_nonexisting_attrs mongoengine/tests/test_datastructures.py /^ def test_init_fails_on_nonexisting_attrs(self):$/;" m class:TestStrictDict +test_initialisation mongoengine/tests/queryset/queryset.py /^ def test_initialisation(self):$/;" m class:QuerySetTest +test_inserts_if_you_set_the_pk mongoengine/tests/document/instance.py /^ def test_inserts_if_you_set_the_pk(self):$/;" m class:InstanceTest +test_instance_is_set_on_setattr mongoengine/tests/document/instance.py /^ def test_instance_is_set_on_setattr(self):$/;" m class:InstanceTest +test_instance_is_set_on_setattr_on_embedded_document_list mongoengine/tests/document/instance.py /^ def test_instance_is_set_on_setattr_on_embedded_document_list(self):$/;" m class:InstanceTest +test_int_and_float_ne_operator mongoengine/tests/fields/fields.py /^ def test_int_and_float_ne_operator(self):$/;" m class:FieldTest +test_int_and_float_ne_operator tests/fields/fields.py /^ def test_int_and_float_ne_operator(self):$/;" m class:FieldTest +test_int_validation mongoengine/tests/fields/fields.py /^ def test_int_validation(self):$/;" m class:FieldTest +test_int_validation tests/fields/fields.py /^ def test_int_validation(self):$/;" m class:FieldTest +test_invalid_dict_value mongoengine/tests/fields/fields.py /^ def test_invalid_dict_value(self):$/;" m class:FieldTest +test_invalid_dict_value tests/fields/fields.py /^ def test_invalid_dict_value(self):$/;" m class:FieldTest +test_invalid_reverse_delete_rule_raise_errors mongoengine/tests/document/instance.py /^ def test_invalid_reverse_delete_rule_raise_errors(self):$/;" m class:InstanceTest +test_invalid_son mongoengine/tests/document/instance.py /^ def test_invalid_son(self):$/;" m class:InstanceTest +test_item_frequencies mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies(self):$/;" m class:QuerySetTest +test_item_frequencies_normalize mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_normalize(self):$/;" m class:QuerySetTest +test_item_frequencies_null_values mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_null_values(self):$/;" m class:QuerySetTest +test_item_frequencies_on_embedded mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_on_embedded(self):$/;" m class:QuerySetTest +test_item_frequencies_with_0_values mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_with_0_values(self):$/;" m class:QuerySetTest +test_item_frequencies_with_False_values mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_with_False_values(self):$/;" m class:QuerySetTest +test_item_frequencies_with_null_embedded mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_with_null_embedded(self):$/;" m class:QuerySetTest +test_items mongoengine/tests/test_datastructures.py /^ def test_items(self):$/;" m class:TestStrictDict +test_iteration_within_iteration mongoengine/tests/queryset/queryset.py /^ def test_iteration_within_iteration(self):$/;" m class:QuerySetTest +test_json_complex mongoengine/tests/document/json_serialisation.py /^ def test_json_complex(self):$/;" m class:TestJson +test_json_complex mongoengine/tests/queryset/queryset.py /^ def test_json_complex(self):$/;" m class:QuerySetTest +test_json_names mongoengine/tests/document/json_serialisation.py /^ def test_json_names(self):$/;" m class:TestJson +test_json_simple mongoengine/tests/document/json_serialisation.py /^ def test_json_simple(self):$/;" m class:TestJson +test_json_simple mongoengine/tests/queryset/queryset.py /^ def test_json_simple(self):$/;" m class:QuerySetTest +test_keyword_multiple_return_get mongoengine/tests/fields/fields.py /^ def test_keyword_multiple_return_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_keyword_multiple_return_get tests/fields/fields.py /^ def test_keyword_multiple_return_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_kwargs_complex mongoengine/tests/document/instance.py /^ def test_kwargs_complex(self):$/;" m class:InstanceTest +test_kwargs_simple mongoengine/tests/document/instance.py /^ def test_kwargs_simple(self):$/;" m class:InstanceTest +test_last_field_name_like_operator mongoengine/tests/queryset/transform.py /^ def test_last_field_name_like_operator(self):$/;" m class:TransformTest +test_lazy_reference_bad_set mongoengine/tests/fields/fields.py /^ def test_lazy_reference_bad_set(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_bad_set tests/fields/fields.py /^ def test_lazy_reference_bad_set(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_config mongoengine/tests/fields/fields.py /^ def test_lazy_reference_config(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_config tests/fields/fields.py /^ def test_lazy_reference_config(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_embedded mongoengine/tests/fields/fields.py /^ def test_lazy_reference_embedded(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_embedded tests/fields/fields.py /^ def test_lazy_reference_embedded(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_equality mongoengine/tests/fields/fields.py /^ def test_lazy_reference_equality(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_equality tests/fields/fields.py /^ def test_lazy_reference_equality(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_fetch_invalid_ref mongoengine/tests/fields/fields.py /^ def test_lazy_reference_fetch_invalid_ref(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_fetch_invalid_ref tests/fields/fields.py /^ def test_lazy_reference_fetch_invalid_ref(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_not_set mongoengine/tests/fields/fields.py /^ def test_lazy_reference_not_set(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_not_set tests/fields/fields.py /^ def test_lazy_reference_not_set(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_passthrough mongoengine/tests/fields/fields.py /^ def test_lazy_reference_passthrough(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_passthrough tests/fields/fields.py /^ def test_lazy_reference_passthrough(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_query_conversion mongoengine/tests/fields/fields.py /^ def test_lazy_reference_query_conversion(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_query_conversion tests/fields/fields.py /^ def test_lazy_reference_query_conversion(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_query_conversion_dbref mongoengine/tests/fields/fields.py /^ def test_lazy_reference_query_conversion_dbref(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_query_conversion_dbref tests/fields/fields.py /^ def test_lazy_reference_query_conversion_dbref(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_set mongoengine/tests/fields/fields.py /^ def test_lazy_reference_set(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_set tests/fields/fields.py /^ def test_lazy_reference_set(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_simple mongoengine/tests/fields/fields.py /^ def test_lazy_reference_simple(self):$/;" m class:LazyReferenceFieldTest +test_lazy_reference_simple tests/fields/fields.py /^ def test_lazy_reference_simple(self):$/;" m class:LazyReferenceFieldTest +test_len_during_iteration mongoengine/tests/queryset/queryset.py /^ def test_len_during_iteration(self):$/;" m class:QuerySetTest +test_limit mongoengine/tests/queryset/queryset.py /^ def test_limit(self):$/;" m class:QuerySetTest +test_limit_with_write_concern_0 mongoengine/tests/queryset/queryset.py /^ def test_limit_with_write_concern_0(self):$/;" m class:QuerySetTest +test_linestring mongoengine/tests/queryset/geo.py /^ def test_linestring(self):$/;" m class:GeoQueriesTest +test_linestring_validation mongoengine/tests/fields/geo.py /^ def test_linestring_validation(self):$/;" m class:GeoFieldTest +test_list_assignment mongoengine/tests/fields/fields.py /^ def test_list_assignment(self):$/;" m class:FieldTest +test_list_assignment tests/fields/fields.py /^ def test_list_assignment(self):$/;" m class:FieldTest +test_list_embedded_document_index mongoengine/tests/document/indexes.py /^ def test_list_embedded_document_index(self):$/;" m class:IndexesTest +test_list_field mongoengine/tests/fields/fields.py /^ def test_list_field(self):$/;" m class:FieldTest +test_list_field tests/fields/fields.py /^ def test_list_field(self):$/;" m class:FieldTest +test_list_field_complex mongoengine/tests/fields/fields.py /^ def test_list_field_complex(self):$/;" m class:FieldTest +test_list_field_complex mongoengine/tests/test_dereference.py /^ def test_list_field_complex(self):$/;" m class:FieldTest +test_list_field_complex tests/fields/fields.py /^ def test_list_field_complex(self):$/;" m class:FieldTest +test_list_field_invalid_operators mongoengine/tests/fields/fields.py /^ def test_list_field_invalid_operators(self):$/;" m class:FieldTest +test_list_field_invalid_operators tests/fields/fields.py /^ def test_list_field_invalid_operators(self):$/;" m class:FieldTest +test_list_field_lexicographic_operators mongoengine/tests/fields/fields.py /^ def test_list_field_lexicographic_operators(self):$/;" m class:FieldTest +test_list_field_lexicographic_operators tests/fields/fields.py /^ def test_list_field_lexicographic_operators(self):$/;" m class:FieldTest +test_list_field_manipulative_operators mongoengine/tests/fields/fields.py /^ def test_list_field_manipulative_operators(self):$/;" m class:FieldTest +test_list_field_manipulative_operators tests/fields/fields.py /^ def test_list_field_manipulative_operators(self):$/;" m class:FieldTest +test_list_field_passed_in_value mongoengine/tests/fields/fields.py /^ def test_list_field_passed_in_value(self):$/;" m class:FieldTest +test_list_field_passed_in_value tests/fields/fields.py /^ def test_list_field_passed_in_value(self):$/;" m class:FieldTest +test_list_field_rejects_strings mongoengine/tests/fields/fields.py /^ def test_list_field_rejects_strings(self):$/;" m class:FieldTest +test_list_field_rejects_strings tests/fields/fields.py /^ def test_list_field_rejects_strings(self):$/;" m class:FieldTest +test_list_field_strict mongoengine/tests/fields/fields.py /^ def test_list_field_strict(self):$/;" m class:FieldTest +test_list_field_strict tests/fields/fields.py /^ def test_list_field_strict(self):$/;" m class:FieldTest +test_list_field_with_negative_indices mongoengine/tests/fields/fields.py /^ def test_list_field_with_negative_indices(self):$/;" m class:FieldTest +test_list_field_with_negative_indices tests/fields/fields.py /^ def test_list_field_with_negative_indices(self):$/;" m class:FieldTest +test_list_indexes_inheritance mongoengine/tests/document/class_methods.py /^ def test_list_indexes_inheritance(self):$/;" m class:ClassMethodsTest +test_list_item_dereference mongoengine/tests/fields/fields.py /^ def test_list_item_dereference(self):$/;" m class:FieldTest +test_list_item_dereference mongoengine/tests/test_dereference.py /^ def test_list_item_dereference(self):$/;" m class:FieldTest +test_list_item_dereference tests/fields/fields.py /^ def test_list_item_dereference(self):$/;" m class:FieldTest +test_list_item_dereference_dref_false mongoengine/tests/test_dereference.py /^ def test_list_item_dereference_dref_false(self):$/;" m class:FieldTest +test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries mongoengine/tests/test_dereference.py /^ def test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries(self):$/;" m class:FieldTest +test_list_item_dereference_dref_false_stores_as_type mongoengine/tests/test_dereference.py /^ def test_list_item_dereference_dref_false_stores_as_type(self):$/;" m class:FieldTest +test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries mongoengine/tests/test_dereference.py /^ def test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries(self):$/;" m class:FieldTest +test_list_iter mongoengine/tests/document/instance.py /^ def test_list_iter(self):$/;" m class:InstanceTest +test_list_lookup_not_checked_in_map mongoengine/tests/test_dereference.py /^ def test_list_lookup_not_checked_in_map(self):$/;" m class:FieldTest +test_list_of_lists_of_references mongoengine/tests/test_dereference.py /^ def test_list_of_lists_of_references(self):$/;" m class:FieldTest +test_list_search_by_embedded mongoengine/tests/document/instance.py /^ def test_list_search_by_embedded(self):$/;" m class:InstanceTest +test_list_validation mongoengine/tests/fields/fields.py /^ def test_list_validation(self):$/;" m class:FieldTest +test_list_validation tests/fields/fields.py /^ def test_list_validation(self):$/;" m class:FieldTest +test_load_undefined_fields mongoengine/tests/document/instance.py /^ def test_load_undefined_fields(self):$/;" m class:InstanceTest +test_load_undefined_fields_on_embedded_document mongoengine/tests/document/instance.py /^ def test_load_undefined_fields_on_embedded_document(self):$/;" m class:InstanceTest +test_load_undefined_fields_on_embedded_document_with_strict_false mongoengine/tests/document/instance.py /^ def test_load_undefined_fields_on_embedded_document_with_strict_false(self):$/;" m class:InstanceTest +test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc mongoengine/tests/document/instance.py /^ def test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc(self):$/;" m class:InstanceTest +test_load_undefined_fields_with_strict_false mongoengine/tests/document/instance.py /^ def test_load_undefined_fields_with_strict_false(self):$/;" m class:InstanceTest +test_long_field_is_considered_as_int64 mongoengine/tests/fields/fields.py /^ def test_long_field_is_considered_as_int64(self):$/;" m class:FieldTest +test_long_field_is_considered_as_int64 tests/fields/fields.py /^ def test_long_field_is_considered_as_int64(self):$/;" m class:FieldTest +test_long_ne_operator mongoengine/tests/fields/fields.py /^ def test_long_ne_operator(self):$/;" m class:FieldTest +test_long_ne_operator tests/fields/fields.py /^ def test_long_ne_operator(self):$/;" m class:FieldTest +test_long_validation mongoengine/tests/fields/fields.py /^ def test_long_validation(self):$/;" m class:FieldTest +test_long_validation tests/fields/fields.py /^ def test_long_validation(self):$/;" m class:FieldTest +test_loop_over_invalid_id_does_not_crash mongoengine/tests/queryset/queryset.py /^ def test_loop_over_invalid_id_does_not_crash(self):$/;" m class:QuerySetTest +test_lower_level_mark_as_changed mongoengine/tests/document/delta.py /^ def test_lower_level_mark_as_changed(self):$/;" m class:DeltaTest +test_map_field_lookup mongoengine/tests/fields/fields.py /^ def test_map_field_lookup(self):$/;" m class:FieldTest +test_map_field_lookup tests/fields/fields.py /^ def test_map_field_lookup(self):$/;" m class:FieldTest +test_map_field_reference mongoengine/tests/test_dereference.py /^ def test_map_field_reference(self):$/;" m class:FieldTest +test_map_field_unicode mongoengine/tests/fields/fields.py /^ def test_map_field_unicode(self):$/;" m class:FieldTest +test_map_field_unicode tests/fields/fields.py /^ def test_map_field_unicode(self):$/;" m class:FieldTest +test_map_reduce mongoengine/tests/queryset/queryset.py /^ def test_map_reduce(self):$/;" m class:QuerySetTest +test_map_reduce_custom_output mongoengine/tests/queryset/queryset.py /^ def test_map_reduce_custom_output(self):$/;" m class:QuerySetTest +test_map_reduce_finalize mongoengine/tests/queryset/queryset.py /^ def test_map_reduce_finalize(self):$/;" m class:QuerySetTest +test_map_reduce_with_custom_object_ids mongoengine/tests/queryset/queryset.py /^ def test_map_reduce_with_custom_object_ids(self):$/;" m class:QuerySetTest +test_mapfield mongoengine/tests/fields/fields.py /^ def test_mapfield(self):$/;" m class:FieldTest +test_mapfield tests/fields/fields.py /^ def test_mapfield(self):$/;" m class:FieldTest +test_mapfield_numerical_index mongoengine/tests/fields/fields.py /^ def test_mapfield_numerical_index(self):$/;" m class:FieldTest +test_mapfield_numerical_index tests/fields/fields.py /^ def test_mapfield_numerical_index(self):$/;" m class:FieldTest +test_mapfield_update mongoengine/tests/queryset/queryset.py /^ def test_mapfield_update(self):$/;" m class:QuerySetTest +test_mappings_protocol mongoengine/tests/test_datastructures.py /^ def test_mappings_protocol(self):$/;" m class:TestStrictDict +test_max_time_ms mongoengine/tests/queryset/queryset.py /^ def test_max_time_ms(self):$/;" m class:QuerySetTest +test_migrate_references mongoengine/tests/test_dereference.py /^ def test_migrate_references(self):$/;" m class:FieldTest +test_mix_slice_with_other_fields mongoengine/tests/queryset/field_list.py /^ def test_mix_slice_with_other_fields(self):$/;" m class:OnlyExcludeAllTest +test_mixed_creation mongoengine/tests/document/instance.py /^ def test_mixed_creation(self):$/;" m class:InstanceTest +test_mixed_creation_dynamic mongoengine/tests/document/instance.py /^ def test_mixed_creation_dynamic(self):$/;" m class:InstanceTest +test_mixed_creation_embedded mongoengine/tests/document/instance.py /^ def test_mixed_creation_embedded(self):$/;" m class:InstanceTest +test_mixin_inheritance mongoengine/tests/document/instance.py /^ def test_mixin_inheritance(self):$/;" m class:InstanceTest +test_mixing_only_exclude mongoengine/tests/queryset/field_list.py /^ def test_mixing_only_exclude(self):$/;" m class:OnlyExcludeAllTest +test_model_signals mongoengine/tests/test_signals.py /^ def test_model_signals(self):$/;" m class:SignalTests +test_model_validation mongoengine/tests/document/validation.py /^ def test_model_validation(self):$/;" m class:ValidatorErrorTest +test_modify mongoengine/tests/queryset/modify.py /^ def test_modify(self):$/;" m class:FindAndModifyTest +test_modify_empty mongoengine/tests/document/instance.py /^ def test_modify_empty(self):$/;" m class:InstanceTest +test_modify_invalid_query mongoengine/tests/document/instance.py /^ def test_modify_invalid_query(self):$/;" m class:InstanceTest +test_modify_match_another_document mongoengine/tests/document/instance.py /^ def test_modify_match_another_document(self):$/;" m class:InstanceTest +test_modify_not_existing mongoengine/tests/queryset/modify.py /^ def test_modify_not_existing(self):$/;" m class:FindAndModifyTest +test_modify_not_exists mongoengine/tests/document/instance.py /^ def test_modify_not_exists(self):$/;" m class:InstanceTest +test_modify_update mongoengine/tests/document/instance.py /^ def test_modify_update(self):$/;" m class:InstanceTest +test_modify_with_fields mongoengine/tests/queryset/modify.py /^ def test_modify_with_fields(self):$/;" m class:FindAndModifyTest +test_modify_with_new mongoengine/tests/queryset/modify.py /^ def test_modify_with_new(self):$/;" m class:FindAndModifyTest +test_modify_with_order_by mongoengine/tests/queryset/modify.py /^ def test_modify_with_order_by(self):$/;" m class:FindAndModifyTest +test_modify_with_positional_push mongoengine/tests/document/instance.py /^ def test_modify_with_positional_push(self):$/;" m class:InstanceTest +test_modify_with_push mongoengine/tests/queryset/modify.py /^ def test_modify_with_push(self):$/;" m class:FindAndModifyTest +test_modify_with_remove mongoengine/tests/queryset/modify.py /^ def test_modify_with_remove(self):$/;" m class:FindAndModifyTest +test_modify_with_upsert mongoengine/tests/queryset/modify.py /^ def test_modify_with_upsert(self):$/;" m class:FindAndModifyTest +test_modify_with_upsert_existing mongoengine/tests/queryset/modify.py /^ def test_modify_with_upsert_existing(self):$/;" m class:FindAndModifyTest +test_modify_with_upsert_with_new mongoengine/tests/queryset/modify.py /^ def test_modify_with_upsert_with_new(self):$/;" m class:FindAndModifyTest +test_multi_keyword_exclude mongoengine/tests/fields/fields.py /^ def test_multi_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_multi_keyword_exclude tests/fields/fields.py /^ def test_multi_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_multi_keyword_filter mongoengine/tests/fields/fields.py /^ def test_multi_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_multi_keyword_filter tests/fields/fields.py /^ def test_multi_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_multi_keyword_get mongoengine/tests/fields/fields.py /^ def test_multi_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_multi_keyword_get tests/fields/fields.py /^ def test_multi_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_multidirectional_lists mongoengine/tests/test_dereference.py /^ def test_multidirectional_lists(self):$/;" m class:FieldTest +test_multilinestring_validation mongoengine/tests/fields/geo.py /^ def test_multilinestring_validation(self):$/;" m class:GeoFieldTest +test_multiple_connection_settings mongoengine/tests/test_connection.py /^ def test_multiple_connection_settings(self):$/;" m class:ConnectionTest +test_multiple_occurence_in_field mongoengine/tests/queryset/visitor.py /^ def test_multiple_occurence_in_field(self):$/;" m class:QTest +test_multiple_sequence_fields mongoengine/tests/fields/fields.py /^ def test_multiple_sequence_fields(self):$/;" m class:FieldTest +test_multiple_sequence_fields tests/fields/fields.py /^ def test_multiple_sequence_fields(self):$/;" m class:FieldTest +test_multiple_sequence_fields_on_docs mongoengine/tests/fields/fields.py /^ def test_multiple_sequence_fields_on_docs(self):$/;" m class:FieldTest +test_multiple_sequence_fields_on_docs tests/fields/fields.py /^ def test_multiple_sequence_fields_on_docs(self):$/;" m class:FieldTest +test_multipoint_validation mongoengine/tests/fields/geo.py /^ def test_multipoint_validation(self):$/;" m class:GeoFieldTest +test_multipolygon_validation mongoengine/tests/fields/geo.py /^ def test_multipolygon_validation(self):$/;" m class:GeoFieldTest +test_mutating_documents mongoengine/tests/document/instance.py /^ def test_mutating_documents(self):$/;" m class:InstanceTest +test_near mongoengine/tests/queryset/geo.py /^ def test_near(self):$/;" m class:GeoQueriesTest +test_near_and_max_distance mongoengine/tests/queryset/geo.py /^ def test_near_and_max_distance(self):$/;" m class:GeoQueriesTest +test_near_and_min_distance mongoengine/tests/queryset/geo.py /^ def test_near_and_min_distance(self):$/;" m class:GeoQueriesTest +test_nested_nested_fields_mark_as_changed mongoengine/tests/document/delta.py /^ def test_nested_nested_fields_mark_as_changed(self):$/;" m class:DeltaTest +test_nested_queryset_iterator mongoengine/tests/queryset/queryset.py /^ def test_nested_queryset_iterator(self):$/;" m class:QuerySetTest +test_no_cache mongoengine/tests/queryset/queryset.py /^ def test_no_cache(self):$/;" m class:QuerySetTest +test_no_cached_queryset mongoengine/tests/queryset/queryset.py /^ def test_no_cached_queryset(self):$/;" m class:QuerySetTest +test_no_dereference mongoengine/tests/queryset/queryset.py /^ def test_no_dereference(self):$/;" m class:QuerySetTest +test_no_dereference_context_manager_dbref mongoengine/tests/test_context_managers.py /^ def test_no_dereference_context_manager_dbref(self):$/;" m class:ContextManagersTest +test_no_dereference_context_manager_object_id mongoengine/tests/test_context_managers.py /^ def test_no_dereference_context_manager_object_id(self):$/;" m class:ContextManagersTest +test_no_dereference_embedded_doc mongoengine/tests/queryset/queryset.py /^ def test_no_dereference_embedded_doc(self):$/;" m class:QuerySetTest +test_no_inherited_sequencefield mongoengine/tests/fields/fields.py /^ def test_no_inherited_sequencefield(self):$/;" m class:FieldTest +test_no_inherited_sequencefield tests/fields/fields.py /^ def test_no_inherited_sequencefield(self):$/;" m class:FieldTest +test_no_keyword_exclude mongoengine/tests/fields/fields.py /^ def test_no_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_no_keyword_exclude tests/fields/fields.py /^ def test_no_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_no_keyword_filter mongoengine/tests/fields/fields.py /^ def test_no_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_no_keyword_filter tests/fields/fields.py /^ def test_no_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_no_keyword_multiple_return_get mongoengine/tests/fields/fields.py /^ def test_no_keyword_multiple_return_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_no_keyword_multiple_return_get tests/fields/fields.py /^ def test_no_keyword_multiple_return_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_no_keyword_update mongoengine/tests/fields/fields.py /^ def test_no_keyword_update(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_no_keyword_update tests/fields/fields.py /^ def test_no_keyword_update(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_no_ordering_for_get mongoengine/tests/queryset/queryset.py /^ def test_no_ordering_for_get(self):$/;" m class:QuerySetTest +test_no_result_get mongoengine/tests/fields/fields.py /^ def test_no_result_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_no_result_get tests/fields/fields.py /^ def test_no_result_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_no_sub_classes mongoengine/tests/queryset/queryset.py /^ def test_no_sub_classes(self):$/;" m class:QuerySetTest +test_no_sub_classes mongoengine/tests/test_context_managers.py /^ def test_no_sub_classes(self):$/;" m class:ContextManagersTest +test_non_ascii_pk mongoengine/tests/test_dereference.py /^ def test_non_ascii_pk(self):$/;" m class:FieldTest +test_non_matching_exclude mongoengine/tests/fields/fields.py /^ def test_non_matching_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_non_matching_exclude tests/fields/fields.py /^ def test_non_matching_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_none mongoengine/tests/queryset/queryset.py /^ def test_none(self):$/;" m class:QuerySetTest +test_not mongoengine/tests/queryset/queryset.py /^ def test_not(self):$/;" m class:QuerySetTest +test_not_required_handles_none_from_database mongoengine/tests/fields/fields.py /^ def test_not_required_handles_none_from_database(self):$/;" m class:FieldTest +test_not_required_handles_none_from_database tests/fields/fields.py /^ def test_not_required_handles_none_from_database(self):$/;" m class:FieldTest +test_not_required_handles_none_in_update mongoengine/tests/fields/fields.py /^ def test_not_required_handles_none_in_update(self):$/;" m class:FieldTest +test_not_required_handles_none_in_update tests/fields/fields.py /^ def test_not_required_handles_none_in_update(self):$/;" m class:FieldTest +test_not_saved_eq mongoengine/tests/document/instance.py /^ def test_not_saved_eq(self):$/;" m class:InstanceTest +test_null_field mongoengine/tests/document/instance.py /^ def test_null_field(self):$/;" m class:InstanceTest +test_object_id_validation mongoengine/tests/fields/fields.py /^ def test_object_id_validation(self):$/;" m class:FieldTest +test_object_id_validation tests/fields/fields.py /^ def test_object_id_validation(self):$/;" m class:FieldTest +test_object_mixins mongoengine/tests/document/instance.py /^ def test_object_mixins(self):$/;" m class:InstanceTest +test_objectid_reference_across_databases mongoengine/tests/test_dereference.py /^ def test_objectid_reference_across_databases(self):$/;" m class:FieldTest +test_objectid_reference_fields mongoengine/tests/fields/fields.py /^ def test_objectid_reference_fields(self):$/;" m class:FieldTest +test_objectid_reference_fields tests/fields/fields.py /^ def test_objectid_reference_fields(self):$/;" m class:FieldTest +test_only mongoengine/tests/queryset/field_list.py /^ def test_only(self):$/;" m class:OnlyExcludeAllTest +test_only_with_subfields mongoengine/tests/queryset/field_list.py /^ def test_only_with_subfields(self):$/;" m class:OnlyExcludeAllTest +test_or_and_or_combination mongoengine/tests/queryset/visitor.py /^ def test_or_and_or_combination(self):$/;" m class:QTest +test_or_combination mongoengine/tests/queryset/visitor.py /^ def test_or_combination(self):$/;" m class:QTest +test_order_by mongoengine/tests/queryset/queryset.py /^ def test_order_by(self):$/;" m class:QuerySetTest +test_order_by_chaining mongoengine/tests/queryset/queryset.py /^ def test_order_by_chaining(self):$/;" m class:QuerySetTest +test_order_by_list mongoengine/tests/queryset/queryset.py /^ def test_order_by_list(self):$/;" m class:QuerySetTest +test_order_by_optional mongoengine/tests/queryset/queryset.py /^ def test_order_by_optional(self):$/;" m class:QuerySetTest +test_order_then_filter mongoengine/tests/queryset/queryset.py /^ def test_order_then_filter(self):$/;" m class:QuerySetTest +test_order_works_with_custom_db_field_names mongoengine/tests/queryset/queryset.py /^ def test_order_works_with_custom_db_field_names(self):$/;" m class:QuerySetTest +test_order_works_with_primary mongoengine/tests/queryset/queryset.py /^ def test_order_works_with_primary(self):$/;" m class:QuerySetTest +test_ordering mongoengine/tests/queryset/queryset.py /^ def test_ordering(self):$/;" m class:QuerySetTest +test_override_method_with_field mongoengine/tests/document/instance.py /^ def test_override_method_with_field(self):$/;" m class:InstanceTest +test_parent_reference_in_child_document mongoengine/tests/document/validation.py /^ def test_parent_reference_in_child_document(self):$/;" m class:ValidatorErrorTest +test_parent_reference_set_as_attribute_in_child_document mongoengine/tests/document/validation.py /^ def test_parent_reference_set_as_attribute_in_child_document(self):$/;" m class:ValidatorErrorTest +test_picke_simple_qs mongoengine/tests/queryset/pickable.py /^ def test_picke_simple_qs(self):$/;" m class:TestQuerysetPickable +test_picklable mongoengine/tests/document/instance.py /^ def test_picklable(self):$/;" m class:InstanceTest +test_picklable_on_signals mongoengine/tests/document/instance.py /^ def test_picklable_on_signals(self):$/;" m class:InstanceTest +test_pickle_support_filtration mongoengine/tests/queryset/pickable.py /^ def test_pickle_support_filtration(self):$/;" m class:TestQuerysetPickable +test_point_validation mongoengine/tests/fields/geo.py /^ def test_point_validation(self):$/;" m class:GeoFieldTest +test_polygon mongoengine/tests/queryset/geo.py /^ def test_polygon(self):$/;" m class:GeoQueriesTest +test_polygon_validation mongoengine/tests/fields/geo.py /^ def test_polygon_validation(self):$/;" m class:GeoFieldTest +test_polymorphic_queries mongoengine/tests/document/inheritance.py /^ def test_polymorphic_queries(self):$/;" m class:InheritanceTest +test_polymorphic_references mongoengine/tests/document/instance.py /^ def test_polymorphic_references(self):$/;" m class:InstanceTest +test_positional_creation mongoengine/tests/document/instance.py /^ def test_positional_creation(self):$/;" m class:InstanceTest +test_positional_creation_embedded mongoengine/tests/document/instance.py /^ def test_positional_creation_embedded(self):$/;" m class:InstanceTest +test_pull_from_nested_embedded mongoengine/tests/queryset/queryset.py /^ def test_pull_from_nested_embedded(self):$/;" m class:QuerySetTest +test_pull_from_nested_mapfield mongoengine/tests/queryset/queryset.py /^ def test_pull_from_nested_mapfield(self):$/;" m class:QuerySetTest +test_pull_in_genericembedded_field mongoengine/tests/queryset/queryset.py /^ def test_pull_in_genericembedded_field(self):$/;" m class:QuerySetTest +test_pull_nested mongoengine/tests/queryset/queryset.py /^ def test_pull_nested(self):$/;" m class:QuerySetTest +test_push_nested_list mongoengine/tests/document/instance.py /^ def test_push_nested_list(self):$/;" m class:InstanceTest +test_push_with_position mongoengine/tests/document/instance.py /^ def test_push_with_position(self):$/;" m class:InstanceTest +test_q mongoengine/tests/queryset/visitor.py /^ def test_q(self):$/;" m class:QTest +test_q_clone mongoengine/tests/queryset/visitor.py /^ def test_q_clone(self):$/;" m class:QTest +test_q_lists mongoengine/tests/queryset/visitor.py /^ def test_q_lists(self):$/;" m class:QTest +test_q_merge_queries_edge_case mongoengine/tests/queryset/visitor.py /^ def test_q_merge_queries_edge_case(self):$/;" m class:QTest +test_q_regex mongoengine/tests/queryset/visitor.py /^ def test_q_regex(self):$/;" m class:QTest +test_q_with_dbref mongoengine/tests/queryset/visitor.py /^ def test_q_with_dbref(self):$/;" m class:QTest +test_query_count_when_saving mongoengine/tests/document/instance.py /^ def test_query_count_when_saving(self):$/;" m class:InstanceTest +test_query_counter mongoengine/tests/test_context_managers.py /^ def test_query_counter(self):$/;" m class:ContextManagersTest +test_query_field_name mongoengine/tests/queryset/transform.py /^ def test_query_field_name(self):$/;" m class:TransformTest +test_query_generic_embedded_document mongoengine/tests/queryset/queryset.py /^ def test_query_generic_embedded_document(self):$/;" m class:QuerySetTest +test_query_pk_field_name mongoengine/tests/queryset/transform.py /^ def test_query_pk_field_name(self):$/;" m class:TransformTest +test_query_reference_to_custom_pk_doc mongoengine/tests/queryset/queryset.py /^ def test_query_reference_to_custom_pk_doc(self):$/;" m class:QuerySetTest +test_query_value_conversion mongoengine/tests/queryset/queryset.py /^ def test_query_value_conversion(self):$/;" m class:QuerySetTest +test_queryset_aggregation_framework mongoengine/tests/queryset/queryset.py /^ def test_queryset_aggregation_framework(self):$/;" m class:QuerySetTest +test_queryset_delete_signals mongoengine/tests/test_signals.py /^ def test_queryset_delete_signals(self):$/;" m class:SignalTests +test_queryset_resurrects_dropped_collection mongoengine/tests/document/instance.py /^ def test_queryset_resurrects_dropped_collection(self):$/;" m class:InstanceTest +test_raw_and_merging mongoengine/tests/queryset/transform.py /^ def test_raw_and_merging(self):$/;" m class:TransformTest +test_raw_query_and_Q_objects mongoengine/tests/queryset/transform.py /^ def test_raw_query_and_Q_objects(self):$/;" m class:TransformTest +test_read_preference mongoengine/tests/queryset/queryset.py /^ def test_read_preference(self):$/;" m class:QuerySetTest +test_recursive_embedded_objects_dont_break_indexes mongoengine/tests/document/indexes.py /^ def test_recursive_embedded_objects_dont_break_indexes(self):$/;" m class:IndexesTest +test_recursive_embedding mongoengine/tests/fields/fields.py /^ def test_recursive_embedding(self):$/;" m class:FieldTest +test_recursive_embedding tests/fields/fields.py /^ def test_recursive_embedding(self):$/;" m class:FieldTest +test_recursive_reference mongoengine/tests/fields/fields.py /^ def test_recursive_reference(self):$/;" m class:FieldTest +test_recursive_reference mongoengine/tests/test_dereference.py /^ def test_recursive_reference(self):$/;" m class:FieldTest +test_recursive_reference tests/fields/fields.py /^ def test_recursive_reference(self):$/;" m class:FieldTest +test_recursive_validation mongoengine/tests/fields/fields.py /^ def test_recursive_validation(self):$/;" m class:FieldTest +test_recursive_validation tests/fields/fields.py /^ def test_recursive_validation(self):$/;" m class:FieldTest +test_reference_abstract_class mongoengine/tests/fields/fields.py /^ def test_reference_abstract_class(self):$/;" m class:FieldTest +test_reference_abstract_class tests/fields/fields.py /^ def test_reference_abstract_class(self):$/;" m class:FieldTest +test_reference_class_with_abstract_parent mongoengine/tests/fields/fields.py /^ def test_reference_class_with_abstract_parent(self):$/;" m class:FieldTest +test_reference_class_with_abstract_parent tests/fields/fields.py /^ def test_reference_class_with_abstract_parent(self):$/;" m class:FieldTest +test_reference_field_find mongoengine/tests/queryset/queryset.py /^ def test_reference_field_find(self):$/;" m class:QuerySetTest +test_reference_field_find_dbref mongoengine/tests/queryset/queryset.py /^ def test_reference_field_find_dbref(self):$/;" m class:QuerySetTest +test_reference_inheritance mongoengine/tests/document/instance.py /^ def test_reference_inheritance(self):$/;" m class:InstanceTest +test_reference_miss mongoengine/tests/fields/fields.py /^ def test_reference_miss(self):$/;" m class:FieldTest +test_reference_miss tests/fields/fields.py /^ def test_reference_miss(self):$/;" m class:FieldTest +test_reference_query_conversion mongoengine/tests/fields/fields.py /^ def test_reference_query_conversion(self):$/;" m class:FieldTest +test_reference_query_conversion tests/fields/fields.py /^ def test_reference_query_conversion(self):$/;" m class:FieldTest +test_reference_query_conversion_dbref mongoengine/tests/fields/fields.py /^ def test_reference_query_conversion_dbref(self):$/;" m class:FieldTest +test_reference_query_conversion_dbref tests/fields/fields.py /^ def test_reference_query_conversion_dbref(self):$/;" m class:FieldTest +test_reference_validation mongoengine/tests/fields/fields.py /^ def test_reference_validation(self):$/;" m class:FieldTest +test_reference_validation tests/fields/fields.py /^ def test_reference_validation(self):$/;" m class:FieldTest +test_referenced_object_changed_attributes mongoengine/tests/document/delta.py /^ def test_referenced_object_changed_attributes(self):$/;" m class:DeltaTest +test_regex_query_shortcuts mongoengine/tests/queryset/queryset.py /^ def test_regex_query_shortcuts(self):$/;" m class:QuerySetTest +test_register_connection mongoengine/tests/test_connection.py /^ def test_register_connection(self):$/;" m class:ConnectionTest +test_register_connection_defaults mongoengine/tests/test_connection.py /^ def test_register_connection_defaults(self):$/;" m class:ConnectionTest +test_register_delete_rule mongoengine/tests/document/class_methods.py /^ def test_register_delete_rule(self):$/;" m class:ClassMethodsTest +test_register_delete_rule_inherited mongoengine/tests/document/class_methods.py /^ def test_register_delete_rule_inherited(self):$/;" m class:ClassMethodsTest +test_regular_document_pickle mongoengine/tests/document/instance.py /^ def test_regular_document_pickle(self):$/;" m class:InstanceTest +test_reload mongoengine/tests/document/instance.py /^ def test_reload(self):$/;" m class:InstanceTest +test_reload_after_unsetting mongoengine/tests/document/dynamic.py /^ def test_reload_after_unsetting(self):$/;" m class:DynamicTest +test_reload_doesnt_exist mongoengine/tests/document/instance.py /^ def test_reload_doesnt_exist(self):$/;" m class:InstanceTest +test_reload_dynamic_field mongoengine/tests/document/dynamic.py /^ def test_reload_dynamic_field(self):$/;" m class:DynamicTest +test_reload_embedded_docs_instance mongoengine/tests/queryset/queryset.py /^ def test_reload_embedded_docs_instance(self):$/;" m class:QuerySetTest +test_reload_list_embedded_docs_instance mongoengine/tests/queryset/queryset.py /^ def test_reload_list_embedded_docs_instance(self):$/;" m class:QuerySetTest +test_reload_of_non_strict_with_special_field_name mongoengine/tests/document/instance.py /^ def test_reload_of_non_strict_with_special_field_name(self):$/;" m class:InstanceTest +test_reload_referencing mongoengine/tests/document/instance.py /^ def test_reload_referencing(self):$/;" m class:InstanceTest +test_reload_sharded mongoengine/tests/document/instance.py /^ def test_reload_sharded(self):$/;" m class:InstanceTest +test_reload_sharded_nested mongoengine/tests/document/instance.py /^ def test_reload_sharded_nested(self):$/;" m class:InstanceTest +test_repeated_iteration mongoengine/tests/queryset/queryset.py /^ def test_repeated_iteration(self):$/;" m class:QuerySetTest +test_replicaset_uri_passes_read_preference mongoengine/tests/test_replicaset_connection.py /^ def test_replicaset_uri_passes_read_preference(self):$/;" m class:ConnectionTest +test_repr mongoengine/tests/document/instance.py /^ def test_repr(self):$/;" m class:InstanceTest +test_repr mongoengine/tests/queryset/queryset.py /^ def test_repr(self):$/;" m class:QuerySetTest +test_repr mongoengine/tests/test_datastructures.py /^ def test_repr(self):$/;" m class:TestStrictDict +test_repr_none mongoengine/tests/document/instance.py /^ def test_repr_none(self):$/;" m class:InstanceTest +test_required_values mongoengine/tests/fields/fields.py /^ def test_required_values(self):$/;" m class:FieldTest +test_required_values tests/fields/fields.py /^ def test_required_values(self):$/;" m class:FieldTest +test_reset mongoengine/tests/queryset/field_list.py /^ def test_reset(self):$/;" m class:QueryFieldListTest +test_reverse_delete_rule_cascade mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_cascade(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_cascade_and_nullify mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_cascade_and_nullify(self):$/;" m class:InstanceTest +test_reverse_delete_rule_cascade_and_nullify_complex_field mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_cascade_and_nullify_complex_field(self):$/;" m class:InstanceTest +test_reverse_delete_rule_cascade_complex_cycle mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_cascade_complex_cycle(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_cascade_cycle mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_cascade_cycle(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_cascade_on_abstract_document mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_cascade_on_abstract_document(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_cascade_recurs mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_cascade_recurs(self):$/;" m class:InstanceTest +test_reverse_delete_rule_cascade_self_referencing mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_cascade_self_referencing(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_cascade_triggers_pre_delete_signal mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_cascade_triggers_pre_delete_signal(self):$/;" m class:InstanceTest +test_reverse_delete_rule_deny mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_deny(self):$/;" m class:InstanceTest +test_reverse_delete_rule_deny mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_deny(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_deny_on_abstract_document mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_deny_on_abstract_document(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_nullify mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_nullify(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_nullify_on_abstract_document mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_nullify_on_abstract_document(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_pull mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_pull(self):$/;" m class:InstanceTest +test_reverse_delete_rule_pull mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_pull(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_pull_on_abstract_documents mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_pull_on_abstract_documents(self):$/;" m class:QuerySetTest +test_reverse_delete_rule_with_custom_id_field mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_with_custom_id_field(self):$/;" m class:InstanceTest +test_reverse_delete_rule_with_document_inheritance mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_with_document_inheritance(self):$/;" m class:InstanceTest +test_reverse_delete_rule_with_shared_id_among_collections mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_with_shared_id_among_collections(self):$/;" m class:InstanceTest +test_reverse_list_sorting mongoengine/tests/fields/fields.py /^ def test_reverse_list_sorting(self):$/;" m class:FieldTest +test_reverse_list_sorting tests/fields/fields.py /^ def test_reverse_list_sorting(self):$/;" m class:FieldTest +test_save mongoengine/tests/document/instance.py /^ def test_save(self):$/;" m class:InstanceTest +test_save mongoengine/tests/fields/fields.py /^ def test_save(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_save tests/fields/fields.py /^ def test_save(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_save_abstract_document mongoengine/tests/document/instance.py /^ def test_save_abstract_document(self):$/;" m class:InstanceTest +test_save_and_only_on_fields_with_default mongoengine/tests/queryset/queryset.py /^ def test_save_and_only_on_fields_with_default(self):$/;" m class:QuerySetTest +test_save_atomicity_condition mongoengine/tests/document/instance.py /^ def test_save_atomicity_condition(self):$/;" m class:InstanceTest +test_save_cascade_kwargs mongoengine/tests/document/instance.py /^ def test_save_cascade_kwargs(self):$/;" m class:InstanceTest +test_save_cascade_meta_false mongoengine/tests/document/instance.py /^ def test_save_cascade_meta_false(self):$/;" m class:InstanceTest +test_save_cascade_meta_true mongoengine/tests/document/instance.py /^ def test_save_cascade_meta_true(self):$/;" m class:InstanceTest +test_save_cascades mongoengine/tests/document/instance.py /^ def test_save_cascades(self):$/;" m class:InstanceTest +test_save_cascades_generically mongoengine/tests/document/instance.py /^ def test_save_cascades_generically(self):$/;" m class:InstanceTest +test_save_custom_id mongoengine/tests/document/instance.py /^ def test_save_custom_id(self):$/;" m class:InstanceTest +test_save_custom_pk mongoengine/tests/document/instance.py /^ def test_save_custom_pk(self):$/;" m class:InstanceTest +test_save_embedded_document mongoengine/tests/document/instance.py /^ def test_save_embedded_document(self):$/;" m class:InstanceTest +test_save_list mongoengine/tests/document/instance.py /^ def test_save_list(self):$/;" m class:InstanceTest +test_save_max_recursion_not_hit mongoengine/tests/document/instance.py /^ def test_save_max_recursion_not_hit(self):$/;" m class:InstanceTest +test_save_max_recursion_not_hit_with_file_field mongoengine/tests/document/instance.py /^ def test_save_max_recursion_not_hit_with_file_field(self):$/;" m class:InstanceTest +test_save_only_changed_fields mongoengine/tests/document/instance.py /^ def test_save_only_changed_fields(self):$/;" m class:InstanceTest +test_save_only_changed_fields_recursive mongoengine/tests/document/instance.py /^ def test_save_only_changed_fields_recursive(self):$/;" m class:InstanceTest +test_save_reference mongoengine/tests/document/instance.py /^ def test_save_reference(self):$/;" m class:InstanceTest +test_save_to_a_value_that_equates_to_false mongoengine/tests/document/instance.py /^ def test_save_to_a_value_that_equates_to_false(self):$/;" m class:InstanceTest +test_scalar mongoengine/tests/queryset/queryset.py /^ def test_scalar(self):$/;" m class:QuerySetTest +test_scalar_cursor_behaviour mongoengine/tests/queryset/queryset.py /^ def test_scalar_cursor_behaviour(self):$/;" m class:QuerySetTest +test_scalar_db_field mongoengine/tests/queryset/queryset.py /^ def test_scalar_db_field(self):$/;" m class:QuerySetTest +test_scalar_decimal mongoengine/tests/queryset/queryset.py /^ def test_scalar_decimal(self):$/;" m class:QuerySetTest +test_scalar_embedded mongoengine/tests/queryset/queryset.py /^ def test_scalar_embedded(self):$/;" m class:QuerySetTest +test_scalar_generic_reference_field mongoengine/tests/queryset/queryset.py /^ def test_scalar_generic_reference_field(self):$/;" m class:QuerySetTest +test_scalar_primary_key mongoengine/tests/queryset/queryset.py /^ def test_scalar_primary_key(self):$/;" m class:QuerySetTest +test_scalar_reference_field mongoengine/tests/queryset/queryset.py /^ def test_scalar_reference_field(self):$/;" m class:QuerySetTest +test_scalar_simple mongoengine/tests/queryset/queryset.py /^ def test_scalar_simple(self):$/;" m class:QuerySetTest +test_select_related_follows_embedded_referencefields mongoengine/tests/test_dereference.py /^ def test_select_related_follows_embedded_referencefields(self):$/;" m class:FieldTest +test_sequence_field mongoengine/tests/fields/fields.py /^ def test_sequence_field(self):$/;" m class:FieldTest +test_sequence_field tests/fields/fields.py /^ def test_sequence_field(self):$/;" m class:FieldTest +test_sequence_field_get_next_value mongoengine/tests/fields/fields.py /^ def test_sequence_field_get_next_value(self):$/;" m class:FieldTest +test_sequence_field_get_next_value tests/fields/fields.py /^ def test_sequence_field_get_next_value(self):$/;" m class:FieldTest +test_sequence_field_sequence_name mongoengine/tests/fields/fields.py /^ def test_sequence_field_sequence_name(self):$/;" m class:FieldTest +test_sequence_field_sequence_name tests/fields/fields.py /^ def test_sequence_field_sequence_name(self):$/;" m class:FieldTest +test_sequence_field_value_decorator mongoengine/tests/fields/fields.py /^ def test_sequence_field_value_decorator(self):$/;" m class:FieldTest +test_sequence_field_value_decorator tests/fields/fields.py /^ def test_sequence_field_value_decorator(self):$/;" m class:FieldTest +test_sequence_fields_reload mongoengine/tests/fields/fields.py /^ def test_sequence_fields_reload(self):$/;" m class:FieldTest +test_sequence_fields_reload tests/fields/fields.py /^ def test_sequence_fields_reload(self):$/;" m class:FieldTest +test_set_generic_embedded_documents mongoengine/tests/queryset/queryset.py /^ def test_set_generic_embedded_documents(self):$/;" m class:QuerySetTest +test_set_list_embedded_documents mongoengine/tests/queryset/queryset.py /^ def test_set_list_embedded_documents(self):$/;" m class:QuerySetTest +test_set_on_insert mongoengine/tests/queryset/queryset.py /^ def test_set_on_insert(self):$/;" m class:QuerySetTest +test_set_unset_one_operation mongoengine/tests/document/instance.py /^ def test_set_unset_one_operation(self):$/;" m class:InstanceTest +test_setattr_getattr mongoengine/tests/test_datastructures.py /^ def test_setattr_getattr(self):$/;" m class:TestStrictDict +test_setattr_getattr_special mongoengine/tests/test_datastructures.py /^ def test_setattr_getattr_special(self):$/;" m class:TestStrictDict +test_setattr_raises_on_nonexisting_attr mongoengine/tests/test_datastructures.py /^ def test_setattr_raises_on_nonexisting_attr(self):$/;" m class:TestStrictDict +test_shard_key mongoengine/tests/document/instance.py /^ def test_shard_key(self):$/;" m class:InstanceTest +test_shard_key_in_embedded_document mongoengine/tests/document/instance.py /^ def test_shard_key_in_embedded_document(self):$/;" m class:InstanceTest +test_shard_key_primary mongoengine/tests/document/instance.py /^ def test_shard_key_primary(self):$/;" m class:InstanceTest +test_sharing_connections mongoengine/tests/test_connection.py /^ def test_sharing_connections(self):$/;" m class:ConnectionTest +test_signal_kwargs mongoengine/tests/test_signals.py /^ def test_signal_kwargs(self):$/;" m class:SignalTests +test_signals_bulk_insert mongoengine/tests/test_signals.py /^ def test_signals_bulk_insert(self):$/;" m class:SignalTests +test_signals_with_explicit_doc_ids mongoengine/tests/test_signals.py /^ def test_signals_with_explicit_doc_ids(self):$/;" m class:SignalTests +test_signals_with_switch_collection mongoengine/tests/test_signals.py /^ def test_signals_with_switch_collection(self):$/;" m class:SignalTests +test_signals_with_switch_db mongoengine/tests/test_signals.py /^ def test_signals_with_switch_db(self):$/;" m class:SignalTests +test_simple_choices_get_field_display mongoengine/tests/fields/fields.py /^ def test_simple_choices_get_field_display(self):$/;" m class:FieldTest +test_simple_choices_get_field_display tests/fields/fields.py /^ def test_simple_choices_get_field_display(self):$/;" m class:FieldTest +test_simple_choices_validation mongoengine/tests/fields/fields.py /^ def test_simple_choices_validation(self):$/;" m class:FieldTest +test_simple_choices_validation tests/fields/fields.py /^ def test_simple_choices_validation(self):$/;" m class:FieldTest +test_simple_choices_validation_invalid_value mongoengine/tests/fields/fields.py /^ def test_simple_choices_validation_invalid_value(self):$/;" m class:FieldTest +test_simple_choices_validation_invalid_value tests/fields/fields.py /^ def test_simple_choices_validation_invalid_value(self):$/;" m class:FieldTest +test_simple_dynamic_document mongoengine/tests/document/dynamic.py /^ def test_simple_dynamic_document(self):$/;" m class:DynamicTest +test_single_keyword_exclude mongoengine/tests/fields/fields.py /^ def test_single_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_single_keyword_exclude tests/fields/fields.py /^ def test_single_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_single_keyword_filter mongoengine/tests/fields/fields.py /^ def test_single_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_single_keyword_filter tests/fields/fields.py /^ def test_single_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_single_keyword_get mongoengine/tests/fields/fields.py /^ def test_single_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_single_keyword_get tests/fields/fields.py /^ def test_single_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_single_keyword_update mongoengine/tests/fields/fields.py /^ def test_single_keyword_update(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_single_keyword_update tests/fields/fields.py /^ def test_single_keyword_update(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_skip mongoengine/tests/queryset/queryset.py /^ def test_skip(self):$/;" m class:QuerySetTest +test_slave_okay mongoengine/tests/queryset/queryset.py /^ def test_slave_okay(self):$/;" m class:QuerySetTest +test_slice mongoengine/tests/queryset/queryset.py /^ def test_slice(self):$/;" m class:QuerySetTest +test_slice_marks_field_as_changed mongoengine/tests/fields/fields.py /^ def test_slice_marks_field_as_changed(self):$/;" m class:FieldTest +test_slice_marks_field_as_changed tests/fields/fields.py /^ def test_slice_marks_field_as_changed(self):$/;" m class:FieldTest +test_slicing mongoengine/tests/queryset/field_list.py /^ def test_slicing(self):$/;" m class:OnlyExcludeAllTest +test_slicing_fields mongoengine/tests/queryset/field_list.py /^ def test_slicing_fields(self):$/;" m class:OnlyExcludeAllTest +test_slicing_nested_fields mongoengine/tests/queryset/field_list.py /^ def test_slicing_nested_fields(self):$/;" m class:OnlyExcludeAllTest +test_sorted_list_sorting mongoengine/tests/fields/fields.py /^ def test_sorted_list_sorting(self):$/;" m class:FieldTest +test_sorted_list_sorting tests/fields/fields.py /^ def test_sorted_list_sorting(self):$/;" m class:FieldTest +test_spaces_in_keys mongoengine/tests/document/instance.py /^ def test_spaces_in_keys(self):$/;" m class:InstanceTest +test_sparse_compound_indexes mongoengine/tests/document/indexes.py /^ def test_sparse_compound_indexes(self):$/;" m class:IndexesTest +test_sparse_field mongoengine/tests/fields/fields.py /^ def test_sparse_field(self):$/;" m class:FieldTest +test_sparse_field tests/fields/fields.py /^ def test_sparse_field(self):$/;" m class:FieldTest +test_spherical_geospatial_operators mongoengine/tests/queryset/geo.py /^ def test_spherical_geospatial_operators(self):$/;" m class:GeoQueriesTest +test_string_indexes mongoengine/tests/document/indexes.py /^ def test_string_indexes(self):$/;" m class:IndexesTest +test_string_validation mongoengine/tests/fields/fields.py /^ def test_string_validation(self):$/;" m class:FieldTest +test_string_validation tests/fields/fields.py /^ def test_string_validation(self):$/;" m class:FieldTest +test_subclass_field_query mongoengine/tests/queryset/queryset.py /^ def test_subclass_field_query(self):$/;" m class:QuerySetTest +test_subclasses mongoengine/tests/document/inheritance.py /^ def test_subclasses(self):$/;" m class:InheritanceTest +test_sum mongoengine/tests/queryset/queryset.py /^ def test_sum(self):$/;" m class:QuerySetTest +test_sum_over_db_field mongoengine/tests/queryset/queryset.py /^ def test_sum_over_db_field(self):$/;" m class:QuerySetTest +test_superclasses mongoengine/tests/document/inheritance.py /^ def test_superclasses(self):$/;" m class:InheritanceTest +test_switch_collection_context_manager mongoengine/tests/test_context_managers.py /^ def test_switch_collection_context_manager(self):$/;" m class:ContextManagersTest +test_switch_db_context_manager mongoengine/tests/test_context_managers.py /^ def test_switch_db_context_manager(self):$/;" m class:ContextManagersTest +test_switch_db_instance mongoengine/tests/document/instance.py /^ def test_switch_db_instance(self):$/;" m class:InstanceTest +test_text_indexes mongoengine/tests/document/indexes.py /^ def test_text_indexes(self):$/;" m class:IndexesTest +test_text_indexes mongoengine/tests/queryset/queryset.py /^ def test_text_indexes(self):$/;" m class:QuerySetTest +test_three_level_complex_data_lookups mongoengine/tests/document/dynamic.py /^ def test_three_level_complex_data_lookups(self):$/;" m class:DynamicTest +test_to_dbref mongoengine/tests/document/instance.py /^ def test_to_dbref(self):$/;" m class:InstanceTest +test_to_dict mongoengine/tests/document/validation.py /^ def test_to_dict(self):$/;" m class:ValidatorErrorTest +test_transform_query mongoengine/tests/queryset/transform.py /^ def test_transform_query(self):$/;" m class:TransformTest +test_transform_update mongoengine/tests/queryset/transform.py /^ def test_transform_update(self):$/;" m class:TransformTest +test_ttl_indexes mongoengine/tests/document/indexes.py /^ def test_ttl_indexes(self):$/;" m class:IndexesTest +test_tuples_as_tuples mongoengine/tests/fields/fields.py /^ def test_tuples_as_tuples(self):$/;" m class:FieldTest +test_tuples_as_tuples tests/fields/fields.py /^ def test_tuples_as_tuples(self):$/;" m class:FieldTest +test_two_way_reverse_delete_rule mongoengine/tests/document/instance.py /^ def test_two_way_reverse_delete_rule(self):$/;" m class:InstanceTest +test_type mongoengine/tests/queryset/transform.py /^ def test_type(self):$/;" m class:TransformTest +test_undefined_field_exception mongoengine/tests/fields/fields.py /^ def test_undefined_field_exception(self):$/;" m class:FieldTest +test_undefined_field_exception tests/fields/fields.py /^ def test_undefined_field_exception(self):$/;" m class:FieldTest +test_undefined_field_exception_with_strict mongoengine/tests/fields/fields.py /^ def test_undefined_field_exception_with_strict(self):$/;" m class:FieldTest +test_undefined_field_exception_with_strict tests/fields/fields.py /^ def test_undefined_field_exception_with_strict(self):$/;" m class:FieldTest +test_undefined_reference mongoengine/tests/fields/fields.py /^ def test_undefined_reference(self):$/;" m class:FieldTest +test_undefined_reference tests/fields/fields.py /^ def test_undefined_reference(self):$/;" m class:FieldTest +test_understandable_error_raised mongoengine/tests/queryset/transform.py /^ def test_understandable_error_raised(self):$/;" m class:TransformTest +test_unicode mongoengine/tests/fields/fields.py /^ def test_unicode(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_unicode tests/fields/fields.py /^ def test_unicode(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_unicode_url_validation mongoengine/tests/fields/fields.py /^ def test_unicode_url_validation(self):$/;" m class:FieldTest +test_unicode_url_validation tests/fields/fields.py /^ def test_unicode_url_validation(self):$/;" m class:FieldTest +test_unique mongoengine/tests/document/indexes.py /^ def test_unique(self):$/;" m class:IndexesTest +test_unique_and_indexes mongoengine/tests/document/indexes.py /^ def test_unique_and_indexes(self):$/;" m class:IndexesTest +test_unique_and_primary mongoengine/tests/document/indexes.py /^ def test_unique_and_primary(self):$/;" m class:IndexesTest +test_unique_and_primary_create mongoengine/tests/document/indexes.py /^ def test_unique_and_primary_create(self):$/;" m class:IndexesTest +test_unique_embedded_document mongoengine/tests/document/indexes.py /^ def test_unique_embedded_document(self):$/;" m class:IndexesTest +test_unique_embedded_document_in_list mongoengine/tests/document/indexes.py /^ def test_unique_embedded_document_in_list(self):$/;" m class:IndexesTest +test_unique_with mongoengine/tests/document/indexes.py /^ def test_unique_with(self):$/;" m class:IndexesTest +test_unique_with_embedded_document_and_embedded_unique mongoengine/tests/document/indexes.py /^ def test_unique_with_embedded_document_and_embedded_unique(self):$/;" m class:IndexesTest +test_unknown_keyword_exclude mongoengine/tests/fields/fields.py /^ def test_unknown_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_unknown_keyword_exclude tests/fields/fields.py /^ def test_unknown_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_unknown_keyword_filter mongoengine/tests/fields/fields.py /^ def test_unknown_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_unknown_keyword_filter tests/fields/fields.py /^ def test_unknown_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_unknown_keyword_get mongoengine/tests/fields/fields.py /^ def test_unknown_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_unknown_keyword_get tests/fields/fields.py /^ def test_unknown_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase +test_unpickle mongoengine/tests/queryset/pickable.py /^ def test_unpickle(self):$/;" m class:TestQuerysetPickable +test_unset_reference mongoengine/tests/queryset/queryset.py /^ def test_unset_reference(self):$/;" m class:QuerySetTest +test_update mongoengine/tests/document/instance.py /^ def test_update(self):$/;" m class:InstanceTest +test_update mongoengine/tests/queryset/queryset.py /^ def test_update(self):$/;" m class:QuerySetTest +test_update_array_position mongoengine/tests/queryset/queryset.py /^ def test_update_array_position(self):$/;" m class:QuerySetTest +test_update_list_field mongoengine/tests/document/instance.py /^ def test_update_list_field(self):$/;" m class:InstanceTest +test_update_min_max mongoengine/tests/queryset/queryset.py /^ def test_update_min_max(self):$/;" m class:QuerySetTest +test_update_one_pop_generic_reference mongoengine/tests/queryset/queryset.py /^ def test_update_one_pop_generic_reference(self):$/;" m class:QuerySetTest +test_update_push_and_pull_add_to_set mongoengine/tests/queryset/queryset.py /^ def test_update_push_and_pull_add_to_set(self):$/;" m class:QuerySetTest +test_update_push_list_of_list mongoengine/tests/queryset/queryset.py /^ def test_update_push_list_of_list(self):$/;" m class:QuerySetTest +test_update_push_with_position mongoengine/tests/queryset/queryset.py /^ def test_update_push_with_position(self):$/;" m class:QuerySetTest +test_update_related_models mongoengine/tests/queryset/queryset.py /^ def test_update_related_models(self):$/;" m class:QuerySetTest +test_update_rename_operator mongoengine/tests/document/instance.py /^ def test_update_rename_operator(self):$/;" m class:InstanceTest +test_update_results mongoengine/tests/queryset/queryset.py /^ def test_update_results(self):$/;" m class:QuerySetTest +test_update_unique_field mongoengine/tests/document/instance.py /^ def test_update_unique_field(self):$/;" m class:InstanceTest +test_update_update_has_a_value mongoengine/tests/queryset/queryset.py /^ def test_update_update_has_a_value(self):$/;" m class:QuerySetTest +test_update_upsert_looks_like_a_digit mongoengine/tests/queryset/queryset.py /^ def test_update_upsert_looks_like_a_digit(self):$/;" m class:QuerySetTest +test_update_using_positional_operator mongoengine/tests/queryset/queryset.py /^ def test_update_using_positional_operator(self):$/;" m class:QuerySetTest +test_update_using_positional_operator_embedded_document mongoengine/tests/queryset/queryset.py /^ def test_update_using_positional_operator_embedded_document(self):$/;" m class:QuerySetTest +test_update_using_positional_operator_matches_first mongoengine/tests/queryset/queryset.py /^ def test_update_using_positional_operator_matches_first(self):$/;" m class:QuerySetTest +test_update_validate mongoengine/tests/queryset/queryset.py /^ def test_update_validate(self):$/;" m class:QuerySetTest +test_update_value_conversion mongoengine/tests/queryset/queryset.py /^ def test_update_value_conversion(self):$/;" m class:QuerySetTest +test_update_write_concern mongoengine/tests/queryset/queryset.py /^ def test_update_write_concern(self):$/;" m class:QuerySetTest +test_updates_can_have_match_operators mongoengine/tests/queryset/queryset.py /^ def test_updates_can_have_match_operators(self):$/;" m class:QuerySetTest +test_updating_an_embedded_document mongoengine/tests/document/instance.py /^ def test_updating_an_embedded_document(self):$/;" m class:InstanceTest +test_upper_level_mark_as_changed mongoengine/tests/document/delta.py /^ def test_upper_level_mark_as_changed(self):$/;" m class:DeltaTest +test_upsert mongoengine/tests/queryset/queryset.py /^ def test_upsert(self):$/;" m class:QuerySetTest +test_upsert_includes_cls mongoengine/tests/queryset/queryset.py /^ def test_upsert_includes_cls(self):$/;" m class:QuerySetTest +test_upsert_one mongoengine/tests/queryset/queryset.py /^ def test_upsert_one(self):$/;" m class:QuerySetTest +test_uri_without_credentials_doesnt_override_conn_settings mongoengine/tests/test_connection.py /^ def test_uri_without_credentials_doesnt_override_conn_settings(self):$/;" m class:ConnectionTest +test_url_scheme_validation mongoengine/tests/fields/fields.py /^ def test_url_scheme_validation(self):$/;" m class:FieldTest +test_url_scheme_validation tests/fields/fields.py /^ def test_url_scheme_validation(self):$/;" m class:FieldTest +test_url_validation mongoengine/tests/fields/fields.py /^ def test_url_validation(self):$/;" m class:FieldTest +test_url_validation tests/fields/fields.py /^ def test_url_validation(self):$/;" m class:FieldTest +test_using mongoengine/tests/queryset/queryset.py /^ def test_using(self):$/;" m class:QuerySetTest +test_using_a_slice mongoengine/tests/queryset/field_list.py /^ def test_using_a_slice(self):$/;" m class:QueryFieldListTest +test_uuid_field_binary mongoengine/tests/fields/fields.py /^ def test_uuid_field_binary(self):$/;" m class:FieldTest +test_uuid_field_binary tests/fields/fields.py /^ def test_uuid_field_binary(self):$/;" m class:FieldTest +test_uuid_field_string mongoengine/tests/fields/fields.py /^ def test_uuid_field_string(self):$/;" m class:FieldTest +test_uuid_field_string tests/fields/fields.py /^ def test_uuid_field_string(self):$/;" m class:FieldTest +test_where mongoengine/tests/queryset/queryset.py /^ def test_where(self):$/;" m class:QuerySetTest +test_within_box mongoengine/tests/queryset/geo.py /^ def test_within_box(self):$/;" m class:GeoQueriesTest +test_within_distance mongoengine/tests/queryset/geo.py /^ def test_within_distance(self):$/;" m class:GeoQueriesTest +test_within_polygon mongoengine/tests/queryset/geo.py /^ def test_within_polygon(self):$/;" m class:GeoQueriesTest +test_write_concern mongoengine/tests/test_connection.py /^ def test_write_concern(self):$/;" m class:ConnectionTest +testdict mongoengine/tests/queryset/queryset.py /^ testdict = DictField()$/;" v class:QuerySetTest.test_dict_with_custom_baseclass.Test +testdict mongoengine/tests/queryset/queryset.py /^ testdict = DictField(basecls=StringField)$/;" v class:QuerySetTest.test_dict_with_custom_baseclass.Test +text mongoengine/tests/document/indexes.py /^ text = StringField()$/;" v class:IndexesTest.test_compound_key_dictfield.ReportDictField +text mongoengine/tests/document/indexes.py /^ text = StringField()$/;" v class:IndexesTest.test_compound_key_embedded.ReportEmbedded +text mongoengine/tests/document/instance.py /^ text = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_recurs.Comment +text mongoengine/tests/fields/fields.py /^ text = StringField()$/;" v class:FieldTest.test_list_field_passed_in_value.Bar +text mongoengine/tests/queryset/field_list.py /^ text = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude.Comment +text mongoengine/tests/queryset/field_list.py /^ text = StringField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.Comment +text mongoengine/tests/queryset/queryset.py /^ text = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_ReferenceField.Bar +text mongoengine/tests/queryset/queryset.py /^ text = StringField()$/;" v class:QuerySetTest.test_distinct_handles_references.Bar +text mongoengine/tests/queryset/queryset.py /^ text = StringField()$/;" v class:QuerySetTest.test_distinct_handles_references_to_alias.Bar +text mongoengine/tests/queryset/queryset.py /^ text = StringField()$/;" v class:QuerySetTest.test_unset_reference.Comment +text mongoengine/tests/test_dereference.py /^ text = StringField()$/;" v class:FieldTest.test_list_lookup_not_checked_in_map.Comment +text tests/fields/fields.py /^ text = StringField()$/;" v class:FieldTest.test_list_field_passed_in_value.Bar +text_info mongoengine/tests/fields/fields.py /^ text_info = ListField(StringField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost +text_info tests/fields/fields.py /^ text_info = ListField(StringField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost +the_date mongoengine/tests/test_connection.py /^ the_date = DateTimeField(required=True)$/;" v class:ConnectionTest.test_datetime.DateDoc +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_copyable.PutFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_boolean.TestFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_cmp.TestFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_disk_space.TestFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_field_no_default.GridDocument +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_field_optional.DemoFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_fields.PutFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_fields_set.SetFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_fields_stream.StreamFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_fields_stream_after_none.StreamFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_reassigning.TestFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_uniqueness.TestFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField(db_alias="test_files",$/;" v class:FileTest.test_file_multidb.TestFile +the_file mongoengine/tests/fields/file_tests.py /^ the_file = ImageField()$/;" v class:FileTest.test_image_field_reassigning.TestFile +thick mongoengine/tests/queryset/queryset.py /^ thick = BooleanField()$/;" v class:QuerySetTest.test_elem_match.Foo +thing mongoengine/tests/document/instance.py /^ thing = EmbeddedDocumentField(Thing)$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document.User +thing mongoengine/tests/document/instance.py /^ thing = EmbeddedDocumentField(Thing)$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false.User +thing mongoengine/tests/document/instance.py /^ thing = EmbeddedDocumentField(Thing)$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc.User +thing mongoengine/tests/document/instance.py /^ thing = EmbeddedDocumentField(Thing)$/;" v class:InstanceTest.test_save_to_a_value_that_equates_to_false.User +thing mongoengine/tests/fields/fields.py /^ thing = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Ocurrence +thing tests/fields/fields.py /^ thing = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Ocurrence +thumbnail mongoengine/fields.py /^ def thumbnail(self):$/;" m class:ImageGridFsProxy +thumbnail mongoengine/mongoengine/fields.py /^ def thumbnail(self):$/;" m class:ImageGridFsProxy +time mongoengine/tests/fields/fields.py /^ time = DateTimeField()$/;" v class:FieldTest.test_datetime_tz_aware_mark_as_changed.LogEntry +time mongoengine/tests/fields/fields.py /^ time = DateTimeField()$/;" v class:FieldTest.test_datetime_validation.LogEntry +time tests/fields/fields.py /^ time = DateTimeField()$/;" v class:FieldTest.test_datetime_tz_aware_mark_as_changed.LogEntry +time tests/fields/fields.py /^ time = DateTimeField()$/;" v class:FieldTest.test_datetime_validation.LogEntry +timeout mongoengine/mongoengine/queryset/base.py /^ def timeout(self, enabled):$/;" m class:BaseQuerySet +title mongoengine/docs/code/tumblelog.py /^ title = StringField(max_length=120, required=True)$/;" v class:Post +title mongoengine/tests/document/class_methods.py /^ title = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes.BlogPost +title mongoengine/tests/document/class_methods.py /^ title = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPost +title mongoengine/tests/document/class_methods.py /^ title = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPost +title mongoengine/tests/document/class_methods.py /^ title = StringField()$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPost +title mongoengine/tests/document/indexes.py /^ title = DictField()$/;" v class:IndexesTest.test_text_indexes.Book +title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest._index_test_inheritance.ExtendedBlogPost +title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_embedded_document_index.BlogPost +title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_index_no_cls.A +title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_indexes_after_database_drop.BlogPost +title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_inherited_index.A +title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_list_embedded_document_index.BlogPost +title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_unique.BlogPost +title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_unique_embedded_document.BlogPost +title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_unique_embedded_document_in_list.BlogPost +title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_unique_with.BlogPost +title mongoengine/tests/document/indexes.py /^ title = StringField(required=True)$/;" v class:IndexesTest.test_embedded_document_index_meta.Rank +title mongoengine/tests/document/indexes.py /^ title = StringField(required=True)$/;" v class:IndexesTest.test_index_on_id.BlogPost +title mongoengine/tests/document/indexes.py /^ title = StringField(unique_with='sub.year')$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost +title mongoengine/tests/document/instance.py /^ title = StringField()$/;" v class:InstanceTest.test_reload_of_non_strict_with_special_field_name.Post +title mongoengine/tests/document/instance.py /^ title = StringField()$/;" v class:InstanceTest.test_repr.Article +title mongoengine/tests/document/instance.py /^ title = StringField()$/;" v class:InstanceTest.test_repr_none.Article +title mongoengine/tests/document/instance.py /^ title = StringField(required=True)$/;" v class:InstanceTest.test_db_embedded_doc_field_load.Rank +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference.Link +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference.Post +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices.Link +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices.Post +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Post +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_document_not_registered.Link +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list.Link +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list.Post +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_choices.Link +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_choices.Post +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_item_modification.Post +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_string_choices.Link +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_string_choices.Post +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_reference_query_conversion.BlogPost +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_reference_query_conversion_dbref.BlogPost +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.BlogPost +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.BlogPost +title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.BlogPost +title mongoengine/tests/fields/fields.py /^ title = StringField(required=True)$/;" v class:FieldTest.test_embedded_sequence_field.Post +title mongoengine/tests/fields/fields.py /^ title = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Post +title mongoengine/tests/fields/geo.py /^ title = StringField()$/;" v class:GeoFieldTest.test_geopoint_embedded_indexes.Event +title mongoengine/tests/fields/geo.py /^ title = StringField()$/;" v class:GeoFieldTest.test_indexes_2dsphere.Event +title mongoengine/tests/fields/geo.py /^ title = StringField()$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Event +title mongoengine/tests/fields/geo.py /^ title = StringField()$/;" v class:GeoFieldTest.test_indexes_geopoint.Event +title mongoengine/tests/queryset/field_list.py /^ title = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude.Comment +title mongoengine/tests/queryset/field_list.py /^ title = StringField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.Comment +title mongoengine/tests/queryset/geo.py /^ title = StringField()$/;" v class:GeoQueriesTest._create_event_data.Event +title mongoengine/tests/queryset/geo.py /^ title = StringField()$/;" v class:GeoQueriesTest._test_embedded.Event +title mongoengine/tests/queryset/geo.py /^ title="Coltrane Motion @ Bottom of the Hill",$/;" v class:GeoQueriesTest._create_event_data.Event +title mongoengine/tests/queryset/geo.py /^ title="Coltrane Motion @ Double Door",$/;" v class:GeoQueriesTest._create_event_data.Event +title mongoengine/tests/queryset/geo.py /^ title="Coltrane Motion @ Empty Bottle",$/;" v class:GeoQueriesTest._create_event_data.Event +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_bulk.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_call_after_limits_set.Post +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_clear_ordering.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_count_limit_and_skip.Post +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField.Book +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Book +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_map_reduce.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_no_ordering_for_get.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_order_by_list.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_order_by_optional.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_ordering.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_set_list_embedded_documents.Message +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_text_indexes.News +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_update.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_update_using_positional_operator.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField(db_field='bpTitle')$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +title mongoengine/tests/queryset/queryset.py /^ title = StringField(primary_key=True)$/;" v class:QuerySetTest.test_map_reduce_with_custom_object_ids.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title = StringField(required=True)$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Post +title mongoengine/tests/queryset/queryset.py /^ title = StringField(unique=True)$/;" v class:QuerySetTest.test_bulk_insert.Blog +title mongoengine/tests/queryset/queryset.py /^ title="A",$/;" v class:QuerySetTest.test_order_by_list.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="B",$/;" v class:QuerySetTest.test_order_by_list.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #1",$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #1",$/;" v class:QuerySetTest.test_order_by_optional.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #1",$/;" v class:QuerySetTest.test_ordering.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #2",$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #2",$/;" v class:QuerySetTest.test_order_by_optional.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #2",$/;" v class:QuerySetTest.test_ordering.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #3",$/;" v class:QuerySetTest.test_filter_chaining.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #3",$/;" v class:QuerySetTest.test_order_by_optional.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #3",$/;" v class:QuerySetTest.test_ordering.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #4",$/;" v class:QuerySetTest.test_order_by_optional.BlogPost +title mongoengine/tests/queryset/queryset.py /^ title="C",$/;" v class:QuerySetTest.test_order_by_list.BlogPost +title mongoengine/tests/queryset/transform.py /^ title = StringField()$/;" v class:TransformTest.test_understandable_error_raised.Event +title mongoengine/tests/queryset/transform.py /^ title = StringField(db_field='postTitle')$/;" v class:TransformTest.test_query_field_name.BlogPost +title mongoengine/tests/queryset/transform.py /^ title = StringField(primary_key=True, db_field='postTitle')$/;" v class:TransformTest.test_query_pk_field_name.BlogPost +title mongoengine/tests/queryset/visitor.py /^ title = StringField()$/;" v class:QTest.test_q.BlogPost +title mongoengine/tests/queryset/visitor.py /^ title = StringField(max_length=40)$/;" v class:QTest.test_multiple_occurence_in_field.Test +title mongoengine/tests/test_dereference.py /^ title = StringField()$/;" v class:FieldTest.test_multidirectional_lists.Asset +title mongoengine/tests/test_dereference.py /^ title = StringField()$/;" v class:FieldTest.test_select_related_follows_embedded_referencefields.Song +title mongoengine/tests/test_dereference.py /^ title = StringField(max_length=255, primary_key=True)$/;" v class:FieldTest.test_non_ascii_pk.Brand +title mongoengine/tests/test_dereference.py /^ title = StringField(max_length=255, primary_key=True)$/;" v class:FieldTest.test_non_ascii_pk.BrandGroup +title mongoengine/tests/test_signals.py /^ title = StringField()$/;" v class:SignalTests.setUp.Post +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference.Link +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference.Post +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices.Link +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices.Post +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Post +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_document_not_registered.Link +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list.Link +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list.Post +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_choices.Link +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_choices.Post +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_item_modification.Post +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_string_choices.Link +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_string_choices.Post +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_reference_query_conversion.BlogPost +title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_reference_query_conversion_dbref.BlogPost +title tests/fields/fields.py /^ title = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.BlogPost +title tests/fields/fields.py /^ title = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.BlogPost +title tests/fields/fields.py /^ title = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.BlogPost +title tests/fields/fields.py /^ title = StringField(required=True)$/;" v class:FieldTest.test_embedded_sequence_field.Post +title tests/fields/fields.py /^ title = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Post +to mongoengine/tests/queryset/field_list.py /^ to = StringField()$/;" v class:OnlyExcludeAllTest.test_all_fields.Email +to mongoengine/tests/queryset/field_list.py /^ to = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email +to_dbref mongoengine/mongoengine/document.py /^ def to_dbref(self):$/;" m class:Document +to_dict mongoengine/mongoengine/errors.py /^ def to_dict(self):$/;" m class:ValidationError +to_json mongoengine/mongoengine/base/document.py /^ def to_json(self, *args, **kwargs):$/;" m class:BaseDocument +to_json mongoengine/mongoengine/queryset/base.py /^ def to_json(self, *args, **kwargs):$/;" m class:BaseQuerySet +to_mongo mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:GenericLazyReferenceField +to_mongo mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:GenericReferenceField +to_mongo mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:ReferenceField +to_mongo mongoengine/fields.py /^ def to_mongo(self, document, use_db_field=True, fields=None):$/;" m class:CachedReferenceField +to_mongo mongoengine/fields.py /^ def to_mongo(self, document, use_db_field=True, fields=None):$/;" m class:GenericEmbeddedDocumentField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:BinaryField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:ComplexDateTimeField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:DateTimeField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:DecimalField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:FileField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:LazyReferenceField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:LongField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:UUIDField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:DynamicField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:EmbeddedDocumentField +to_mongo mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:SortedListField +to_mongo mongoengine/mongoengine/base/document.py /^ def to_mongo(self, use_db_field=True, fields=None):$/;" m class:BaseDocument +to_mongo mongoengine/mongoengine/base/fields.py /^ def to_mongo(self, value):$/;" m class:BaseField +to_mongo mongoengine/mongoengine/base/fields.py /^ def to_mongo(self, value):$/;" m class:GeoJsonBaseField +to_mongo mongoengine/mongoengine/base/fields.py /^ def to_mongo(self, value):$/;" m class:ObjectIdField +to_mongo mongoengine/mongoengine/base/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:ComplexBaseField +to_mongo mongoengine/mongoengine/document.py /^ def to_mongo(self, *args, **kwargs):$/;" m class:Document +to_mongo mongoengine/mongoengine/document.py /^ def to_mongo(self, *args, **kwargs):$/;" m class:EmbeddedDocument +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:GenericLazyReferenceField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:GenericReferenceField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:ReferenceField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, document, use_db_field=True, fields=None):$/;" m class:CachedReferenceField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, document, use_db_field=True, fields=None):$/;" m class:GenericEmbeddedDocumentField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:BinaryField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:ComplexDateTimeField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:DateTimeField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:DecimalField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:FileField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:LazyReferenceField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:LongField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:UUIDField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:DynamicField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:EmbeddedDocumentField +to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:SortedListField +to_mongo mongoengine/tests/fields/fields.py /^ def to_mongo(self, value):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField +to_mongo tests/fields/fields.py /^ def to_mongo(self, value):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:BooleanField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:CachedReferenceField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:ComplexDateTimeField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:DecimalField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:DynamicField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:EmbeddedDocumentField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:FileField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:FloatField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:GenericEmbeddedDocumentField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:IntField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:LongField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:ReferenceField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:SequenceField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:StringField +to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:UUIDField +to_python mongoengine/mongoengine/base/fields.py /^ def to_python(self, value):$/;" m class:BaseField +to_python mongoengine/mongoengine/base/fields.py /^ def to_python(self, value):$/;" m class:ComplexBaseField +to_python mongoengine/mongoengine/base/fields.py /^ def to_python(self, value):$/;" m class:ObjectIdField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:BooleanField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:CachedReferenceField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:ComplexDateTimeField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:DecimalField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:DynamicField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:EmbeddedDocumentField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:FileField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:FloatField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:GenericEmbeddedDocumentField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:IntField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:LongField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:ReferenceField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:SequenceField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:StringField +to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:UUIDField +to_python mongoengine/tests/fields/fields.py /^ def to_python(self, value):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField +to_python tests/fields/fields.py /^ def to_python(self, value):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField +to_query mongoengine/mongoengine/queryset/visitor.py /^ def to_query(self, document):$/;" m class:QNode +toggle mongoengine/tests/document/instance.py /^ toggle = BooleanField(default=False)$/;" v class:InstanceTest.test_save_atomicity_condition.Widget +topic mongoengine/tests/test_dereference.py /^ topic = ReferenceField(Topic)$/;" v class:FieldTest.test_document_reload_reference_integrity.Message +tp mongoengine/tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person +tp mongoengine/tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone +tp mongoengine/tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +tp mongoengine/tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person +tp tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person +tp tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone +tp tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +tp tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person +txt mongoengine/tests/document/indexes.py /^ txt = StringField()$/;" v class:IndexesTest.test_index_dont_send_cls_option.TestDoc +txt mongoengine/tests/fields/fields.py /^ txt = StringField()$/;" v class:FieldTest.test_double_embedded_db_field.C +txt mongoengine/tests/fields/fields.py /^ txt = StringField()$/;" v class:FieldTest.test_double_embedded_db_field_from_son.C +txt mongoengine/tests/queryset/queryset.py /^ txt = StringField()$/;" v class:QuerySetTest.test_read_preference.Bar +txt tests/fields/fields.py /^ txt = StringField()$/;" v class:FieldTest.test_double_embedded_db_field.C +txt tests/fields/fields.py /^ txt = StringField()$/;" v class:FieldTest.test_double_embedded_db_field_from_son.C +txt2 mongoengine/tests/document/indexes.py /^ txt2 = StringField()$/;" v class:IndexesTest.test_index_dont_send_cls_option.TestChildDoc +txt_1 mongoengine/tests/document/indexes.py /^ txt_1 = StringField()$/;" v class:IndexesTest.test_compound_index_underscore_cls_not_overwritten.TestDoc +type mongoengine/tests/document/delta.py /^ type = StringField()$/;" v class:DeltaTest.test_delta_for_nested_map_fields.EmbeddedRole +type mongoengine/tests/queryset/transform.py /^ type = StringField()$/;" v class:TransformTest.test_last_field_name_like_operator.EmbeddedItem +unhelpful mongoengine/tests/queryset/queryset.py /^ unhelpful = ListField(EmbeddedDocumentField(User))$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Collaborator +up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=1079,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=1446,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=215,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=48,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=481,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=74,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +up_votes mongoengine/tests/queryset/queryset.py /^ up_votes = IntField()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link +update mongoengine/mongoengine/base/datastructures.py /^ def update(self, **update):$/;" m class:EmbeddedDocumentList +update mongoengine/mongoengine/base/datastructures.py /^ def update(self, *args, **kwargs):$/;" m class:BaseDict +update mongoengine/mongoengine/document.py /^ def update(self, **kwargs):$/;" m class:Document +update mongoengine/mongoengine/queryset/base.py /^ def update(self, upsert=False, multi=True, write_concern=None,$/;" m class:BaseQuerySet +update mongoengine/mongoengine/queryset/transform.py /^def update(_doc_cls=None, **update):$/;" f +update mongoengine/tests/queryset/transform.py /^ update = transform.update(DicDoc, **{"%s__dictField__test" % k: doc})$/;" v class:TransformTest.test_transform_update.Doc +update_one mongoengine/mongoengine/queryset/base.py /^ def update_one(self, upsert=False, write_concern=None, **update):$/;" m class:BaseQuerySet +upsert_one mongoengine/mongoengine/queryset/base.py /^ def upsert_one(self, write_concern=None, **update):$/;" m class:BaseQuerySet +url mongoengine/tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_unicode_url_validation.Link +url mongoengine/tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_url_scheme_validation.Link +url mongoengine/tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_url_validation.Link +url mongoengine/tests/fields/fields.py /^ url = URLField(schemes=['ws', 'irc'])$/;" v class:FieldTest.test_url_scheme_validation.SchemeLink +url tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_unicode_url_validation.Link +url tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_url_scheme_validation.Link +url tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_url_validation.Link +url tests/fields/fields.py /^ url = URLField(schemes=['ws', 'irc'])$/;" v class:FieldTest.test_url_scheme_validation.SchemeLink +url_field mongoengine/tests/document/instance.py /^ url_field = URLField(default="http:\/\/mongoengine.org")$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +url_field mongoengine/tests/document/json_serialisation.py /^ url_field = URLField(default="http:\/\/mongoengine.org")$/;" v class:TestJson.test_json_complex.Doc +url_field mongoengine/tests/queryset/queryset.py /^ url_field = URLField(default="http:\/\/mongoengine.org")$/;" v class:QuerySetTest.test_json_complex.Doc +use_db_field mongoengine/tests/document/instance.py /^ use_db_field=False).to_dict()$/;" v class:InstanceTest.test_embedded_document_complex_instance_no_use_db_field.Doc +user mongoengine/tests/document/instance.py /^ user = ReferenceField(User)$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription +user mongoengine/tests/document/instance.py /^ user = ReferenceField(User,$/;" v class:InstanceTest.test_list_search_by_embedded.Comment +user mongoengine/tests/document/instance.py /^ user = User.objects.first()$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription +user mongoengine/tests/queryset/queryset.py /^ user = ReferenceField(User)$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Member +user mongoengine/tests/queryset/queryset.py /^ user = StringField()$/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Collaborator +user mongoengine/tests/queryset/queryset.py /^ user = StringField()$/;" v class:QuerySetTest.test_pull_nested.Collaborator +user mongoengine/tests/test_dereference.py /^ user = User(name='user %s' % i)$/;" v class:FieldTest.test_handle_old_style_references.Group +user mongoengine/tests/test_dereference.py /^ user = User(name='user %s' % i)$/;" v class:FieldTest.test_list_item_dereference.Group +user mongoengine/tests/test_dereference.py /^ user = User(name='user %s' % i)$/;" v class:FieldTest.test_list_item_dereference_dref_false.Group +user mongoengine/tests/test_dereference.py /^ user = User(name='user %s' % i)$/;" v class:FieldTest.test_map_field_reference.Group +user_guid mongoengine/tests/document/indexes.py /^ user_guid = StringField(required=True)$/;" v class:IndexesTest.test_abstract_index_inheritance.UserBase +user_guid mongoengine/tests/document/indexes.py /^ user_guid = StringField(required=True)$/;" v class:IndexesTest.test_disable_index_creation.User +user_lists mongoengine/tests/test_dereference.py /^ user_lists = ListField(ListField(ReferenceField(User)))$/;" v class:FieldTest.test_list_of_lists_of_references.Post +user_num mongoengine/tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:FieldTest.test_reference_query_conversion.Member +user_num mongoengine/tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:FieldTest.test_reference_query_conversion_dbref.Member +user_num mongoengine/tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.Member +user_num mongoengine/tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.Member +user_num mongoengine/tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.Member +user_num tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:FieldTest.test_reference_query_conversion.Member +user_num tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:FieldTest.test_reference_query_conversion_dbref.Member +user_num tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.Member +user_num tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.Member +user_num tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.Member +userid mongoengine/tests/fields/fields.py /^ userid = StringField()$/;" v class:FieldTest.test_required_values.Person +userid mongoengine/tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_nothing_set.Person +userid mongoengine/tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_set_to_None.Person +userid mongoengine/tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person +userid mongoengine/tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person +userid mongoengine/tests/fields/fields.py /^ userid = StringField(r'[0-9a-z_]+$')$/;" v class:FieldTest.test_string_validation.Person +userid tests/fields/fields.py /^ userid = StringField()$/;" v class:FieldTest.test_required_values.Person +userid tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_nothing_set.Person +userid tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_set_to_None.Person +userid tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person +userid tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person +userid tests/fields/fields.py /^ userid = StringField(r'[0-9a-z_]+$')$/;" v class:FieldTest.test_string_validation.Person +username mongoengine/tests/document/instance.py /^ username = StringField(primary_key=True)$/;" v class:InstanceTest.test_custom_id_field.User +username mongoengine/tests/document/instance.py /^ username = StringField(required=True)$/;" v class:InstanceTest.test_list_search_by_embedded.User +username mongoengine/tests/document/validation.py /^ username = StringField(primary_key=True)$/;" v class:ValidatorErrorTest.test_model_validation.User +username mongoengine/tests/fields/fields.py /^ username = StringField()$/;" v class:FieldTest.test_generic_reference_list_item_modification.User +username mongoengine/tests/queryset/field_list.py /^ username = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_from_subclasses_docs.Base +username mongoengine/tests/queryset/queryset.py /^ username = StringField()$/;" v class:QuerySetTest.test_set_generic_embedded_documents.User +username tests/fields/fields.py /^ username = StringField()$/;" v class:FieldTest.test_generic_reference_list_item_modification.User +users mongoengine/tests/document/delta.py /^ users = MapField(field=EmbeddedDocumentField(EmbeddedUser))$/;" v class:DeltaTest.test_delta_for_nested_map_fields.Doc +users mongoengine/tests/test_dereference.py /^ users = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_of_lists_of_references.SimpleList +using mongoengine/mongoengine/queryset/base.py /^ def using(self, alias):$/;" m class:BaseQuerySet +uuid_field mongoengine/tests/document/instance.py /^ uuid_field = UUIDField(default=uuid.uuid4)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc +uuid_field mongoengine/tests/document/json_serialisation.py /^ uuid_field = UUIDField(default=uuid.uuid4)$/;" v class:TestJson.test_json_complex.Doc +uuid_field mongoengine/tests/queryset/queryset.py /^ uuid_field = UUIDField(default=uuid.uuid4)$/;" v class:QuerySetTest.test_json_complex.Doc +v mongoengine/tests/document/instance.py /^ v = StringField()$/;" v class:InstanceTest.test_list_iter.B +vaccine_made mongoengine/tests/document/class_methods.py /^ vaccine_made = ListField(ReferenceField("Vaccine", reverse_delete_rule=PULL))$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Animal +val mongoengine/tests/document/validation.py /^ val = IntField(required=True)$/;" v class:ValidatorErrorTest.test_embedded_db_field_validate.SubDoc +val mongoengine/tests/document/validation.py /^ val = IntField(required=True)$/;" v class:ValidatorErrorTest.test_embedded_weakref.SubDoc +val mongoengine/tests/queryset/queryset.py /^ val = BooleanField()$/;" v class:QuerySetTest.test_item_frequencies_with_False_values.Test +val mongoengine/tests/queryset/queryset.py /^ val = IntField()$/;" v class:QuerySetTest.test_item_frequencies_normalize.Test +val mongoengine/tests/queryset/queryset.py /^ val = IntField()$/;" v class:QuerySetTest.test_item_frequencies_with_0_values.Test +val mongoengine/tests/queryset/queryset.py /^ val = IntField()$/;" v class:QuerySetTest.test_reload_embedded_docs_instance.SubDoc +val mongoengine/tests/queryset/queryset.py /^ val = IntField()$/;" v class:QuerySetTest.test_reload_list_embedded_docs_instance.SubDoc +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:BinaryField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:BooleanField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:CachedReferenceField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:ComplexDateTimeField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:DateTimeField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:DecimalField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:DictField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:EmailField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:FileField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:FloatField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:GenericLazyReferenceField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:GenericReferenceField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:GeoPointField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:IntField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:LazyReferenceField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:ListField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:LongField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:ReferenceField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:StringField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:URLField +validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:UUIDField +validate mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:DynamicField +validate mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:EmbeddedDocumentField +validate mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:GenericEmbeddedDocumentField +validate mongoengine/mongoengine/base/document.py /^ def validate(self, clean=True):$/;" m class:BaseDocument +validate mongoengine/mongoengine/base/fields.py /^ def validate(self, value):$/;" m class:ComplexBaseField +validate mongoengine/mongoengine/base/fields.py /^ def validate(self, value):$/;" m class:GeoJsonBaseField +validate mongoengine/mongoengine/base/fields.py /^ def validate(self, value):$/;" m class:ObjectIdField +validate mongoengine/mongoengine/base/fields.py /^ def validate(self, value, clean=True):$/;" m class:BaseField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:BinaryField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:BooleanField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:CachedReferenceField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:ComplexDateTimeField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:DateTimeField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:DecimalField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:DictField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:EmailField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:FileField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:FloatField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:GenericLazyReferenceField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:GenericReferenceField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:GeoPointField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:IntField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:LazyReferenceField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:ListField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:LongField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:ReferenceField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:StringField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:URLField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:UUIDField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:DynamicField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:EmbeddedDocumentField +validate mongoengine/mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:GenericEmbeddedDocumentField +validate mongoengine/tests/document/instance.py /^ validate = DictField()$/;" v class:InstanceTest.test_override_method_with_field.Blog +validate_domain_part mongoengine/fields.py /^ def validate_domain_part(self, domain_part):$/;" m class:EmailField +validate_domain_part mongoengine/mongoengine/fields.py /^ def validate_domain_part(self, domain_part):$/;" m class:EmailField +validate_user_part mongoengine/fields.py /^ def validate_user_part(self, user_part):$/;" m class:EmailField +validate_user_part mongoengine/mongoengine/fields.py /^ def validate_user_part(self, user_part):$/;" m class:EmailField +value mongoengine/tests/document/instance.py /^ value = DynamicField(default="UNDEFINED")$/;" v class:InstanceTest.test_complex_nesting_document_and_embedded_document.Macro +value mongoengine/tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_complex_mapfield.IntegerSetting +value mongoengine/tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_dictfield_complex.IntegerSetting +value mongoengine/tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_list_field_complex.IntegerSetting +value mongoengine/tests/fields/fields.py /^ value = LongField(min_value=0, max_value=110)$/;" v class:FieldTest.test_long_validation.TestDocument +value mongoengine/tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_complex_mapfield.StringSetting +value mongoengine/tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_dictfield_complex.StringSetting +value mongoengine/tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_list_field_complex.StringSetting +value mongoengine/tests/queryset/modify.py /^ value = IntField()$/;" v class:Doc +value mongoengine/tests/queryset/queryset.py /^ value = DecimalField()$/;" v class:QuerySetTest.test_embedded_average.Pay +value mongoengine/tests/queryset/queryset.py /^ value = DecimalField()$/;" v class:QuerySetTest.test_embedded_sum.Pay +value mongoengine/tests/queryset/queryset.py /^ value = StringField()$/;" v class:QuerySetTest.test_scalar_primary_key.SettingValue +value tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_complex_mapfield.IntegerSetting +value tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_dictfield_complex.IntegerSetting +value tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_list_field_complex.IntegerSetting +value tests/fields/fields.py /^ value = LongField(min_value=0, max_value=110)$/;" v class:FieldTest.test_long_validation.TestDocument +value tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_complex_mapfield.StringSetting +value tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_dictfield_complex.StringSetting +value tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_list_field_complex.StringSetting +value_list mongoengine/tests/fields/fields.py /^ value_list = ListField(field=StringField())$/;" v class:FieldTest.test_map_field_unicode.Info +value_list tests/fields/fields.py /^ value_list = ListField(field=StringField())$/;" v class:FieldTest.test_map_field_unicode.Info +values mongoengine/tests/queryset/queryset.py /^ values = ListField(DecimalField())$/;" v class:QuerySetTest.test_array_average.Doc +values mongoengine/tests/queryset/queryset.py /^ values = ListField(DecimalField())$/;" v class:QuerySetTest.test_array_sum.Doc +values mongoengine/tests/queryset/queryset.py /^ values = ListField(DecimalField())$/;" v class:QuerySetTest.test_embedded_array_average.Pay +values mongoengine/tests/queryset/queryset.py /^ values = ListField(DecimalField())$/;" v class:QuerySetTest.test_embedded_array_sum.Pay +values_list mongoengine/mongoengine/queryset/base.py /^ def values_list(self, *fields):$/;" m class:BaseQuerySet +various mongoengine/tests/queryset/field_list.py /^ various = MapField(field=EmbeddedDocumentField(VariousData))$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.BlogPost +venue mongoengine/tests/fields/geo.py /^ venue = EmbeddedDocumentField(Venue)$/;" v class:GeoFieldTest.test_geopoint_embedded_indexes.Event +venue mongoengine/tests/fields/geo.py /^ venue = EmbeddedDocumentField(Venue)$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Event +venue mongoengine/tests/queryset/geo.py /^ venue=venue1).save()$/;" v class:GeoQueriesTest._test_embedded.Event +venue mongoengine/tests/queryset/geo.py /^ venue=venue2).save()$/;" v class:GeoQueriesTest._test_embedded.Event +venue mongoengine/tests/queryset/geo.py /^ venue = EmbeddedDocumentField(Venue)$/;" v class:GeoQueriesTest._test_embedded.Event +verbose_name mongoengine/tests/fields/fields.py /^ verbose_name="Type",$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +verbose_name tests/fields/fields.py /^ verbose_name="Type",$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner +version mongoengine/docs/conf.py /^version = mongoengine.get_version()$/;" v +version_line mongoengine/setup.py /^version_line = list(filter(lambda l: l.startswith('VERSION'), open(init)))[0]$/;" v +visit_combination mongoengine/mongoengine/queryset/visitor.py /^ def visit_combination(self, combination):$/;" m class:QNodeVisitor +visit_combination mongoengine/mongoengine/queryset/visitor.py /^ def visit_combination(self, combination):$/;" m class:QueryCompilerVisitor +visit_combination mongoengine/mongoengine/queryset/visitor.py /^ def visit_combination(self, combination):$/;" m class:SimplificationVisitor +visit_query mongoengine/mongoengine/queryset/visitor.py /^ def visit_query(self, query):$/;" m class:QNodeVisitor +visit_query mongoengine/mongoengine/queryset/visitor.py /^ def visit_query(self, query):$/;" m class:QueryCompilerVisitor +visited mongoengine/tests/fields/fields.py /^ visited = MapField(DateTimeField())$/;" v class:FieldTest.test_map_field_lookup.Log +visited tests/fields/fields.py /^ visited = MapField(DateTimeField())$/;" v class:FieldTest.test_map_field_lookup.Log +visited__friends__exists mongoengine/tests/fields/fields.py /^ visited__friends__exists=True).count())$/;" v class:FieldTest.test_map_field_lookup.Log +visited__friends__exists tests/fields/fields.py /^ visited__friends__exists=True).count())$/;" v class:FieldTest.test_map_field_lookup.Log +vote mongoengine/tests/queryset/queryset.py /^ vote = IntField()$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Comment +votes mongoengine/tests/queryset/queryset.py /^ votes = EmbeddedDocumentField(Vote)$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.Comment +votes mongoengine/tests/queryset/queryset.py /^ votes = IntField()$/;" v class:QuerySetTest.test_update_using_positional_operator.Comment +weight mongoengine/tests/queryset/queryset.py /^ weight = IntField()$/;" v class:QuerySetTest.setUp.PersonMeta +where mongoengine/mongoengine/queryset/base.py /^ def where(self, where_clause):$/;" m class:BaseQuerySet +whiskers_length mongoengine/tests/queryset/queryset.py /^ whiskers_length = FloatField()$/;" v class:QuerySetTest.test_subclass_field_query.Cat +wibble mongoengine/tests/queryset/field_list.py /^ wibble = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_from_subclasses_docs.User +widgets mongoengine/tests/document/instance.py /^ widgets = StringField()$/;" v class:InstanceTest.test_object_mixins.Bar +widgets mongoengine/tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_del_slice_marks_field_as_changed.Simple +widgets mongoengine/tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_list_field_with_negative_indices.Simple +widgets mongoengine/tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_slice_marks_field_as_changed.Simple +widgets tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_del_slice_marks_field_as_changed.Simple +widgets tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_list_field_with_negative_indices.Simple +widgets tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_slice_marks_field_as_changed.Simple +with_id mongoengine/mongoengine/queryset/base.py /^ def with_id(self, object_id):$/;" m class:BaseQuerySet +with_inactive mongoengine/tests/queryset/queryset.py /^ def with_inactive(doc_cls, queryset):$/;" m class:QuerySetTest.test_custom_manager_overriding_objects_works.Foo +write mongoengine/fields.py /^ def write(self, *args, **kwargs):$/;" m class:ImageGridFsProxy +write mongoengine/fields.py /^ def write(self, string):$/;" m class:GridFSProxy +write mongoengine/mongoengine/fields.py /^ def write(self, *args, **kwargs):$/;" m class:ImageGridFsProxy +write mongoengine/mongoengine/fields.py /^ def write(self, string):$/;" m class:GridFSProxy +write_concern mongoengine/tests/queryset/queryset.py /^ write_concern={"w": 0, 'continue_on_error': True})$/;" v class:QuerySetTest.test_bulk_insert.Author +writelines mongoengine/fields.py /^ def writelines(self, *args, **kwargs):$/;" m class:ImageGridFsProxy +writelines mongoengine/fields.py /^ def writelines(self, lines):$/;" m class:GridFSProxy +writelines mongoengine/mongoengine/fields.py /^ def writelines(self, *args, **kwargs):$/;" m class:ImageGridFsProxy +writelines mongoengine/mongoengine/fields.py /^ def writelines(self, lines):$/;" m class:GridFSProxy +x mongoengine/tests/document/instance.py /^ x = IntField(required=True)$/;" v class:InstanceTest.test_document_embedded_clean.TestEmbeddedDocument +x mongoengine/tests/queryset/queryset.py /^ x = IntField()$/;" v class:QuerySetTest.test_no_sub_classes.A +x mongoengine/tests/queryset/queryset.py /^ x = IntField()$/;" v class:QuerySetTest.test_scalar_db_field.TestDoc +x mongoengine/tests/queryset/queryset.py /^ x = IntField()$/;" v class:QuerySetTest.test_scalar_simple.TestDoc +x mongoengine/tests/queryset/queryset.py /^ x = ListField()$/;" v class:QuerySetTest.test_update_using_positional_operator_matches_first.Simple +x mongoengine/tests/queryset/visitor.py /^ x = IntField()$/;" v class:QTest.test_and_combination.TestDoc +x mongoengine/tests/queryset/visitor.py /^ x = IntField()$/;" v class:QTest.test_and_or_combination.TestDoc +x mongoengine/tests/queryset/visitor.py /^ x = IntField()$/;" v class:QTest.test_or_and_or_combination.TestDoc +x mongoengine/tests/queryset/visitor.py /^ x = IntField()$/;" v class:QTest.test_or_combination.TestDoc +x mongoengine/tests/queryset/visitor.py /^ x = IntField()$/;" v class:QTest.test_q_clone.TestDoc +x mongoengine/tests/test_context_managers.py /^ x = IntField()$/;" v class:ContextManagersTest.test_no_sub_classes.A +y mongoengine/tests/document/instance.py /^ y = IntField(required=True)$/;" v class:InstanceTest.test_document_embedded_clean.TestEmbeddedDocument +y mongoengine/tests/queryset/queryset.py /^ y = BooleanField()$/;" v class:QuerySetTest.test_scalar_db_field.TestDoc +y mongoengine/tests/queryset/queryset.py /^ y = BooleanField()$/;" v class:QuerySetTest.test_scalar_simple.TestDoc +y mongoengine/tests/queryset/queryset.py /^ y = IntField()$/;" v class:QuerySetTest.test_no_sub_classes.A +y mongoengine/tests/queryset/visitor.py /^ y = BooleanField()$/;" v class:QTest.test_and_or_combination.TestDoc +y mongoengine/tests/queryset/visitor.py /^ y = BooleanField()$/;" v class:QTest.test_or_and_or_combination.TestDoc +y mongoengine/tests/queryset/visitor.py /^ y = StringField()$/;" v class:QTest.test_and_combination.TestDoc +y mongoengine/tests/test_context_managers.py /^ y = IntField()$/;" v class:ContextManagersTest.test_no_sub_classes.A +year mongoengine/tests/document/indexes.py /^ year = IntField(db_field='yr')$/;" v class:IndexesTest.test_embedded_document_index.Date +year mongoengine/tests/document/indexes.py /^ year = IntField(db_field='yr')$/;" v class:IndexesTest.test_unique_embedded_document.SubDocument +year mongoengine/tests/document/indexes.py /^ year = IntField(db_field='yr')$/;" v class:IndexesTest.test_unique_embedded_document_in_list.SubDocument +year mongoengine/tests/document/indexes.py /^ year = IntField(db_field='yr')$/;" v class:IndexesTest.test_unique_with.Date +year mongoengine/tests/document/indexes.py /^ year = IntField(db_field='yr')$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.SubDocument +years mongoengine/tests/document/instance.py /^ years = IntField()$/;" v class:InstanceTest.setUp.Job +z mongoengine/tests/document/instance.py /^ z = IntField(required=True)$/;" v class:InstanceTest.test_document_embedded_clean.TestEmbeddedDocument +z mongoengine/tests/queryset/queryset.py /^ z = IntField()$/;" v class:QuerySetTest.test_no_sub_classes.B +z mongoengine/tests/test_context_managers.py /^ z = IntField()$/;" v class:ContextManagersTest.test_no_sub_classes.B +zz mongoengine/tests/queryset/queryset.py /^ zz = IntField()$/;" v class:QuerySetTest.test_no_sub_classes.C +zz mongoengine/tests/test_context_managers.py /^ zz = IntField()$/;" v class:ContextManagersTest.test_no_sub_classes.C diff --git a/tests/fields/fields.py b/tests/fields/fields.py index 0f325849..b09c0a2d 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -1698,6 +1698,10 @@ class FieldTest(MongoDBTestCase): 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() @@ -1706,12 +1710,15 @@ class FieldTest(MongoDBTestCase): post.info = {'details': {'test': 3}} post.save() - self.assertEqual(BlogPost.objects.count(), 3) + 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) From b525c91bd34861b7689958f7a2b976a00ff1ebee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Wed, 19 Dec 2018 20:33:37 +0100 Subject: [PATCH 235/250] remove tags file that shouldnt be added to situkangsayur s commit --- tags | 6449 ---------------------------------------------------------- 1 file changed, 6449 deletions(-) delete mode 100644 tags diff --git a/tags b/tags deleted file mode 100644 index 88c92b07..00000000 --- a/tags +++ /dev/null @@ -1,6449 +0,0 @@ -!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/ -!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/ -!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/ -!_TAG_PROGRAM_NAME Exuberant Ctags // -!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/ -!_TAG_PROGRAM_VERSION 5.9~svn20110310 // -A mongoengine/tests/document/indexes.py /^ class A(Document):$/;" c function:IndexesTest.test_index_no_cls -A mongoengine/tests/document/indexes.py /^ class A(Document):$/;" c function:IndexesTest.test_inherited_index -A mongoengine/tests/document/inheritance.py /^ class A(Document):$/;" c function:InheritanceTest.test_indexes_and_multiple_inheritance -A mongoengine/tests/document/inheritance.py /^ class A(EmbeddedDocument):$/;" c function:InheritanceTest.test_abstract_embedded_documents -A mongoengine/tests/document/instance.py /^ class A(Document):$/;" c function:InstanceTest.subclasses_and_unique_keys_works -A mongoengine/tests/document/instance.py /^ class A(Document):$/;" c function:InstanceTest.test_db_alias_overrides -A mongoengine/tests/document/instance.py /^ class A(Document):$/;" c function:InstanceTest.test_db_alias_propagates -A mongoengine/tests/document/instance.py /^ class A(Document):$/;" c function:InstanceTest.test_list_iter -A mongoengine/tests/document/instance.py /^ class A(Document):$/;" c function:InstanceTest.test_mutating_documents -A mongoengine/tests/fields/fields.py /^ class A(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field -A mongoengine/tests/fields/fields.py /^ class A(Document):$/;" c function:FieldTest.test_double_embedded_db_field -A mongoengine/tests/fields/fields.py /^ class A(Document):$/;" c function:FieldTest.test_double_embedded_db_field_from_son -A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_batch_size -A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_chaining -A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_count_list_embedded -A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_no_sub_classes -A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_none -A mongoengine/tests/queryset/queryset.py /^ class A(Document):$/;" c function:QuerySetTest.test_query_reference_to_custom_pk_doc -A mongoengine/tests/queryset/queryset.py /^ class A(EmbeddedDocument):$/;" c function:QuerySetTest.test_query_generic_embedded_document -A mongoengine/tests/queryset/transform.py /^ class A(Document):$/;" c function:TransformTest.test_chaining -A mongoengine/tests/test_context_managers.py /^ class A(Document):$/;" c function:ContextManagersTest.test_no_sub_classes -A tests/fields/fields.py /^ class A(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field -A tests/fields/fields.py /^ class A(Document):$/;" c function:FieldTest.test_double_embedded_db_field -A tests/fields/fields.py /^ class A(Document):$/;" c function:FieldTest.test_double_embedded_db_field_from_son -ALLSPHINXOPTS mongoengine/docs/Makefile /^ALLSPHINXOPTS = -d $(BUILDDIR)\/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .$/;" m -AND mongoengine/mongoengine/queryset/visitor.py /^ AND = 0$/;" v class:QNode -AbstractBlogPost mongoengine/tests/queryset/queryset.py /^ class AbstractBlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_on_abstract_document -AbstractBlogPost mongoengine/tests/queryset/queryset.py /^ class AbstractBlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_deny_on_abstract_document -AbstractBlogPost mongoengine/tests/queryset/queryset.py /^ class AbstractBlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_nullify_on_abstract_document -AbstractBlogPost mongoengine/tests/queryset/queryset.py /^ class AbstractBlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents -AbstractDoc mongoengine/tests/fields/fields.py /^ class AbstractDoc(Document):$/;" c function:FieldTest.test_drop_abstract_document -AbstractDoc tests/fields/fields.py /^ class AbstractDoc(Document):$/;" c function:FieldTest.test_drop_abstract_document -Account mongoengine/tests/document/instance.py /^ class Account(Document):$/;" c function:InstanceTest.test_instance_is_set_on_setattr -Account mongoengine/tests/document/instance.py /^ class Account(Document):$/;" c function:InstanceTest.test_instance_is_set_on_setattr_on_embedded_document_list -AcloholicDrink mongoengine/tests/document/inheritance.py /^ class AcloholicDrink(Drink):$/;" c class:InheritanceTest.test_inherited_collections.Drinker -Action mongoengine/tests/fields/fields.py /^ class Action(EmbeddedDocument):$/;" c function:FieldTest.test_map_field_lookup -Action tests/fields/fields.py /^ class Action(EmbeddedDocument):$/;" c function:FieldTest.test_map_field_lookup -Actor mongoengine/tests/document/instance.py /^ class Actor(self.Person):$/;" c function:InstanceTest.test_queryset_resurrects_dropped_collection -Address mongoengine/tests/document/dynamic.py /^ class Address(DynamicEmbeddedDocument):$/;" c function:DynamicTest.test_dynamic_embedded_works_with_only -Address mongoengine/tests/document/dynamic.py /^ class Address(EmbeddedDocument):$/;" c function:DynamicTest.test_dynamic_and_embedded -Address mongoengine/tests/document/dynamic.py /^ class Address(EmbeddedDocument):$/;" c function:DynamicTest.test_dynamic_and_embedded_dict_access -AlcoholicDrink mongoengine/tests/document/inheritance.py /^ class AlcoholicDrink(Drink):$/;" c class:InheritanceTest.test_inherited_collections.Drinker -AllWarnings mongoengine/tests/all_warnings/__init__.py /^class AllWarnings(unittest.TestCase):$/;" c -Animal mongoengine/tests/document/class_methods.py /^ class Animal(Document):$/;" c function:ClassMethodsTest.test_register_delete_rule_inherited -Animal mongoengine/tests/document/inheritance.py /^ class Animal(Base): pass$/;" c function:InheritanceTest.test_external_subclasses -Animal mongoengine/tests/document/inheritance.py /^ class Animal(Base): pass$/;" c function:InheritanceTest.test_external_superclasses -Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_abstract_documents -Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_allow_inheritance -Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_cant_turn_off_inheritance_on_subclass -Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_dynamic_declarations -Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_polymorphic_queries -Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_subclasses -Animal mongoengine/tests/document/inheritance.py /^ class Animal(Document):$/;" c function:InheritanceTest.test_superclasses -Animal mongoengine/tests/document/inheritance.py /^ class Animal(FinalDocument):$/;" c function:InheritanceTest.test_allow_inheritance_abstract_document -Animal mongoengine/tests/document/instance.py /^ class Animal(Document):$/;" c function:InstanceTest.test_polymorphic_references -Animal mongoengine/tests/document/instance.py /^ class Animal(Document):$/;" c function:InstanceTest.test_reload_sharded -Animal mongoengine/tests/document/instance.py /^ class Animal(Document):$/;" c function:InstanceTest.test_reload_sharded_nested -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_get_and_save -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_cls_field -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_multiple_sequence_fields_on_docs -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_sequence_fields_reload -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_equality -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_not_set -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_passthrough -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set -Animal mongoengine/tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_simple -Animal mongoengine/tests/fields/file_tests.py /^ class Animal(Document):$/;" c function:FileTest.test_complex_field_filefield -Animal mongoengine/tests/fields/file_tests.py /^ class Animal(Document):$/;" c function:FileTest.test_file_saving -Animal mongoengine/tests/queryset/queryset.py /^ class Animal(Document):$/;" c function:QuerySetTest.test_cls_query_in_subclassed_docs -Animal mongoengine/tests/queryset/queryset.py /^ class Animal(Document):$/;" c function:QuerySetTest.test_subclass_field_query -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_get_and_save -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_cls_field -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_multiple_sequence_fields_on_docs -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:FieldTest.test_sequence_fields_reload -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_equality -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_not_set -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_passthrough -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set -Animal tests/fields/fields.py /^ class Animal(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_simple -Anon mongoengine/tests/queryset/field_list.py /^ class Anon(Base):$/;" c function:OnlyExcludeAllTest.test_exclude_from_subclasses_docs -Another mongoengine/tests/test_signals.py /^ class Another(Document):$/;" c function:SignalTests.setUp -Area mongoengine/tests/document/instance.py /^ class Area(Location):$/;" c function:InstanceTest.test_document_registry_regressions -Article mongoengine/tests/document/instance.py /^ class Article(Document):$/;" c function:InstanceTest.test_repr -Article mongoengine/tests/document/instance.py /^ class Article(Document):$/;" c function:InstanceTest.test_repr_none -Asset mongoengine/tests/test_dereference.py /^ class Asset(Document):$/;" c function:FieldTest.test_multidirectional_lists -Attachment mongoengine/tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_field_primary -Attachment mongoengine/tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_field_primary_filter_by_binary_pk_as_str -Attachment mongoengine/tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_fields -Attachment mongoengine/tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_validation -Attachment mongoengine/tests/queryset/field_list.py /^ class Attachment(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_exclude_only_combining -Attachment tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_field_primary -Attachment tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_field_primary_filter_by_binary_pk_as_str -Attachment tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_fields -Attachment tests/fields/fields.py /^ class Attachment(Document):$/;" c function:FieldTest.test_binary_validation -AttachmentRequired mongoengine/tests/fields/fields.py /^ class AttachmentRequired(Document):$/;" c function:FieldTest.test_binary_validation -AttachmentRequired tests/fields/fields.py /^ class AttachmentRequired(Document):$/;" c function:FieldTest.test_binary_validation -AttachmentSizeLimit mongoengine/tests/fields/fields.py /^ class AttachmentSizeLimit(Document):$/;" c function:FieldTest.test_binary_validation -AttachmentSizeLimit tests/fields/fields.py /^ class AttachmentSizeLimit(Document):$/;" c function:FieldTest.test_binary_validation -Author mongoengine/tests/fields/fields.py /^ class Author(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_validation -Author mongoengine/tests/queryset/queryset.py /^ class Author(Document):$/;" c function:QuerySetTest.test_bulk_insert -Author mongoengine/tests/queryset/queryset.py /^ class Author(Document):$/;" c function:QuerySetTest.test_confirm_order_by_reference_wont_work -Author mongoengine/tests/queryset/queryset.py /^ class Author(EmbeddedDocument):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField -Author mongoengine/tests/queryset/queryset.py /^ class Author(EmbeddedDocument):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField -Author mongoengine/tests/queryset/queryset.py /^ class Author(EmbeddedDocument):$/;" c function:QuerySetTest.test_set_list_embedded_documents -Author mongoengine/tests/test_signals.py /^ class Author(Document):$/;" c function:SignalTests.setUp -Author tests/fields/fields.py /^ class Author(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_validation -AuthorBooks mongoengine/tests/document/instance.py /^ class AuthorBooks(Document):$/;" c function:InstanceTest.test_db_alias_tests -B mongoengine/tests/document/indexes.py /^ class B(A):$/;" c function:IndexesTest.test_index_no_cls -B mongoengine/tests/document/indexes.py /^ class B(A):$/;" c function:IndexesTest.test_inherited_index -B mongoengine/tests/document/inheritance.py /^ class B(A):$/;" c function:InheritanceTest.test_abstract_embedded_documents -B mongoengine/tests/document/inheritance.py /^ class B(Document):$/;" c function:InheritanceTest.test_indexes_and_multiple_inheritance -B mongoengine/tests/document/instance.py /^ class B(A):$/;" c function:InstanceTest.subclasses_and_unique_keys_works -B mongoengine/tests/document/instance.py /^ class B(A):$/;" c function:InstanceTest.test_db_alias_overrides -B mongoengine/tests/document/instance.py /^ class B(A):$/;" c function:InstanceTest.test_db_alias_propagates -B mongoengine/tests/document/instance.py /^ class B(EmbeddedDocument):$/;" c function:InstanceTest.test_list_iter -B mongoengine/tests/document/instance.py /^ class B(EmbeddedDocument):$/;" c function:InstanceTest.test_mutating_documents -B mongoengine/tests/fields/fields.py /^ class B(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field -B mongoengine/tests/fields/fields.py /^ class B(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field -B mongoengine/tests/fields/fields.py /^ class B(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field_from_son -B mongoengine/tests/queryset/queryset.py /^ class B(A):$/;" c function:QuerySetTest.test_no_sub_classes -B mongoengine/tests/queryset/queryset.py /^ class B(Document):$/;" c function:QuerySetTest.test_chaining -B mongoengine/tests/queryset/queryset.py /^ class B(Document):$/;" c function:QuerySetTest.test_query_reference_to_custom_pk_doc -B mongoengine/tests/queryset/queryset.py /^ class B(Document):$/;" c function:QuerySetTest.test_save_and_only_on_fields_with_default -B mongoengine/tests/queryset/queryset.py /^ class B(EmbeddedDocument):$/;" c function:QuerySetTest.test_count_list_embedded -B mongoengine/tests/queryset/queryset.py /^ class B(EmbeddedDocument):$/;" c function:QuerySetTest.test_query_generic_embedded_document -B mongoengine/tests/queryset/transform.py /^ class B(Document):$/;" c function:TransformTest.test_chaining -B mongoengine/tests/test_context_managers.py /^ class B(A):$/;" c function:ContextManagersTest.test_no_sub_classes -B tests/fields/fields.py /^ class B(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field -B tests/fields/fields.py /^ class B(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field -B tests/fields/fields.py /^ class B(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field_from_son -BUILDDIR mongoengine/docs/Makefile /^BUILDDIR = _build$/;" m -BadDoc mongoengine/tests/fields/fields.py /^ class BadDoc(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set -BadDoc mongoengine/tests/fields/fields.py /^ class BadDoc(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set -BadDoc tests/fields/fields.py /^ class BadDoc(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set -BadDoc tests/fields/fields.py /^ class BadDoc(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set -Bar mongoengine/tests/document/instance.py /^ class Bar(Document):$/;" c function:InstanceTest.test_shard_key_in_embedded_document -Bar mongoengine/tests/document/instance.py /^ class Bar(Document):$/;" c function:InstanceTest.test_two_way_reverse_delete_rule -Bar mongoengine/tests/document/instance.py /^ class Bar(Document, NameMixin):$/;" c function:InstanceTest.test_object_mixins -Bar mongoengine/tests/fields/fields.py /^ class Bar(Base):$/;" c function:FieldTest.test_inherited_sequencefield -Bar mongoengine/tests/fields/fields.py /^ class Bar(Base):$/;" c function:FieldTest.test_no_inherited_sequencefield -Bar mongoengine/tests/fields/fields.py /^ class Bar(Document):$/;" c function:FieldTest.test_list_field_passed_in_value -Bar mongoengine/tests/fields/fields.py /^ class Bar(Document):$/;" c function:FieldTest.test_reference_miss -Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_distinct_ListField_ReferenceField -Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_distinct_handles_references -Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_distinct_handles_references_to_alias -Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_elem_match -Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_pull_in_genericembedded_field -Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Document):$/;" c function:QuerySetTest.test_read_preference -Bar mongoengine/tests/queryset/queryset.py /^ class Bar(EmbeddedDocument):$/;" c function:QuerySetTest.test_set_generic_embedded_documents -Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Foo):$/;" c function:QuerySetTest.test_inherit_objects -Bar mongoengine/tests/queryset/queryset.py /^ class Bar(Foo):$/;" c function:QuerySetTest.test_inherit_objects_override -Bar mongoengine/tests/test_dereference.py /^ class Bar(Document):$/;" c function:FieldTest.test_document_reload_no_inheritance -Bar tests/fields/fields.py /^ class Bar(Base):$/;" c function:FieldTest.test_inherited_sequencefield -Bar tests/fields/fields.py /^ class Bar(Base):$/;" c function:FieldTest.test_no_inherited_sequencefield -Bar tests/fields/fields.py /^ class Bar(Document):$/;" c function:FieldTest.test_list_field_passed_in_value -Bar tests/fields/fields.py /^ class Bar(Document):$/;" c function:FieldTest.test_reference_miss -Base mongoengine/tests/fields/fields.py /^ class Base(Document):$/;" c function:FieldTest.test_inherited_sequencefield -Base mongoengine/tests/fields/fields.py /^ class Base(Document):$/;" c function:FieldTest.test_no_inherited_sequencefield -Base mongoengine/tests/fixtures.py /^class Base(Document):$/;" c -Base mongoengine/tests/queryset/field_list.py /^ class Base(Document):$/;" c function:OnlyExcludeAllTest.test_exclude_from_subclasses_docs -Base mongoengine/tests/queryset/queryset.py /^ class Base(Document):$/;" c function:QuerySetTest.test_custom_querysets_inherited -Base mongoengine/tests/queryset/queryset.py /^ class Base(Document):$/;" c function:QuerySetTest.test_custom_querysets_inherited_direct -Base tests/fields/fields.py /^ class Base(Document):$/;" c function:FieldTest.test_inherited_sequencefield -Base tests/fields/fields.py /^ class Base(Document):$/;" c function:FieldTest.test_no_inherited_sequencefield -BaseDict mongoengine/mongoengine/base/datastructures.py /^class BaseDict(dict):$/;" c -BaseDocument mongoengine/mongoengine/base/document.py /^class BaseDocument(object):$/;" c -BaseDocument mongoengine/tests/document/class_methods.py /^ class BaseDocument(Document):$/;" c function:ClassMethodsTest.test_collection_naming -BaseDocument mongoengine/tests/document/class_methods.py /^ class BaseDocument(Document, BaseMixin):$/;" c function:ClassMethodsTest.test_collection_naming -BaseField mongoengine/mongoengine/base/fields.py /^class BaseField(object):$/;" c -BaseList mongoengine/mongoengine/base/datastructures.py /^class BaseList(list):$/;" c -BaseMixIn mongoengine/tests/document/instance.py /^ class BaseMixIn(object):$/;" c function:InstanceTest.test_mixin_inheritance -BaseMixin mongoengine/tests/document/class_methods.py /^ class BaseMixin(object):$/;" c function:ClassMethodsTest.test_collection_naming -BasePerson mongoengine/tests/document/validation.py /^ class BasePerson(Document):$/;" c function:ValidatorErrorTest.test_fields_rewrite -BaseQuerySet mongoengine/mongoengine/queryset/base.py /^class BaseQuerySet(object):$/;" c -Basedoc mongoengine/tests/fields/fields.py /^ class Basedoc(Document):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list -Basedoc tests/fields/fields.py /^ class Basedoc(Document):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list -BasesTuple mongoengine/mongoengine/base/metaclasses.py /^class BasesTuple(tuple):$/;" c -Basket mongoengine/tests/fields/fields.py /^ class Basket(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields -Basket tests/fields/fields.py /^ class Basket(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields -Baz mongoengine/tests/test_dereference.py /^ class Baz(Document):$/;" c function:FieldTest.test_document_reload_no_inheritance -BigPerson mongoengine/tests/fields/fields.py /^ class BigPerson(Document):$/;" c function:FieldTest.test_float_validation -BigPerson tests/fields/fields.py /^ class BigPerson(Document):$/;" c function:FieldTest.test_float_validation -BinaryField mongoengine/fields.py /^class BinaryField(BaseField):$/;" c -BinaryField mongoengine/mongoengine/fields.py /^class BinaryField(BaseField):$/;" c -Blog mongoengine/tests/document/instance.py /^ class Blog(Document):$/;" c function:InstanceTest.test_invalid_reverse_delete_rule_raise_errors -Blog mongoengine/tests/document/instance.py /^ class Blog(Document):$/;" c function:InstanceTest.test_override_method_with_field -Blog mongoengine/tests/queryset/queryset.py /^ class Blog(Document):$/;" c function:QuerySetTest.test_bulk_insert -Blog mongoengine/tests/queryset/queryset.py /^ class Blog(Document):$/;" c function:QuerySetTest.test_filter_chaining -Blog mongoengine/tests/queryset/queryset.py /^ class Blog(Document):$/;" c function:QuerySetTest.test_find_array_position -Blog mongoengine/tests/queryset/queryset.py /^ class Blog(Document):$/;" c function:QuerySetTest.test_update_array_position -BlogPost mongoengine/tests/document/class_methods.py /^ class BlogPost(Document):$/;" c function:ClassMethodsTest.test_compare_indexes -BlogPost mongoengine/tests/document/class_methods.py /^ class BlogPost(Document):$/;" c function:ClassMethodsTest.test_compare_indexes_inheritance -BlogPost mongoengine/tests/document/class_methods.py /^ class BlogPost(Document):$/;" c function:ClassMethodsTest.test_compare_indexes_multiple_subclasses -BlogPost mongoengine/tests/document/class_methods.py /^ class BlogPost(Document):$/;" c function:ClassMethodsTest.test_list_indexes_inheritance -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c class:IndexesTest.test_index_with_pk.Comment -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_dictionary_indexes -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_embedded_document_index -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_hint -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_index_on_id -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_indexes_after_database_drop -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_list_embedded_document_index -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_unique -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_unique_embedded_document -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_unique_embedded_document_in_list -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_unique_with -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(Document):$/;" c function:IndexesTest.test_unique_with_embedded_document_and_embedded_unique -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(InheritFrom):$/;" c function:IndexesTest._index_test -BlogPost mongoengine/tests/document/indexes.py /^ class BlogPost(InheritFrom):$/;" c function:IndexesTest._index_test_inheritance -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_document_hash -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_modify_with_positional_push -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_push_nested_list -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_push_with_position -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_and_nullify -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_and_nullify_complex_field -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_recurs -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_deny -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_with_document_inheritance -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_save_list -BlogPost mongoengine/tests/document/instance.py /^ class BlogPost(Document):$/;" c function:InstanceTest.test_save_reference -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.setUp -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents_inheritance -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents_invalid -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_dict_field -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_embedded_document_inheritance -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_assignment -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_invalid_operators -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_lexicographic_operators -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_manipulative_operators -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_validation -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_map_field_unicode -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_query_conversion -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_query_conversion_dbref -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_validation -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_sorted_list_sorting -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion -BlogPost mongoengine/tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref -BlogPost mongoengine/tests/queryset/field_list.py /^ class BlogPost(Document):$/;" c function:OnlyExcludeAllTest.test_exclude -BlogPost mongoengine/tests/queryset/field_list.py /^ class BlogPost(Document):$/;" c function:OnlyExcludeAllTest.test_only_with_subfields -BlogPost mongoengine/tests/queryset/modify.py /^ class BlogPost(Document):$/;" c function:FindAndModifyTest.test_modify_with_push -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(AbstractBlogPost):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_on_abstract_document -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(AbstractBlogPost):$/;" c function:QuerySetTest.test_reverse_delete_rule_deny_on_abstract_document -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(AbstractBlogPost):$/;" c function:QuerySetTest.test_reverse_delete_rule_nullify_on_abstract_document -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(AbstractBlogPost):$/;" c function:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_bulk -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_cannot_perform_joins_references -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_clear_ordering -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_custom_manager -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_delete_with_limit_handles_delete_rules -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_editting_embedded_objects -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_exec_js_field_sub -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_exec_js_query -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_filter_chaining -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_find_dict_item -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_find_embedded -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_find_empty_embedded -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_in_operator_on_non_iterable -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_item_frequencies -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_map_reduce -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_map_reduce_with_custom_object_ids -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_no_ordering_for_get -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_order_by_list -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_order_by_optional -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_ordering -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_query_value_conversion -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reference_field_find -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reference_field_find_dbref -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_deny -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_nullify -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_pull -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_one_pop_generic_reference -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_push_and_pull_add_to_set -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_push_list_of_list -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_push_with_position -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_using_positional_operator -BlogPost mongoengine/tests/queryset/queryset.py /^ class BlogPost(Document):$/;" c function:QuerySetTest.test_update_using_positional_operator_embedded_document -BlogPost mongoengine/tests/queryset/transform.py /^ class BlogPost(Document):$/;" c function:TransformTest.test_query_field_name -BlogPost mongoengine/tests/queryset/transform.py /^ class BlogPost(Document):$/;" c function:TransformTest.test_query_pk_field_name -BlogPost mongoengine/tests/queryset/visitor.py /^ class BlogPost(Document):$/;" c function:QTest.test_q -BlogPost mongoengine/tests/queryset/visitor.py /^ class BlogPost(Document):$/;" c function:QTest.test_q_lists -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.setUp -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents_inheritance -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_choices_validation_documents_invalid -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_dict_field -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_embedded_document_inheritance -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_assignment -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_invalid_operators -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_lexicographic_operators -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_field_manipulative_operators -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_list_validation -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_map_field_unicode -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_query_conversion -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_query_conversion_dbref -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_reference_validation -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:FieldTest.test_sorted_list_sorting -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion -BlogPost tests/fields/fields.py /^ class BlogPost(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref -BlogPostWithCustomField mongoengine/tests/document/class_methods.py /^ class BlogPostWithCustomField(BlogPost):$/;" c function:ClassMethodsTest.test_compare_indexes_multiple_subclasses -BlogPostWithTags mongoengine/tests/document/class_methods.py /^ class BlogPostWithTags(BlogPost):$/;" c function:ClassMethodsTest.test_compare_indexes_inheritance -BlogPostWithTags mongoengine/tests/document/class_methods.py /^ class BlogPostWithTags(BlogPost):$/;" c function:ClassMethodsTest.test_compare_indexes_multiple_subclasses -BlogPostWithTags mongoengine/tests/document/class_methods.py /^ class BlogPostWithTags(BlogPost):$/;" c function:ClassMethodsTest.test_list_indexes_inheritance -BlogPostWithTagsAndExtraText mongoengine/tests/document/class_methods.py /^ class BlogPostWithTagsAndExtraText(BlogPostWithTags):$/;" c function:ClassMethodsTest.test_list_indexes_inheritance -BlogTag mongoengine/tests/queryset/queryset.py /^ class BlogTag(Document):$/;" c function:QuerySetTest.test_update_one_pop_generic_reference -BlogTag mongoengine/tests/queryset/queryset.py /^ class BlogTag(EmbeddedDocument):$/;" c function:QuerySetTest.test_editting_embedded_objects -Book mongoengine/tests/document/indexes.py /^ class Book(Document):$/;" c function:IndexesTest.test_hashed_indexes -Book mongoengine/tests/document/indexes.py /^ class Book(Document):$/;" c function:IndexesTest.test_text_indexes -Book mongoengine/tests/document/instance.py /^ class Book(Document):$/;" c function:InstanceTest.test_db_alias_tests -Book mongoengine/tests/document/instance.py /^ class Book(Document):$/;" c function:InstanceTest.test_db_ref_usage -Book mongoengine/tests/document/instance.py /^ class Book(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_with_custom_id_field -Book mongoengine/tests/document/instance.py /^ class Book(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_with_shared_id_among_collections -Book mongoengine/tests/queryset/queryset.py /^ class Book(Document):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField -Book mongoengine/tests/queryset/queryset.py /^ class Book(Document):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField -Book mongoengine/tests/test_dereference.py /^ class Book(Document):$/;" c function:FieldTest.test_objectid_reference_across_databases -Bookmark mongoengine/tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference -Bookmark mongoengine/tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_choices -Bookmark mongoengine/tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_choices_no_dereference -Bookmark mongoengine/tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_string_choices -Bookmark tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference -Bookmark tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_choices -Bookmark tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_choices_no_dereference -Bookmark tests/fields/fields.py /^ class Bookmark(Document):$/;" c function:FieldTest.test_generic_reference_string_choices -BooleanField mongoengine/fields.py /^class BooleanField(BaseField):$/;" c -BooleanField mongoengine/mongoengine/fields.py /^class BooleanField(BaseField):$/;" c -Brand mongoengine/tests/test_dereference.py /^ class Brand(Document):$/;" c function:FieldTest.test_non_ascii_pk -BrandGroup mongoengine/tests/test_dereference.py /^ class BrandGroup(Document):$/;" c function:FieldTest.test_non_ascii_pk -Brother mongoengine/tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_abstract_reference_base_type -Brother mongoengine/tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_reference_abstract_class -Brother mongoengine/tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_reference_class_with_abstract_parent -Brother tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_abstract_reference_base_type -Brother tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_reference_abstract_class -Brother tests/fields/fields.py /^ class Brother(Sibling):$/;" c function:FieldTest.test_reference_class_with_abstract_parent -C mongoengine/tests/document/inheritance.py /^ class C(A, B):$/;" c function:InheritanceTest.test_indexes_and_multiple_inheritance -C mongoengine/tests/document/instance.py /^ class C(EmbeddedDocument):$/;" c function:InstanceTest.test_mutating_documents -C mongoengine/tests/fields/fields.py /^ class C(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field -C mongoengine/tests/fields/fields.py /^ class C(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field_from_son -C mongoengine/tests/queryset/queryset.py /^ class C(B):$/;" c function:QuerySetTest.test_no_sub_classes -C mongoengine/tests/test_context_managers.py /^ class C(B):$/;" c function:ContextManagersTest.test_no_sub_classes -C tests/fields/fields.py /^ class C(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field -C tests/fields/fields.py /^ class C(EmbeddedDocument):$/;" c function:FieldTest.test_double_embedded_db_field_from_son -CASCADE mongoengine/mongoengine/queryset/base.py /^CASCADE = 2$/;" v -CLASSIFIERS mongoengine/setup.py /^CLASSIFIERS = [$/;" v -COLLECTION_NAME mongoengine/fields.py /^ COLLECTION_NAME = 'mongoengine.counters'$/;" v class:SequenceField -COLLECTION_NAME mongoengine/mongoengine/fields.py /^ COLLECTION_NAME = 'mongoengine.counters'$/;" v class:SequenceField -COMPARISON_OPERATORS mongoengine/mongoengine/queryset/transform.py /^COMPARISON_OPERATORS = ('ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'mod',$/;" v -CONN_CLASS mongoengine/tests/test_replicaset_connection.py /^ CONN_CLASS = MongoClient$/;" v -CONN_CLASS mongoengine/tests/test_replicaset_connection.py /^ CONN_CLASS = ReplicaSetConnection$/;" v -CUSTOM_OPERATORS mongoengine/mongoengine/queryset/transform.py /^CUSTOM_OPERATORS = ('match',)$/;" v -CachedReferenceField mongoengine/fields.py /^class CachedReferenceField(BaseField):$/;" c -CachedReferenceField mongoengine/mongoengine/fields.py /^class CachedReferenceField(BaseField):$/;" c -CachedReferenceFieldTest mongoengine/tests/fields/fields.py /^class CachedReferenceFieldTest(MongoDBTestCase):$/;" c -CachedReferenceFieldTest tests/fields/fields.py /^class CachedReferenceFieldTest(MongoDBTestCase):$/;" c -Car mongoengine/tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document -Car mongoengine/tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document_choices -Car mongoengine/tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_list_embedded_document_choices -Car tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document -Car tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document_choices -Car tests/fields/fields.py /^ class Car(EmbeddedDocument):$/;" c function:FieldTest.test_generic_list_embedded_document_choices -Cat mongoengine/tests/document/class_methods.py /^ class Cat(Animal):$/;" c function:ClassMethodsTest.test_register_delete_rule_inherited -Cat mongoengine/tests/queryset/queryset.py /^ class Cat(Animal):$/;" c function:QuerySetTest.test_cls_query_in_subclassed_docs -Cat mongoengine/tests/queryset/queryset.py /^ class Cat(Animal):$/;" c function:QuerySetTest.test_subclass_field_query -Category mongoengine/tests/fields/fields.py /^ class Category(EmbeddedDocument):$/;" c function:FieldTest.test_reverse_list_sorting -Category mongoengine/tests/queryset/queryset.py /^ class Category(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_complex_cycle -Category mongoengine/tests/queryset/queryset.py /^ class Category(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing -Category mongoengine/tests/queryset/queryset.py /^ class Category(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_nullify -Category tests/fields/fields.py /^ class Category(EmbeddedDocument):$/;" c function:FieldTest.test_reverse_list_sorting -CategoryList mongoengine/tests/fields/fields.py /^ class CategoryList(Document):$/;" c function:FieldTest.test_reverse_list_sorting -CategoryList tests/fields/fields.py /^ class CategoryList(Document):$/;" c function:FieldTest.test_reverse_list_sorting -Child mongoengine/tests/document/validation.py /^ class Child(Parent):$/;" c function:ValidatorErrorTest.test_parent_reference_in_child_document -Child mongoengine/tests/document/validation.py /^ class Child(Parent):$/;" c function:ValidatorErrorTest.test_parent_reference_set_as_attribute_in_child_document -City mongoengine/tests/document/inheritance.py /^ class City(Document):$/;" c function:InheritanceTest.test_abstract_document_creation_does_not_fail -City mongoengine/tests/document/inheritance.py /^ class City(Document):$/;" c function:InheritanceTest.test_abstract_handle_ids_in_metaclass_properly -City mongoengine/tests/document/inheritance.py /^ class City(Document):$/;" c function:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class -City mongoengine/tests/document/inheritance.py /^ class City(Document):$/;" c function:InheritanceTest.test_auto_id_vs_non_pk_id_field -ClassMethodsTest mongoengine/tests/document/class_methods.py /^class ClassMethodsTest(unittest.TestCase):$/;" c -Club mongoengine/tests/queryset/queryset.py /^ class Club(Document):$/;" c function:QuerySetTest.test_dictfield_update -Club mongoengine/tests/queryset/queryset.py /^ class Club(Document):$/;" c function:QuerySetTest.test_mapfield_update -Collaborator mongoengine/tests/queryset/queryset.py /^ class Collaborator(EmbeddedDocument):$/;" c function:QuerySetTest.test_pull_from_nested_embedded -Collaborator mongoengine/tests/queryset/queryset.py /^ class Collaborator(EmbeddedDocument):$/;" c function:QuerySetTest.test_pull_from_nested_mapfield -Collaborator mongoengine/tests/queryset/queryset.py /^ class Collaborator(EmbeddedDocument):$/;" c function:QuerySetTest.test_pull_nested -Comment mongoengine/docs/code/tumblelog.py /^class Comment(EmbeddedDocument):$/;" c -Comment mongoengine/tests/document/indexes.py /^ class Comment(EmbeddedDocument):$/;" c function:IndexesTest.test_index_with_pk -Comment mongoengine/tests/document/inheritance.py /^ class Comment(EmbeddedDocument):$/;" c function:InheritanceTest.test_allow_inheritance_embedded_document -Comment mongoengine/tests/document/instance.py /^ class Comment(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_recurs -Comment mongoengine/tests/document/instance.py /^ class Comment(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document -Comment mongoengine/tests/document/instance.py /^ class Comment(EmbeddedDocument):$/;" c function:InstanceTest.test_list_search_by_embedded -Comment mongoengine/tests/document/instance.py /^ class Comment(EmbeddedDocument):$/;" c function:InstanceTest.test_save_list -Comment mongoengine/tests/document/instance.py /^ class Comment(EmbeddedDocument):$/;" c function:InstanceTest.test_save_only_changed_fields_recursive -Comment mongoengine/tests/document/validation.py /^ class Comment(EmbeddedDocument):$/;" c function:ValidatorErrorTest.test_embedded_document_validation -Comment mongoengine/tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_validation -Comment mongoengine/tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_sequence_field -Comment mongoengine/tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_list_validation -Comment mongoengine/tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_validation -Comment mongoengine/tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_sorted_list_sorting -Comment mongoengine/tests/queryset/field_list.py /^ class Comment(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_exclude -Comment mongoengine/tests/queryset/field_list.py /^ class Comment(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_only_with_subfields -Comment mongoengine/tests/queryset/queryset.py /^ class Comment(Document):$/;" c function:QuerySetTest.test_ensure_index -Comment mongoengine/tests/queryset/queryset.py /^ class Comment(Document):$/;" c function:QuerySetTest.test_unset_reference -Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_bulk_insert -Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_exec_js_field_sub -Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_find_array_position -Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_array_position -Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_using_positional_operator -Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_using_positional_operator_embedded_document -Comment mongoengine/tests/queryset/queryset.py /^ class Comment(EmbeddedDocument):$/;" c function:QuerySetTest.test_updates_can_have_match_operators -Comment mongoengine/tests/queryset/transform.py /^ class Comment(EmbeddedDocument):$/;" c function:TransformTest.test_query_field_name -Comment mongoengine/tests/test_dereference.py /^ class Comment(Document):$/;" c function:FieldTest.test_list_lookup_not_checked_in_map -Comment tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_validation -Comment tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_sequence_field -Comment tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_list_validation -Comment tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_validation -Comment tests/fields/fields.py /^ class Comment(EmbeddedDocument):$/;" c function:FieldTest.test_sorted_list_sorting -Comments mongoengine/tests/fields/fields.py /^ class Comments(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.setUp -Comments mongoengine/tests/fields/fields.py /^ class Comments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_inheritance -Comments tests/fields/fields.py /^ class Comments(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.setUp -Comments tests/fields/fields.py /^ class Comments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_inheritance -Company mongoengine/tests/fields/fields.py /^ class Company(Document):$/;" c function:FieldTest.test_undefined_reference -Company tests/fields/fields.py /^ class Company(Document):$/;" c function:FieldTest.test_undefined_reference -CompareStats mongoengine/tests/document/instance.py /^ class CompareStats(Document):$/;" c function:InstanceTest.test_reference_inheritance -ComplexBaseField mongoengine/mongoengine/base/fields.py /^class ComplexBaseField(BaseField):$/;" c -ComplexDateTimeField mongoengine/fields.py /^class ComplexDateTimeField(StringField):$/;" c -ComplexDateTimeField mongoengine/mongoengine/fields.py /^class ComplexDateTimeField(StringField):$/;" c -CompoundKey mongoengine/tests/document/indexes.py /^ class CompoundKey(EmbeddedDocument):$/;" c function:IndexesTest.test_compound_key_embedded -ConnectionTest mongoengine/tests/test_connection.py /^class ConnectionTest(unittest.TestCase):$/;" c -ConnectionTest mongoengine/tests/test_replicaset_connection.py /^class ConnectionTest(unittest.TestCase):$/;" c -ContextManagersTest mongoengine/tests/test_context_managers.py /^class ContextManagersTest(unittest.TestCase):$/;" c -Continent mongoengine/tests/queryset/queryset.py /^ class Continent(EmbeddedDocument):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField -Country mongoengine/tests/queryset/queryset.py /^ class Country(EmbeddedDocument):$/;" c function:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField -CustomData mongoengine/tests/fields/fields.py /^ class CustomData(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_custom_data -CustomData tests/fields/fields.py /^ class CustomData(Document):$/;" c function:EmbeddedDocumentListFieldTestCase.test_custom_data -CustomNamingTest mongoengine/tests/document/class_methods.py /^ class CustomNamingTest(Document):$/;" c function:ClassMethodsTest.test_collection_naming -CustomQuerySet mongoengine/tests/queryset/queryset.py /^ class CustomQuerySet(QuerySet):$/;" c function:QuerySetTest.test_custom_querysets -CustomQuerySet mongoengine/tests/queryset/queryset.py /^ class CustomQuerySet(QuerySet):$/;" c function:QuerySetTest.test_custom_querysets_inherited -CustomQuerySet mongoengine/tests/queryset/queryset.py /^ class CustomQuerySet(QuerySet):$/;" c function:QuerySetTest.test_custom_querysets_inherited_direct -CustomQuerySet mongoengine/tests/queryset/queryset.py /^ class CustomQuerySet(QuerySet):$/;" c function:QuerySetTest.test_custom_querysets_set_manager_directly -CustomQuerySetManager mongoengine/tests/queryset/queryset.py /^ class CustomQuerySetManager(QuerySetManager):$/;" c function:QuerySetTest.test_custom_querysets_inherited_direct -CustomQuerySetManager mongoengine/tests/queryset/queryset.py /^ class CustomQuerySetManager(QuerySetManager):$/;" c function:QuerySetTest.test_custom_querysets_managers_directly -CustomQuerySetManager mongoengine/tests/queryset/queryset.py /^ class CustomQuerySetManager(QuerySetManager):$/;" c function:QuerySetTest.test_custom_querysets_set_manager_directly -Customer mongoengine/tests/document/indexes.py /^ class Customer(Document):$/;" c function:IndexesTest.test_unique_and_indexes -D mongoengine/tests/fields/fields.py /^ class D(Document):$/;" c function:FieldTest.test_ensure_unique_default_instances -D tests/fields/fields.py /^ class D(Document):$/;" c function:FieldTest.test_ensure_unique_default_instances -DEFAULT_CONNECTION_NAME mongoengine/mongoengine/connection.py /^DEFAULT_CONNECTION_NAME = 'default'$/;" v -DENY mongoengine/mongoengine/queryset/base.py /^DENY = 3$/;" v -DESCRIPTION mongoengine/setup.py /^DESCRIPTION = ($/;" v -DOMAIN_REGEX mongoengine/fields.py /^ DOMAIN_REGEX = re.compile($/;" v class:EmailField -DOMAIN_REGEX mongoengine/mongoengine/fields.py /^ DOMAIN_REGEX = re.compile($/;" v class:EmailField -DO_NOTHING mongoengine/mongoengine/queryset/base.py /^DO_NOTHING = 0$/;" v -Data mongoengine/tests/queryset/queryset.py /^ class Data(Document):$/;" c function:QuerySetTest.test_iteration_within_iteration -Data mongoengine/tests/queryset/queryset.py /^ class Data(Document):$/;" c function:QuerySetTest.test_len_during_iteration -Data mongoengine/tests/queryset/queryset.py /^ class Data(EmbeddedDocument):$/;" c function:QuerySetTest.test_item_frequencies_with_null_embedded -Date mongoengine/tests/document/indexes.py /^ class Date(EmbeddedDocument):$/;" c function:IndexesTest.test_embedded_document_index -Date mongoengine/tests/document/indexes.py /^ class Date(EmbeddedDocument):$/;" c function:IndexesTest.test_unique_with -DateCreatedDocument mongoengine/tests/document/inheritance.py /^ class DateCreatedDocument(Document):$/;" c function:InheritanceTest.test_document_inheritance -DateDoc mongoengine/tests/test_connection.py /^ class DateDoc(Document):$/;" c function:ConnectionTest.test_datetime -DateTimeField mongoengine/fields.py /^class DateTimeField(BaseField):$/;" c -DateTimeField mongoengine/mongoengine/fields.py /^class DateTimeField(BaseField):$/;" c -DateUpdatedDocument mongoengine/tests/document/inheritance.py /^ class DateUpdatedDocument(Document):$/;" c function:InheritanceTest.test_document_inheritance -DeReference mongoengine/mongoengine/dereference.py /^class DeReference(object):$/;" c -DecimalField mongoengine/fields.py /^class DecimalField(BaseField):$/;" c -DecimalField mongoengine/mongoengine/fields.py /^class DecimalField(BaseField):$/;" c -DefaultNamingTest mongoengine/tests/document/class_methods.py /^ class DefaultNamingTest(Document):$/;" c function:ClassMethodsTest.test_collection_naming -DeltaTest mongoengine/tests/document/delta.py /^class DeltaTest(unittest.TestCase):$/;" c -DemoFile mongoengine/tests/fields/file_tests.py /^ class DemoFile(Document):$/;" c function:FileTest.test_file_field_optional -DicDoc mongoengine/tests/queryset/transform.py /^ class DicDoc(Document):$/;" c function:TransformTest.test_transform_update -DictField mongoengine/fields.py /^class DictField(ComplexBaseField):$/;" c -DictField mongoengine/mongoengine/fields.py /^class DictField(ComplexBaseField):$/;" c -DictFieldTest mongoengine/tests/fields/fields.py /^ class DictFieldTest(Document):$/;" c function:FieldTest.test_invalid_dict_value -DictFieldTest tests/fields/fields.py /^ class DictFieldTest(Document):$/;" c function:FieldTest.test_invalid_dict_value -Dish mongoengine/tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document -Dish mongoengine/tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document_choices -Dish mongoengine/tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_list_embedded_document_choices -Dish tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document -Dish tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_embedded_document_choices -Dish tests/fields/fields.py /^ class Dish(EmbeddedDocument):$/;" c function:FieldTest.test_generic_list_embedded_document_choices -Doc mongoengine/tests/document/delta.py /^ class Doc(DocClass):$/;" c function:DeltaTest.delta -Doc mongoengine/tests/document/delta.py /^ class Doc(DocClass):$/;" c function:DeltaTest.delta_db_field -Doc mongoengine/tests/document/delta.py /^ class Doc(DocClass):$/;" c function:DeltaTest.delta_recursive -Doc mongoengine/tests/document/delta.py /^ class Doc(DocClass):$/;" c function:DeltaTest.delta_recursive_db_field -Doc mongoengine/tests/document/delta.py /^ class Doc(Document):$/;" c function:DeltaTest.test_delta_for_nested_map_fields -Doc mongoengine/tests/document/delta.py /^ class Doc(DynamicDocument):$/;" c function:DeltaTest.test_dynamic_delta -Doc mongoengine/tests/document/dynamic.py /^ class Doc(DynamicDocument):$/;" c function:DynamicTest.test_complex_embedded_document_validation -Doc mongoengine/tests/document/dynamic.py /^ class Doc(DynamicDocument):$/;" c function:DynamicTest.test_complex_embedded_documents -Doc mongoengine/tests/document/dynamic.py /^ class Doc(DynamicDocument):$/;" c function:DynamicTest.test_embedded_dynamic_document -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_can_save_false_values -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_can_save_if_not_included -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_embedded_document_complex_instance -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_embedded_document_complex_instance_no_use_db_field -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_embedded_document_instance -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_kwargs_complex -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_kwargs_simple -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_reload_referencing -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_save_abstract_document -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_update_list_field -Doc mongoengine/tests/document/instance.py /^ class Doc(Document):$/;" c function:InstanceTest.test_update_unique_field -Doc mongoengine/tests/document/instance.py /^ class Doc(DynamicDocument):$/;" c function:InstanceTest.test_can_save_false_values_dynamic -Doc mongoengine/tests/document/instance.py /^ class Doc(DynamicDocument):$/;" c function:InstanceTest.test_spaces_in_keys -Doc mongoengine/tests/document/json_serialisation.py /^ class Doc(Document):$/;" c function:TestJson.test_json_complex -Doc mongoengine/tests/document/json_serialisation.py /^ class Doc(Document):$/;" c function:TestJson.test_json_names -Doc mongoengine/tests/document/json_serialisation.py /^ class Doc(Document):$/;" c function:TestJson.test_json_simple -Doc mongoengine/tests/document/validation.py /^ class Doc(Document):$/;" c function:ValidatorErrorTest.test_embedded_db_field_validate -Doc mongoengine/tests/document/validation.py /^ class Doc(Document):$/;" c function:ValidatorErrorTest.test_embedded_weakref -Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dictfield_dump_document -Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamic_fields_class -Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamic_fields_embedded_class -Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document -Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_generic_reference_filter_by_dbref -Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_generic_reference_filter_by_objectid -Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_sparse_field -Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_undefined_field_exception -Doc mongoengine/tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_undefined_field_exception_with_strict -Doc mongoengine/tests/queryset/modify.py /^class Doc(Document):$/;" c -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_array_average -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_array_sum -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_embedded_array_average -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_embedded_array_sum -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_embedded_average -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_embedded_sum -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_json_complex -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_json_simple -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_query_generic_embedded_document -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_reload_embedded_docs_instance -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_reload_list_embedded_docs_instance -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_repr -Doc mongoengine/tests/queryset/queryset.py /^ class Doc(Document):$/;" c function:QuerySetTest.test_update_validate -Doc mongoengine/tests/queryset/transform.py /^ class Doc(Document):$/;" c function:TransformTest.test_last_field_name_like_operator -Doc mongoengine/tests/queryset/transform.py /^ class Doc(Document):$/;" c function:TransformTest.test_raw_and_merging -Doc mongoengine/tests/queryset/transform.py /^ class Doc(Document):$/;" c function:TransformTest.test_transform_update -Doc mongoengine/tests/queryset/transform.py /^ class Doc(Document):$/;" c function:TransformTest.test_type -Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dictfield_dump_document -Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamic_fields_class -Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamic_fields_embedded_class -Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document -Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_generic_reference_filter_by_dbref -Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_generic_reference_filter_by_objectid -Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_sparse_field -Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_undefined_field_exception -Doc tests/fields/fields.py /^ class Doc(Document):$/;" c function:FieldTest.test_undefined_field_exception_with_strict -Doc2 mongoengine/tests/fields/fields.py /^ class Doc2(Document):$/;" c function:FieldTest.test_dynamic_fields_class -Doc2 tests/fields/fields.py /^ class Doc2(Document):$/;" c function:FieldTest.test_dynamic_fields_class -Document mongoengine/mongoengine/document.py /^class Document(BaseDocument):$/;" c -DocumentMetaclass mongoengine/mongoengine/base/metaclasses.py /^class DocumentMetaclass(type):$/;" c -DoesNotExist mongoengine/mongoengine/errors.py /^class DoesNotExist(Exception):$/;" c -Dog mongoengine/tests/document/inheritance.py /^ class Dog(Animal):$/;" c class:InheritanceTest.test_allow_inheritance.Animal -Dog mongoengine/tests/document/inheritance.py /^ class Dog(Mammal): pass$/;" c function:InheritanceTest.test_external_subclasses -Dog mongoengine/tests/document/inheritance.py /^ class Dog(Mammal): pass$/;" c function:InheritanceTest.test_external_superclasses -Dog mongoengine/tests/document/inheritance.py /^ class Dog(Mammal): pass$/;" c function:InheritanceTest.test_polymorphic_queries -Dog mongoengine/tests/document/inheritance.py /^ class Dog(Mammal): pass$/;" c function:InheritanceTest.test_subclasses -Dog mongoengine/tests/document/inheritance.py /^ class Dog(Mammal): pass$/;" c function:InheritanceTest.test_superclasses -Dog mongoengine/tests/document/instance.py /^ class Dog(Mammal):$/;" c function:InstanceTest.test_polymorphic_references -Dog mongoengine/tests/fields/fields.py /^ class Dog(Mammal):$/;" c function:FieldTest.test_cls_field -Dog mongoengine/tests/queryset/queryset.py /^ class Dog(Animal):$/;" c function:QuerySetTest.test_cls_query_in_subclassed_docs -Dog tests/fields/fields.py /^ class Dog(Mammal):$/;" c function:FieldTest.test_cls_field -DoubleMixIn mongoengine/tests/document/instance.py /^ class DoubleMixIn(BaseMixIn):$/;" c function:InstanceTest.test_mixin_inheritance -Drink mongoengine/tests/document/inheritance.py /^ class Drink(Document):$/;" c function:InheritanceTest.test_inherited_collections -Drinker mongoengine/tests/document/inheritance.py /^ class Drinker(Document):$/;" c function:InheritanceTest.test_inherited_collections -Dummy mongoengine/tests/queryset/queryset.py /^ class Dummy(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_complex_cycle -Dummy mongoengine/tests/queryset/queryset.py /^ class Dummy(Document):$/;" c function:QuerySetTest.test_reverse_delete_rule_cascade_cycle -DuplicateQueryConditionsError mongoengine/mongoengine/queryset/visitor.py /^class DuplicateQueryConditionsError(InvalidQueryError):$/;" c -DynamicDocument mongoengine/mongoengine/document.py /^class DynamicDocument(Document):$/;" c -DynamicEmbeddedDocument mongoengine/mongoengine/document.py /^class DynamicEmbeddedDocument(EmbeddedDocument):$/;" c -DynamicField mongoengine/fields.py /^class DynamicField(BaseField):$/;" c -DynamicField mongoengine/mongoengine/fields.py /^class DynamicField(BaseField):$/;" c -DynamicNamingTest mongoengine/tests/document/class_methods.py /^ class DynamicNamingTest(Document):$/;" c function:ClassMethodsTest.test_collection_naming -DynamicTest mongoengine/tests/document/dynamic.py /^class DynamicTest(unittest.TestCase):$/;" c -EXCLUDE mongoengine/mongoengine/queryset/field_list.py /^ EXCLUDE = 0$/;" v class:QueryFieldList -Editor mongoengine/tests/document/instance.py /^ class Editor(self.Person):$/;" c function:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal -EmDoc mongoengine/tests/queryset/queryset.py /^ class EmDoc(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_validate -Email mongoengine/tests/document/instance.py /^ class Email(EmbeddedDocument):$/;" c function:InstanceTest.test_instance_is_set_on_setattr -Email mongoengine/tests/document/instance.py /^ class Email(EmbeddedDocument):$/;" c function:InstanceTest.test_instance_is_set_on_setattr_on_embedded_document_list -Email mongoengine/tests/queryset/field_list.py /^ class Email(Document):$/;" c function:OnlyExcludeAllTest.test_all_fields -Email mongoengine/tests/queryset/field_list.py /^ class Email(Document):$/;" c function:OnlyExcludeAllTest.test_exclude_only_combining -EmailField mongoengine/fields.py /^class EmailField(StringField):$/;" c -EmailField mongoengine/mongoengine/fields.py /^class EmailField(StringField):$/;" c -EmailUser mongoengine/tests/document/instance.py /^ class EmailUser(User):$/;" c class:InstanceTest.test_custom_id_field.User -EmailUser mongoengine/tests/document/instance.py /^ class EmailUser(User):$/;" c function:InstanceTest.test_custom_id_field -Embed mongoengine/tests/fields/fields.py /^ class Embed(EmbeddedDocument):$/;" c function:FieldTest.test_dynamic_fields_embedded_class -Embed mongoengine/tests/queryset/queryset.py /^ class Embed(EmbeddedDocument):$/;" c function:QuerySetTest.test_save_and_only_on_fields_with_default -Embed tests/fields/fields.py /^ class Embed(EmbeddedDocument):$/;" c function:FieldTest.test_dynamic_fields_embedded_class -Embedded mongoengine/tests/document/delta.py /^ class Embedded(EmbeddedClass):$/;" c function:DeltaTest.delta_recursive -Embedded mongoengine/tests/document/delta.py /^ class Embedded(EmbeddedClass):$/;" c function:DeltaTest.delta_recursive_db_field -Embedded mongoengine/tests/document/dynamic.py /^ class Embedded(DynamicEmbeddedDocument):$/;" c function:DynamicTest.test_complex_embedded_document_validation -Embedded mongoengine/tests/document/dynamic.py /^ class Embedded(DynamicEmbeddedDocument):$/;" c function:DynamicTest.test_complex_embedded_documents -Embedded mongoengine/tests/document/dynamic.py /^ class Embedded(DynamicEmbeddedDocument):$/;" c function:DynamicTest.test_embedded_dynamic_document -Embedded mongoengine/tests/document/instance.py /^ class Embedded(DynamicEmbeddedDocument):$/;" c function:InstanceTest.test_spaces_in_keys -Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_complex_instance -Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_complex_instance_no_use_db_field -Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_equality -Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_instance -Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_kwargs_complex -Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_kwargs_simple -Embedded mongoengine/tests/document/instance.py /^ class Embedded(EmbeddedDocument):$/;" c function:InstanceTest.test_reload_referencing -Embedded mongoengine/tests/document/json_serialisation.py /^ class Embedded(EmbeddedDocument):$/;" c function:TestJson.test_json_names -Embedded mongoengine/tests/document/json_serialisation.py /^ class Embedded(EmbeddedDocument):$/;" c function:TestJson.test_json_simple -Embedded mongoengine/tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_db_field -Embedded mongoengine/tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_mapfield_db_field -Embedded mongoengine/tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_mapfield_numerical_index -Embedded mongoengine/tests/queryset/queryset.py /^ class Embedded(EmbeddedDocument):$/;" c function:QuerySetTest.test_json_simple -Embedded tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_db_field -Embedded tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_mapfield_db_field -Embedded tests/fields/fields.py /^ class Embedded(EmbeddedDocument):$/;" c function:FieldTest.test_mapfield_numerical_index -EmbeddedDoc mongoengine/tests/document/delta.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:DeltaTest.test_lower_level_mark_as_changed -EmbeddedDoc mongoengine/tests/document/delta.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:DeltaTest.test_nested_nested_fields_mark_as_changed -EmbeddedDoc mongoengine/tests/document/delta.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:DeltaTest.test_upper_level_mark_as_changed -EmbeddedDoc mongoengine/tests/document/instance.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:InstanceTest.test_can_save_if_not_included -EmbeddedDoc mongoengine/tests/document/json_serialisation.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:TestJson.test_json_complex -EmbeddedDoc mongoengine/tests/queryset/queryset.py /^ class EmbeddedDoc(EmbeddedDocument):$/;" c function:QuerySetTest.test_json_complex -EmbeddedDocument mongoengine/mongoengine/document.py /^class EmbeddedDocument(BaseDocument):$/;" c -EmbeddedDocumentField mongoengine/fields.py /^class EmbeddedDocumentField(BaseField):$/;" c -EmbeddedDocumentField mongoengine/mongoengine/fields.py /^class EmbeddedDocumentField(BaseField):$/;" c -EmbeddedDocumentList mongoengine/mongoengine/base/datastructures.py /^class EmbeddedDocumentList(BaseList):$/;" c -EmbeddedDocumentListField mongoengine/fields.py /^class EmbeddedDocumentListField(ListField):$/;" c -EmbeddedDocumentListField mongoengine/mongoengine/fields.py /^class EmbeddedDocumentListField(ListField):$/;" c -EmbeddedDocumentListFieldTestCase mongoengine/tests/fields/fields.py /^class EmbeddedDocumentListFieldTestCase(MongoDBTestCase):$/;" c -EmbeddedDocumentListFieldTestCase tests/fields/fields.py /^class EmbeddedDocumentListFieldTestCase(MongoDBTestCase):$/;" c -EmbeddedItem mongoengine/tests/queryset/transform.py /^ class EmbeddedItem(EmbeddedDocument):$/;" c function:TransformTest.test_last_field_name_like_operator -EmbeddedLocation mongoengine/tests/document/indexes.py /^ class EmbeddedLocation(EmbeddedDocument):$/;" c function:IndexesTest.test_explicit_geo2d_index_embedded -EmbeddedNumber mongoengine/tests/queryset/field_list.py /^ class EmbeddedNumber(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_slicing_nested_fields -EmbeddedOcurrence mongoengine/tests/fields/fields.py /^ class EmbeddedOcurrence(EmbeddedDocument):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded -EmbeddedOcurrence mongoengine/tests/fields/fields.py /^ class EmbeddedOcurrence(EmbeddedDocument):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded -EmbeddedOcurrence tests/fields/fields.py /^ class EmbeddedOcurrence(EmbeddedDocument):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded -EmbeddedOcurrence tests/fields/fields.py /^ class EmbeddedOcurrence(EmbeddedDocument):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded -EmbeddedRole mongoengine/tests/document/delta.py /^ class EmbeddedRole(EmbeddedDocument):$/;" c function:DeltaTest.test_delta_for_nested_map_fields -EmbeddedUser mongoengine/tests/document/delta.py /^ class EmbeddedUser(EmbeddedDocument):$/;" c function:DeltaTest.test_delta_for_nested_map_fields -EmbeddedWithSparseUnique mongoengine/tests/fields/fields.py /^ class EmbeddedWithSparseUnique(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field -EmbeddedWithSparseUnique tests/fields/fields.py /^ class EmbeddedWithSparseUnique(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field -EmbeddedWithUnique mongoengine/tests/fields/fields.py /^ class EmbeddedWithUnique(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field -EmbeddedWithUnique tests/fields/fields.py /^ class EmbeddedWithUnique(EmbeddedDocument):$/;" c function:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field -Employee mongoengine/tests/document/dynamic.py /^ class Employee(self.Person):$/;" c function:DynamicTest.test_inheritance -Employee mongoengine/tests/document/inheritance.py /^ class Employee(Person):$/;" c function:InheritanceTest.test_inheritance_meta_data -Employee mongoengine/tests/document/inheritance.py /^ class Employee(Person):$/;" c function:InheritanceTest.test_inheritance_to_mongo_keys -Employee mongoengine/tests/document/instance.py /^ class Employee(Person):$/;" c function:InstanceTest.test_embedded_document_to_mongo -Employee mongoengine/tests/document/instance.py /^ class Employee(self.Person):$/;" c function:InstanceTest.test_save_embedded_document -Employee mongoengine/tests/document/instance.py /^ class Employee(self.Person):$/;" c function:InstanceTest.test_updating_an_embedded_document -Employee mongoengine/tests/fields/fields.py /^ class Employee(Document):$/;" c function:FieldTest.test_recursive_reference -Employee mongoengine/tests/queryset/field_list.py /^ class Employee(self.Person):$/;" c function:OnlyExcludeAllTest.test_only -Employee mongoengine/tests/test_dereference.py /^ class Employee(Document):$/;" c function:FieldTest.test_recursive_reference -Employee tests/fields/fields.py /^ class Employee(Document):$/;" c function:FieldTest.test_recursive_reference -EmployeeDetails mongoengine/tests/document/instance.py /^ class EmployeeDetails(EmbeddedDocument):$/;" c function:InstanceTest.test_save_embedded_document -EmployeeDetails mongoengine/tests/document/instance.py /^ class EmployeeDetails(EmbeddedDocument):$/;" c function:InstanceTest.test_updating_an_embedded_document -EnumField mongoengine/tests/fields/fields.py /^ class EnumField(BaseField):$/;" c function:FieldTest.test_tuples_as_tuples -EnumField tests/fields/fields.py /^ class EnumField(BaseField):$/;" c function:FieldTest.test_tuples_as_tuples -EuropeanCity mongoengine/tests/document/inheritance.py /^ class EuropeanCity(City):$/;" c function:InheritanceTest.test_abstract_handle_ids_in_metaclass_properly -EuropeanCity mongoengine/tests/document/inheritance.py /^ class EuropeanCity(City):$/;" c function:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class -EuropeanCity mongoengine/tests/document/inheritance.py /^ class EuropeanCity(City):$/;" c function:InheritanceTest.test_auto_id_vs_non_pk_id_field -Event mongoengine/tests/fields/geo.py /^ class Event(Document):$/;" c function:GeoFieldTest.test_geopoint_embedded_indexes -Event mongoengine/tests/fields/geo.py /^ class Event(Document):$/;" c function:GeoFieldTest.test_indexes_2dsphere -Event mongoengine/tests/fields/geo.py /^ class Event(Document):$/;" c function:GeoFieldTest.test_indexes_2dsphere_embedded -Event mongoengine/tests/fields/geo.py /^ class Event(Document):$/;" c function:GeoFieldTest.test_indexes_geopoint -Event mongoengine/tests/queryset/geo.py /^ class Event(Document):$/;" c function:GeoQueriesTest._create_event_data -Event mongoengine/tests/queryset/geo.py /^ class Event(Document):$/;" c function:GeoQueriesTest._test_embedded -Event mongoengine/tests/queryset/transform.py /^ class Event(Document):$/;" c function:TransformTest.test_understandable_error_raised -EvilHuman mongoengine/tests/document/inheritance.py /^ class EvilHuman(Human):$/;" c class:InheritanceTest.test_abstract_documents.Human -Example mongoengine/tests/queryset/queryset.py /^ class Example(Document):$/;" c function:QuerySetTest.test_can_have_field_same_name_as_query_operator -ExplicitId mongoengine/tests/test_signals.py /^ class ExplicitId(Document):$/;" c function:SignalTests.setUp -ExtendedBlogPost mongoengine/tests/document/indexes.py /^ class ExtendedBlogPost(BlogPost):$/;" c function:IndexesTest._index_test_inheritance -Extensible mongoengine/tests/fields/fields.py /^ class Extensible(Document):$/;" c function:FieldTest.test_complex_mapfield -Extensible tests/fields/fields.py /^ class Extensible(Document):$/;" c function:FieldTest.test_complex_mapfield -Extra mongoengine/tests/queryset/queryset.py /^ class Extra(EmbeddedDocument):$/;" c function:QuerySetTest.test_item_frequencies_with_null_embedded -Family mongoengine/tests/queryset/queryset.py /^ class Family(Document):$/;" c function:QuerySetTest.test_map_reduce_custom_output -Feed mongoengine/tests/document/instance.py /^ class Feed(Document):$/;" c function:InstanceTest.test_query_count_when_saving -FieldDoesNotExist mongoengine/mongoengine/errors.py /^class FieldDoesNotExist(Exception):$/;" c -FieldTest mongoengine/tests/fields/fields.py /^class FieldTest(MongoDBTestCase):$/;" c -FieldTest mongoengine/tests/test_dereference.py /^class FieldTest(unittest.TestCase):$/;" c -FieldTest tests/fields/fields.py /^class FieldTest(MongoDBTestCase):$/;" c -FileField mongoengine/fields.py /^class FileField(BaseField):$/;" c -FileField mongoengine/mongoengine/fields.py /^class FileField(BaseField):$/;" c -FileTest mongoengine/tests/fields/file_tests.py /^class FileTest(MongoDBTestCase):$/;" c -FinalDocument mongoengine/tests/document/inheritance.py /^ class FinalDocument(Document):$/;" c function:InheritanceTest.test_allow_inheritance_abstract_document -FindAndModifyTest mongoengine/tests/queryset/modify.py /^class FindAndModifyTest(unittest.TestCase):$/;" c -Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_abstract_documents -Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_external_subclasses -Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_external_superclasses -Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_polymorphic_queries -Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_subclasses -Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal): pass$/;" c function:InheritanceTest.test_superclasses -Fish mongoengine/tests/document/inheritance.py /^ class Fish(Animal):$/;" c function:InheritanceTest.test_dynamic_declarations -Fish mongoengine/tests/document/instance.py /^ class Fish(Animal):$/;" c function:InstanceTest.test_polymorphic_references -Fish mongoengine/tests/fields/fields.py /^ class Fish(Animal):$/;" c function:FieldTest.test_cls_field -Fish tests/fields/fields.py /^ class Fish(Animal):$/;" c function:FieldTest.test_cls_field -FloatField mongoengine/fields.py /^class FloatField(BaseField):$/;" c -FloatField mongoengine/mongoengine/fields.py /^class FloatField(BaseField):$/;" c -Foo mongoengine/tests/document/instance.py /^ class Foo(Document):$/;" c function:InstanceTest.test_duplicate_db_fields_raise_invalid_document_error -Foo mongoengine/tests/document/instance.py /^ class Foo(Document):$/;" c function:InstanceTest.test_reload_doesnt_exist -Foo mongoengine/tests/document/instance.py /^ class Foo(Document):$/;" c function:InstanceTest.test_save_max_recursion_not_hit_with_file_field -Foo mongoengine/tests/document/instance.py /^ class Foo(Document):$/;" c function:InstanceTest.test_two_way_reverse_delete_rule -Foo mongoengine/tests/document/instance.py /^ class Foo(EmbeddedDocument):$/;" c function:InstanceTest.test_shard_key_in_embedded_document -Foo mongoengine/tests/document/instance.py /^ class Foo(EmbeddedDocument, NameMixin):$/;" c function:InstanceTest.test_object_mixins -Foo mongoengine/tests/fields/fields.py /^ class Foo(Base):$/;" c function:FieldTest.test_inherited_sequencefield -Foo mongoengine/tests/fields/fields.py /^ class Foo(Base):$/;" c function:FieldTest.test_no_inherited_sequencefield -Foo mongoengine/tests/fields/fields.py /^ class Foo(Document):$/;" c function:FieldTest.test_list_field_passed_in_value -Foo mongoengine/tests/fields/fields.py /^ class Foo(Document):$/;" c function:FieldTest.test_reference_miss -Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_custom_manager_overriding_objects_works -Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_distinct_ListField_ReferenceField -Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_distinct_handles_references -Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_distinct_handles_references_to_alias -Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_inherit_objects -Foo mongoengine/tests/queryset/queryset.py /^ class Foo(Document):$/;" c function:QuerySetTest.test_inherit_objects_override -Foo mongoengine/tests/queryset/queryset.py /^ class Foo(EmbeddedDocument):$/;" c function:QuerySetTest.test_elem_match -Foo mongoengine/tests/queryset/queryset.py /^ class Foo(EmbeddedDocument):$/;" c function:QuerySetTest.test_pull_in_genericembedded_field -Foo mongoengine/tests/queryset/transform.py /^ class Foo(Document):$/;" c function:TransformTest.test_raw_query_and_Q_objects -Foo mongoengine/tests/test_dereference.py /^ class Foo(Document):$/;" c function:FieldTest.test_document_reload_no_inheritance -Foo tests/fields/fields.py /^ class Foo(Base):$/;" c function:FieldTest.test_inherited_sequencefield -Foo tests/fields/fields.py /^ class Foo(Base):$/;" c function:FieldTest.test_no_inherited_sequencefield -Foo tests/fields/fields.py /^ class Foo(Document):$/;" c function:FieldTest.test_list_field_passed_in_value -Foo tests/fields/fields.py /^ class Foo(Document):$/;" c function:FieldTest.test_reference_miss -FooBar mongoengine/tests/document/instance.py /^ class FooBar(Document):$/;" c function:InstanceTest.test_set_unset_one_operation -GEO_OPERATORS mongoengine/mongoengine/queryset/transform.py /^GEO_OPERATORS = ('within_distance', 'within_spherical_distance',$/;" v -GenericEmbeddedDocumentField mongoengine/fields.py /^class GenericEmbeddedDocumentField(BaseField):$/;" c -GenericEmbeddedDocumentField mongoengine/mongoengine/fields.py /^class GenericEmbeddedDocumentField(BaseField):$/;" c -GenericLazyReferenceField mongoengine/fields.py /^class GenericLazyReferenceField(GenericReferenceField):$/;" c -GenericLazyReferenceField mongoengine/mongoengine/fields.py /^class GenericLazyReferenceField(GenericReferenceField):$/;" c -GenericLazyReferenceFieldTest mongoengine/tests/fields/fields.py /^class GenericLazyReferenceFieldTest(MongoDBTestCase):$/;" c -GenericLazyReferenceFieldTest tests/fields/fields.py /^class GenericLazyReferenceFieldTest(MongoDBTestCase):$/;" c -GenericReferenceField mongoengine/fields.py /^class GenericReferenceField(BaseField):$/;" c -GenericReferenceField mongoengine/mongoengine/fields.py /^class GenericReferenceField(BaseField):$/;" c -GeoFieldTest mongoengine/tests/fields/geo.py /^class GeoFieldTest(unittest.TestCase):$/;" c -GeoJsonBaseField mongoengine/mongoengine/base/fields.py /^class GeoJsonBaseField(BaseField):$/;" c -GeoPointField mongoengine/fields.py /^class GeoPointField(BaseField):$/;" c -GeoPointField mongoengine/mongoengine/fields.py /^class GeoPointField(BaseField):$/;" c -GeoQueriesTest mongoengine/tests/queryset/geo.py /^class GeoQueriesTest(MongoDBTestCase):$/;" c -GridDocument mongoengine/tests/fields/file_tests.py /^ class GridDocument(Document):$/;" c function:FileTest.test_file_field_no_default -GridFSError mongoengine/fields.py /^class GridFSError(Exception):$/;" c -GridFSError mongoengine/mongoengine/fields.py /^class GridFSError(Exception):$/;" c -GridFSProxy mongoengine/fields.py /^class GridFSProxy(object):$/;" c -GridFSProxy mongoengine/mongoengine/fields.py /^class GridFSProxy(object):$/;" c -Group mongoengine/tests/document/instance.py /^ class Group(Document):$/;" c function:InstanceTest.test_switch_db_instance -Group mongoengine/tests/fields/fields.py /^ class Group(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference -Group mongoengine/tests/fields/fields.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference -Group mongoengine/tests/fields/fields.py /^ class Group(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list -Group mongoengine/tests/queryset/queryset.py /^ class Group(Document):$/;" c function:QuerySetTest.test_update_value_conversion -Group mongoengine/tests/test_context_managers.py /^ class Group(Document):$/;" c function:ContextManagersTest.test_no_dereference_context_manager_dbref -Group mongoengine/tests/test_context_managers.py /^ class Group(Document):$/;" c function:ContextManagersTest.test_no_dereference_context_manager_object_id -Group mongoengine/tests/test_context_managers.py /^ class Group(Document):$/;" c function:ContextManagersTest.test_switch_collection_context_manager -Group mongoengine/tests/test_context_managers.py /^ class Group(Document):$/;" c function:ContextManagersTest.test_switch_db_context_manager -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_dict_field -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_dict_field_no_field_inheritance -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_generic_reference -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_generic_reference_map_field -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_handle_old_style_references -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_field_complex -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false_stores_as_type -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_map_field_reference -Group mongoengine/tests/test_dereference.py /^ class Group(Document):$/;" c function:FieldTest.test_migrate_references -Group tests/fields/fields.py /^ class Group(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference -Group tests/fields/fields.py /^ class Group(Document):$/;" c function:FieldTest.test_list_item_dereference -Group tests/fields/fields.py /^ class Group(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list -Guppy mongoengine/tests/document/inheritance.py /^ class Guppy(Fish): pass$/;" c function:InheritanceTest.test_abstract_documents -Guppy mongoengine/tests/document/inheritance.py /^ class Guppy(Fish): pass$/;" c function:InheritanceTest.test_external_subclasses -Guppy mongoengine/tests/document/inheritance.py /^ class Guppy(Fish): pass$/;" c function:InheritanceTest.test_external_superclasses -Guppy mongoengine/tests/document/inheritance.py /^ class Guppy(Fish): pass$/;" c function:InheritanceTest.test_subclasses -Guppy mongoengine/tests/document/inheritance.py /^ class Guppy(Fish): pass$/;" c function:InheritanceTest.test_superclasses -HAS_PIL mongoengine/tests/fields/file_tests.py /^ HAS_PIL = False$/;" v -HAS_PIL mongoengine/tests/fields/file_tests.py /^ HAS_PIL = True$/;" v -HandleNoneFields mongoengine/tests/fields/fields.py /^ class HandleNoneFields(Document):$/;" c function:FieldTest.test_not_required_handles_none_from_database -HandleNoneFields mongoengine/tests/fields/fields.py /^ class HandleNoneFields(Document):$/;" c function:FieldTest.test_not_required_handles_none_in_update -HandleNoneFields tests/fields/fields.py /^ class HandleNoneFields(Document):$/;" c function:FieldTest.test_not_required_handles_none_from_database -HandleNoneFields tests/fields/fields.py /^ class HandleNoneFields(Document):$/;" c function:FieldTest.test_not_required_handles_none_in_update -Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_abstract_documents -Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_external_subclasses -Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_external_superclasses -Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_polymorphic_queries -Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_subclasses -Human mongoengine/tests/document/inheritance.py /^ class Human(Mammal): pass$/;" c function:InheritanceTest.test_superclasses -Human mongoengine/tests/document/instance.py /^ class Human(Mammal):$/;" c function:InstanceTest.test_polymorphic_references -Human mongoengine/tests/fields/fields.py /^ class Human(Mammal):$/;" c function:FieldTest.test_cls_field -Human tests/fields/fields.py /^ class Human(Mammal):$/;" c function:FieldTest.test_cls_field -IS_PYMONGO_3 mongoengine/mongoengine/python_support.py /^ IS_PYMONGO_3 = False$/;" v -IS_PYMONGO_3 mongoengine/mongoengine/python_support.py /^ IS_PYMONGO_3 = True$/;" v -ITER_CHUNK_SIZE mongoengine/mongoengine/queryset/queryset.py /^ITER_CHUNK_SIZE = 100$/;" v -Image mongoengine/fields.py /^ Image = None$/;" v -Image mongoengine/mongoengine/fields.py /^ Image = None$/;" v -ImageField mongoengine/fields.py /^class ImageField(FileField):$/;" c -ImageField mongoengine/mongoengine/fields.py /^class ImageField(FileField):$/;" c -ImageGridFsProxy mongoengine/fields.py /^class ImageGridFsProxy(GridFSProxy):$/;" c -ImageGridFsProxy mongoengine/mongoengine/fields.py /^class ImageGridFsProxy(GridFSProxy):$/;" c -ImageOps mongoengine/fields.py /^ ImageOps = None$/;" v -ImageOps mongoengine/mongoengine/fields.py /^ ImageOps = None$/;" v -ImagePost mongoengine/docs/code/tumblelog.py /^class ImagePost(Post):$/;" c -ImproperlyConfigured mongoengine/fields.py /^class ImproperlyConfigured(Exception):$/;" c -ImproperlyConfigured mongoengine/mongoengine/fields.py /^class ImproperlyConfigured(Exception):$/;" c -IndexesTest mongoengine/tests/document/indexes.py /^class IndexesTest(unittest.TestCase):$/;" c -Info mongoengine/tests/fields/fields.py /^ class Info(EmbeddedDocument):$/;" c function:FieldTest.test_map_field_unicode -Info tests/fields/fields.py /^ class Info(EmbeddedDocument):$/;" c function:FieldTest.test_map_field_unicode -InheritanceTest mongoengine/tests/document/inheritance.py /^class InheritanceTest(unittest.TestCase):$/;" c -InheritedAbstractNamingTest mongoengine/tests/document/class_methods.py /^ class InheritedAbstractNamingTest(BaseDocument):$/;" c function:ClassMethodsTest.test_collection_naming -InheritedDocumentFailTest mongoengine/tests/all_warnings/__init__.py /^ class InheritedDocumentFailTest(NonAbstractBase):$/;" c function:AllWarnings.test_document_collection_syntax_warning -InstanceTest mongoengine/tests/document/instance.py /^class InstanceTest(unittest.TestCase):$/;" c -Int64 mongoengine/fields.py /^ Int64 = long$/;" v -Int64 mongoengine/mongoengine/fields.py /^ Int64 = long$/;" v -Int64 mongoengine/tests/fields/fields.py /^ Int64 = long$/;" v -Int64 tests/fields/fields.py /^ Int64 = long$/;" v -IntField mongoengine/fields.py /^class IntField(BaseField):$/;" c -IntField mongoengine/mongoengine/fields.py /^class IntField(BaseField):$/;" c -IntPair mongoengine/tests/queryset/queryset.py /^ class IntPair(Document):$/;" c function:QuerySetTest.test_where -IntegerSetting mongoengine/tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_complex_mapfield -IntegerSetting mongoengine/tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_dictfield_complex -IntegerSetting mongoengine/tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_list_field_complex -IntegerSetting tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_complex_mapfield -IntegerSetting tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_dictfield_complex -IntegerSetting tests/fields/fields.py /^ class IntegerSetting(SettingBase):$/;" c function:FieldTest.test_list_field_complex -InvalidCollectionError mongoengine/mongoengine/document.py /^class InvalidCollectionError(Exception):$/;" c -InvalidDocumentError mongoengine/mongoengine/errors.py /^class InvalidDocumentError(Exception):$/;" c -InvalidQueryError mongoengine/mongoengine/errors.py /^class InvalidQueryError(Exception):$/;" c -Item mongoengine/tests/queryset/queryset.py /^ class Item(Document):$/;" c function:QuerySetTest.test_add_to_set_each -Item mongoengine/tests/queryset/visitor.py /^ class Item(Document):$/;" c function:QTest.test_chained_q_or_filtering -Job mongoengine/tests/document/class_methods.py /^ class Job(Document):$/;" c function:ClassMethodsTest.test_register_delete_rule -Job mongoengine/tests/document/instance.py /^ class Job(Document):$/;" c function:InstanceTest.test_do_not_save_unchanged_references -Job mongoengine/tests/document/instance.py /^ class Job(EmbeddedDocument):$/;" c function:InstanceTest.setUp -LONG_DESCRIPTION mongoengine/setup.py /^ LONG_DESCRIPTION = fin.read()$/;" v -LONG_DESCRIPTION mongoengine/setup.py /^ LONG_DESCRIPTION = None$/;" v -LastLogin mongoengine/tests/queryset/queryset.py /^ class LastLogin(EmbeddedDocument):$/;" c function:QuerySetTest.test_as_pymongo -LazyReference mongoengine/mongoengine/base/datastructures.py /^class LazyReference(DBRef):$/;" c -LazyReferenceField mongoengine/fields.py /^class LazyReferenceField(BaseField):$/;" c -LazyReferenceField mongoengine/mongoengine/fields.py /^class LazyReferenceField(BaseField):$/;" c -LazyReferenceFieldTest mongoengine/tests/fields/fields.py /^class LazyReferenceFieldTest(MongoDBTestCase):$/;" c -LazyReferenceFieldTest tests/fields/fields.py /^class LazyReferenceFieldTest(MongoDBTestCase):$/;" c -LineStringField mongoengine/fields.py /^class LineStringField(GeoJsonBaseField):$/;" c -LineStringField mongoengine/mongoengine/fields.py /^class LineStringField(GeoJsonBaseField):$/;" c -Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference -Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_choices -Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_document_not_registered -Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_list -Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_list_choices -Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_string_choices -Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_unicode_url_validation -Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_url_scheme_validation -Link mongoengine/tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_url_validation -Link mongoengine/tests/queryset/queryset.py /^ class Link(Document):$/;" c function:QuerySetTest.test_map_reduce_finalize -Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference -Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_choices -Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_document_not_registered -Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_list -Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_list_choices -Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_generic_reference_string_choices -Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_unicode_url_validation -Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_url_scheme_validation -Link tests/fields/fields.py /^ class Link(Document):$/;" c function:FieldTest.test_url_validation -LinkPost mongoengine/docs/code/tumblelog.py /^class LinkPost(Post):$/;" c -LisDoc mongoengine/tests/queryset/transform.py /^ class LisDoc(Document):$/;" c function:TransformTest.test_transform_update -ListField mongoengine/fields.py /^class ListField(ComplexBaseField):$/;" c -ListField mongoengine/mongoengine/fields.py /^class ListField(ComplexBaseField):$/;" c -Locale mongoengine/tests/queryset/queryset.py /^ class Locale(EmbeddedDocument):$/;" c function:QuerySetTest.test_scalar_embedded -Location mongoengine/tests/document/instance.py /^ class Location(Document):$/;" c function:InstanceTest.test_document_registry_regressions -Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_geo_indexes_recursion -Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_geopoint_validation -Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_linestring_validation -Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_multilinestring_validation -Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_multipoint_validation -Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_multipolygon_validation -Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_point_validation -Location mongoengine/tests/fields/geo.py /^ class Location(Document):$/;" c function:GeoFieldTest.test_polygon_validation -Location mongoengine/tests/queryset/geo.py /^ class Location(Document):$/;" c function:GeoQueriesTest.test_2dsphere_linestring_sets_correctly -Location mongoengine/tests/queryset/geo.py /^ class Location(Document):$/;" c function:GeoQueriesTest.test_2dsphere_point_sets_correctly -Location mongoengine/tests/queryset/geo.py /^ class Location(Document):$/;" c function:GeoQueriesTest.test_geojson_PolygonField -Location mongoengine/tests/queryset/transform.py /^ class Location(Document):$/;" c function:TransformTest.test_geojson_LineStringField -Location mongoengine/tests/queryset/transform.py /^ class Location(Document):$/;" c function:TransformTest.test_geojson_PointField -Location mongoengine/tests/queryset/transform.py /^ class Location(Document):$/;" c function:TransformTest.test_geojson_PolygonField -Log mongoengine/tests/document/indexes.py /^ class Log(Document):$/;" c function:IndexesTest.test_ttl_indexes -Log mongoengine/tests/document/instance.py /^ class Log(Document):$/;" c function:InstanceTest.test_capped_collection -Log mongoengine/tests/document/instance.py /^ class Log(Document):$/;" c function:InstanceTest.test_capped_collection_default -Log mongoengine/tests/document/instance.py /^ class Log(Document):$/;" c function:InstanceTest.test_capped_collection_no_max_size_problems -Log mongoengine/tests/fields/fields.py /^ class Log(Document):$/;" c function:FieldTest.test_map_field_lookup -Log mongoengine/tests/fields/geo.py /^ class Log(Document):$/;" c function:GeoFieldTest.test_geo_indexes_auto_index -Log mongoengine/tests/queryset/queryset.py /^ class Log(Document):$/;" c function:QuerySetTest.test_delete_with_limits -Log tests/fields/fields.py /^ class Log(Document):$/;" c function:FieldTest.test_map_field_lookup -LogEntry mongoengine/tests/document/instance.py /^ class LogEntry(Document):$/;" c function:InstanceTest.test_shard_key -LogEntry mongoengine/tests/document/instance.py /^ class LogEntry(Document):$/;" c function:InstanceTest.test_shard_key_primary -LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_complexdatetime_storage -LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_complexdatetime_usage -LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime -LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_tz_aware_mark_as_changed -LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_usage -LogEntry mongoengine/tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_validation -LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_complexdatetime_storage -LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_complexdatetime_usage -LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime -LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_tz_aware_mark_as_changed -LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_usage -LogEntry tests/fields/fields.py /^ class LogEntry(Document):$/;" c function:FieldTest.test_datetime_validation -LongField mongoengine/fields.py /^class LongField(BaseField):$/;" c -LongField mongoengine/mongoengine/fields.py /^class LongField(BaseField):$/;" c -LookUpError mongoengine/mongoengine/errors.py /^class LookUpError(AttributeError):$/;" c -MATCH_OPERATORS mongoengine/mongoengine/queryset/transform.py /^MATCH_OPERATORS = (COMPARISON_OPERATORS + GEO_OPERATORS +$/;" v -MONGO_TEST_DB mongoengine/tests/utils.py /^MONGO_TEST_DB = 'mongoenginetest'$/;" v -Macro mongoengine/tests/document/instance.py /^ class Macro(EmbeddedDocument):$/;" c function:InstanceTest.test_complex_nesting_document_and_embedded_document -Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal):$/;" c class:InheritanceTest.test_allow_inheritance_abstract_document.Animal -Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal):$/;" c class:InheritanceTest.test_cant_turn_off_inheritance_on_subclass.Animal -Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal): pass$/;" c function:InheritanceTest.test_external_subclasses -Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal): pass$/;" c function:InheritanceTest.test_external_superclasses -Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal): pass$/;" c function:InheritanceTest.test_polymorphic_queries -Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal): pass$/;" c function:InheritanceTest.test_subclasses -Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal): pass$/;" c function:InheritanceTest.test_superclasses -Mammal mongoengine/tests/document/inheritance.py /^ class Mammal(Animal):$/;" c function:InheritanceTest.test_abstract_documents -Mammal mongoengine/tests/document/instance.py /^ class Mammal(Animal):$/;" c function:InstanceTest.test_polymorphic_references -Mammal mongoengine/tests/fields/fields.py /^ class Mammal(Animal):$/;" c function:FieldTest.test_cls_field -Mammal tests/fields/fields.py /^ class Mammal(Animal):$/;" c function:FieldTest.test_cls_field -MapField mongoengine/fields.py /^class MapField(DictField):$/;" c -MapField mongoengine/mongoengine/fields.py /^class MapField(DictField):$/;" c -MapReduceDocument mongoengine/mongoengine/document.py /^class MapReduceDocument(object):$/;" c -Member mongoengine/tests/fields/fields.py /^ class Member(Document):$/;" c function:FieldTest.test_reference_query_conversion -Member mongoengine/tests/fields/fields.py /^ class Member(Document):$/;" c function:FieldTest.test_reference_query_conversion_dbref -Member mongoengine/tests/fields/fields.py /^ class Member(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion -Member mongoengine/tests/fields/fields.py /^ class Member(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion -Member mongoengine/tests/fields/fields.py /^ class Member(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref -Member mongoengine/tests/queryset/queryset.py /^ class Member(EmbeddedDocument):$/;" c function:QuerySetTest.test_mapfield_update -Member mongoengine/tests/queryset/queryset.py /^ class Member(EmbeddedDocument):$/;" c function:QuerySetTest.test_no_dereference_embedded_doc -Member tests/fields/fields.py /^ class Member(Document):$/;" c function:FieldTest.test_reference_query_conversion -Member tests/fields/fields.py /^ class Member(Document):$/;" c function:FieldTest.test_reference_query_conversion_dbref -Member tests/fields/fields.py /^ class Member(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion -Member tests/fields/fields.py /^ class Member(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion -Member tests/fields/fields.py /^ class Member(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref -Message mongoengine/tests/queryset/queryset.py /^ class Message(Document):$/;" c function:QuerySetTest.test_set_list_embedded_documents -Message mongoengine/tests/test_dereference.py /^ class Message(Document):$/;" c function:FieldTest.test_document_reload_reference_integrity -Message mongoengine/tests/test_dereference.py /^ class Message(Document):$/;" c function:FieldTest.test_list_lookup_not_checked_in_map -MetaDict mongoengine/mongoengine/base/metaclasses.py /^class MetaDict(dict):$/;" c -Mineral mongoengine/tests/fields/fields.py /^ class Mineral(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices -Mineral tests/fields/fields.py /^ class Mineral(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices -Mixin mongoengine/tests/fixtures.py /^class Mixin(object):$/;" c -ModeratorComments mongoengine/tests/fields/fields.py /^ class ModeratorComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_invalid -ModeratorComments tests/fields/fields.py /^ class ModeratorComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_invalid -MongoDBTestCase mongoengine/tests/utils.py /^class MongoDBTestCase(unittest.TestCase):$/;" c -MongoEngineConnectionError mongoengine/mongoengine/connection.py /^class MongoEngineConnectionError(Exception):$/;" c -MongoUser mongoengine/tests/document/indexes.py /^ class MongoUser(User):$/;" c function:IndexesTest.test_disable_index_creation -Mother mongoengine/tests/fields/fields.py /^ class Mother(Document):$/;" c function:FieldTest.test_abstract_reference_base_type -Mother tests/fields/fields.py /^ class Mother(Document):$/;" c function:FieldTest.test_abstract_reference_base_type -MultiLineStringField mongoengine/fields.py /^class MultiLineStringField(GeoJsonBaseField):$/;" c -MultiLineStringField mongoengine/mongoengine/fields.py /^class MultiLineStringField(GeoJsonBaseField):$/;" c -MultiPointField mongoengine/fields.py /^class MultiPointField(GeoJsonBaseField):$/;" c -MultiPointField mongoengine/mongoengine/fields.py /^class MultiPointField(GeoJsonBaseField):$/;" c -MultiPolygonField mongoengine/fields.py /^class MultiPolygonField(GeoJsonBaseField):$/;" c -MultiPolygonField mongoengine/mongoengine/fields.py /^class MultiPolygonField(GeoJsonBaseField):$/;" c -MultipleObjectsReturned mongoengine/mongoengine/errors.py /^class MultipleObjectsReturned(Exception):$/;" c -MyDoc mongoengine/tests/document/delta.py /^ class MyDoc(Document):$/;" c function:DeltaTest.test_lower_level_mark_as_changed -MyDoc mongoengine/tests/document/delta.py /^ class MyDoc(Document):$/;" c function:DeltaTest.test_nested_nested_fields_mark_as_changed -MyDoc mongoengine/tests/document/delta.py /^ class MyDoc(Document):$/;" c function:DeltaTest.test_upper_level_mark_as_changed -MyDoc mongoengine/tests/document/indexes.py /^ class MyDoc(Document):$/;" c function:IndexesTest.test_build_index_spec_is_not_destructive -MyDoc mongoengine/tests/document/indexes.py /^ class MyDoc(Document):$/;" c function:IndexesTest.test_sparse_compound_indexes -MyDoc mongoengine/tests/document/indexes.py /^ class MyDoc(Document):$/;" c function:IndexesTest.test_string_indexes -MyDoc mongoengine/tests/fields/fields.py /^ class MyDoc(Document):$/;" c function:FieldTest.test_datetime_from_empty_string -MyDoc mongoengine/tests/fields/fields.py /^ class MyDoc(Document):$/;" c function:FieldTest.test_datetime_from_whitespace_string -MyDoc mongoengine/tests/queryset/field_list.py /^ class MyDoc(Document):$/;" c function:OnlyExcludeAllTest.test_mix_slice_with_other_fields -MyDoc mongoengine/tests/queryset/field_list.py /^ class MyDoc(Document):$/;" c function:OnlyExcludeAllTest.test_mixing_only_exclude -MyDoc mongoengine/tests/queryset/field_list.py /^ class MyDoc(Document):$/;" c function:OnlyExcludeAllTest.test_slicing -MyDoc mongoengine/tests/queryset/queryset.py /^ class MyDoc(Document):$/;" c function:QuerySetTest.test_count_and_none -MyDoc mongoengine/tests/queryset/queryset.py /^ class MyDoc(Document):$/;" c function:QuerySetTest.test_dictfield_key_looks_like_a_digit -MyDoc mongoengine/tests/queryset/queryset.py /^ class MyDoc(DynamicDocument):$/;" c function:QuerySetTest.test_update_upsert_looks_like_a_digit -MyDoc tests/fields/fields.py /^ class MyDoc(Document):$/;" c function:FieldTest.test_datetime_from_empty_string -MyDoc tests/fields/fields.py /^ class MyDoc(Document):$/;" c function:FieldTest.test_datetime_from_whitespace_string -MyDocument mongoengine/tests/document/class_methods.py /^ class MyDocument(BaseDocument):$/;" c function:ClassMethodsTest.test_collection_naming -MyDocument mongoengine/tests/document/inheritance.py /^ class MyDocument(DateCreatedDocument, DateUpdatedDocument):$/;" c class:InheritanceTest.test_document_inheritance.DateUpdatedDocument -MyPerson mongoengine/tests/document/instance.py /^ class MyPerson(self.Person):$/;" c function:InstanceTest.test_from_son -NON_FIELD_ERRORS mongoengine/mongoengine/base/document.py /^NON_FIELD_ERRORS = '__all__'$/;" v -NULLIFY mongoengine/mongoengine/queryset/base.py /^NULLIFY = 1$/;" v -NameMixin mongoengine/tests/document/instance.py /^ class NameMixin(object):$/;" c function:InstanceTest.test_object_mixins -Namespace mongoengine/mongoengine/signals.py /^ class Namespace(object):$/;" c -NewDocumentPickleTest mongoengine/tests/fixtures.py /^class NewDocumentPickleTest(Document):$/;" c -News mongoengine/tests/queryset/queryset.py /^ class News(Document):$/;" c function:QuerySetTest.test_text_indexes -NicePlace mongoengine/tests/document/instance.py /^ class NicePlace(Place):$/;" c function:InstanceTest.test_document_not_registered -NoDeclaredType mongoengine/tests/fields/fields.py /^ class NoDeclaredType(Document):$/;" c class:FieldTest.test_mapfield.Simple -NoDeclaredType tests/fields/fields.py /^ class NoDeclaredType(Document):$/;" c class:FieldTest.test_mapfield.Simple -Noddy mongoengine/tests/queryset/queryset.py /^ class Noddy(Document):$/;" c function:QuerySetTest.test_no_cache -Node mongoengine/tests/document/instance.py /^ class Node(Document):$/;" c function:InstanceTest.test_complex_nesting_document_and_embedded_document -NodesSystem mongoengine/tests/document/instance.py /^ class NodesSystem(Document):$/;" c function:InstanceTest.test_complex_nesting_document_and_embedded_document -NonAbstractBase mongoengine/tests/all_warnings/__init__.py /^ class NonAbstractBase(Document):$/;" c function:AllWarnings.test_document_collection_syntax_warning -NotRegistered mongoengine/mongoengine/errors.py /^class NotRegistered(Exception):$/;" c -NotUniqueError mongoengine/mongoengine/errors.py /^class NotUniqueError(OperationError):$/;" c -Number mongoengine/tests/queryset/queryset.py /^ class Number(Document):$/;" c function:QuerySetTest.test_clone -Number mongoengine/tests/queryset/queryset.py /^ class Number(Document):$/;" c function:QuerySetTest.test_order_then_filter -Number mongoengine/tests/queryset/queryset.py /^ class Number(Document):$/;" c function:QuerySetTest.test_order_works_with_custom_db_field_names -Number mongoengine/tests/queryset/queryset.py /^ class Number(Document):$/;" c function:QuerySetTest.test_order_works_with_primary -Number2 mongoengine/tests/queryset/queryset.py /^ class Number2(Document):$/;" c function:QuerySetTest.test_using -Numbers mongoengine/tests/queryset/field_list.py /^ class Numbers(Document):$/;" c function:OnlyExcludeAllTest.test_slicing_fields -Numbers mongoengine/tests/queryset/field_list.py /^ class Numbers(Document):$/;" c function:OnlyExcludeAllTest.test_slicing_nested_fields -ONLY mongoengine/mongoengine/queryset/field_list.py /^ ONLY = 1$/;" v class:QueryFieldList -OR mongoengine/mongoengine/queryset/visitor.py /^ OR = 1$/;" v class:QNode -ObjectIdField mongoengine/mongoengine/base/fields.py /^class ObjectIdField(BaseField):$/;" c -Occurrence mongoengine/tests/document/instance.py /^ class Occurrence(EmbeddedDocument):$/;" c function:InstanceTest.test_invalid_son -Ocorrence mongoengine/tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields -Ocorrence mongoengine/tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields -Ocorrence mongoengine/tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_get_and_save -Ocorrence mongoengine/tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields -Ocorrence tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields -Ocorrence tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields -Ocorrence tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_get_and_save -Ocorrence tests/fields/fields.py /^ class Ocorrence(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_not_set -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_passthrough -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set -Ocurrence mongoengine/tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_simple -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_bad_set -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_embedded -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_not_set -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_passthrough -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set -Ocurrence tests/fields/fields.py /^ class Ocurrence(Document):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_simple -OldMixinNamingConvention mongoengine/tests/document/class_methods.py /^ class OldMixinNamingConvention(Document, BaseMixin):$/;" c function:ClassMethodsTest.test_collection_naming -OldNamingConvention mongoengine/tests/document/class_methods.py /^ class OldNamingConvention(BaseDocument):$/;" c function:ClassMethodsTest.test_collection_naming -OnlyExcludeAllTest mongoengine/tests/queryset/field_list.py /^class OnlyExcludeAllTest(unittest.TestCase):$/;" c -OperationError mongoengine/mongoengine/errors.py /^class OperationError(Exception):$/;" c -Organization mongoengine/tests/document/delta.py /^ class Organization(DocClass2):$/;" c function:DeltaTest.circular_reference_deltas -Organization mongoengine/tests/document/delta.py /^ class Organization(DocClass2):$/;" c function:DeltaTest.circular_reference_deltas_2 -Organization mongoengine/tests/document/delta.py /^ class Organization(Document):$/;" c function:DeltaTest.test_referenced_object_changed_attributes -Organization mongoengine/tests/document/instance.py /^ class Organization(Document):$/;" c function:InstanceTest.test_query_count_when_saving -Organization mongoengine/tests/queryset/queryset.py /^ class Organization(Document):$/;" c function:QuerySetTest.test_get_changed_fields_query_count -Organization mongoengine/tests/queryset/queryset.py /^ class Organization(Document):$/;" c function:QuerySetTest.test_no_dereference -Organization mongoengine/tests/queryset/queryset.py /^ class Organization(Document):$/;" c function:QuerySetTest.test_no_dereference_embedded_doc -Organization mongoengine/tests/queryset/queryset.py /^ class Organization(Document):$/;" c function:QuerySetTest.test_scalar -Other mongoengine/tests/test_dereference.py /^ class Other(EmbeddedDocument):$/;" c function:FieldTest.test_circular_tree_reference -Owner mongoengine/tests/fields/fields.py /^ class Owner(EmbeddedDocument):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields -Owner mongoengine/tests/fields/fields.py /^ class Owner(EmbeddedDocument):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields -Owner tests/fields/fields.py /^ class Owner(EmbeddedDocument):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_fields -Owner tests/fields/fields.py /^ class Owner(EmbeddedDocument):$/;" c function:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields -PAPER mongoengine/docs/Makefile /^PAPER =$/;" m -PAPEROPT_a4 mongoengine/docs/Makefile /^PAPEROPT_a4 = -D latex_paper_size=a4$/;" m -PAPEROPT_letter mongoengine/docs/Makefile /^PAPEROPT_letter = -D latex_paper_size=letter$/;" m -PULL mongoengine/mongoengine/queryset/base.py /^PULL = 4$/;" v -Page mongoengine/tests/document/instance.py /^ class Page(Document):$/;" c function:InstanceTest.test_list_search_by_embedded -Page mongoengine/tests/document/instance.py /^ class Page(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_update -Page mongoengine/tests/document/instance.py /^ class Page(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_update_after_save -Page mongoengine/tests/document/instance.py /^ class Page(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_update_db_field -Page mongoengine/tests/test_dereference.py /^ class Page(Document):$/;" c function:FieldTest.test_dereferencing_embedded_listfield_referencefield -Parameter mongoengine/tests/document/instance.py /^ class Parameter(EmbeddedDocument):$/;" c function:InstanceTest.test_complex_nesting_document_and_embedded_document -Parent mongoengine/tests/document/validation.py /^ class Parent(Document):$/;" c function:ValidatorErrorTest.test_parent_reference_in_child_document -Parent mongoengine/tests/document/validation.py /^ class Parent(Document):$/;" c function:ValidatorErrorTest.test_parent_reference_set_as_attribute_in_child_document -Parent mongoengine/tests/fields/geo.py /^ class Parent(Document):$/;" c function:GeoFieldTest.test_geo_indexes_recursion -Parents mongoengine/tests/document/instance.py /^ class Parents(EmbeddedDocument):$/;" c function:InstanceTest.test_invalid_reverse_delete_rule_raise_errors -Pay mongoengine/tests/queryset/queryset.py /^ class Pay(EmbeddedDocument):$/;" c function:QuerySetTest.test_embedded_array_average -Pay mongoengine/tests/queryset/queryset.py /^ class Pay(EmbeddedDocument):$/;" c function:QuerySetTest.test_embedded_array_sum -Pay mongoengine/tests/queryset/queryset.py /^ class Pay(EmbeddedDocument):$/;" c function:QuerySetTest.test_embedded_average -Pay mongoengine/tests/queryset/queryset.py /^ class Pay(EmbeddedDocument):$/;" c function:QuerySetTest.test_embedded_sum -Person mongoengine/tests/document/class_methods.py /^ class Person(Document):$/;" c function:ClassMethodsTest.setUp -Person mongoengine/tests/document/class_methods.py /^ class Person(Document):$/;" c function:ClassMethodsTest.test_collection_name_and_primary -Person mongoengine/tests/document/class_methods.py /^ class Person(Document):$/;" c function:ClassMethodsTest.test_custom_collection_name_operations -Person mongoengine/tests/document/delta.py /^ class Person(DocClass1):$/;" c function:DeltaTest.circular_reference_deltas -Person mongoengine/tests/document/delta.py /^ class Person(DocClass1):$/;" c function:DeltaTest.circular_reference_deltas_2 -Person mongoengine/tests/document/delta.py /^ class Person(Document):$/;" c function:DeltaTest.setUp -Person mongoengine/tests/document/delta.py /^ class Person(DynamicDocument):$/;" c function:DeltaTest.test_delta_for_dynamic_documents -Person mongoengine/tests/document/dynamic.py /^ class Person(DynamicDocument):$/;" c function:DynamicTest.setUp -Person mongoengine/tests/document/dynamic.py /^ class Person(DynamicDocument):$/;" c function:DynamicTest.test_complex_dynamic_document_queries -Person mongoengine/tests/document/dynamic.py /^ class Person(DynamicDocument):$/;" c function:DynamicTest.test_dynamic_and_embedded -Person mongoengine/tests/document/dynamic.py /^ class Person(DynamicDocument):$/;" c function:DynamicTest.test_dynamic_and_embedded_dict_access -Person mongoengine/tests/document/dynamic.py /^ class Person(DynamicDocument):$/;" c function:DynamicTest.test_dynamic_embedded_works_with_only -Person mongoengine/tests/document/indexes.py /^ class Person(Document):$/;" c function:IndexesTest.setUp -Person mongoengine/tests/document/indexes.py /^ class Person(Document):$/;" c function:IndexesTest.test_embedded_document_index_meta -Person mongoengine/tests/document/indexes.py /^ class Person(UserBase):$/;" c function:IndexesTest.test_abstract_index_inheritance -Person mongoengine/tests/document/inheritance.py /^ class Person(Document):$/;" c function:InheritanceTest.test_inheritance_meta_data -Person mongoengine/tests/document/inheritance.py /^ class Person(Document):$/;" c function:InheritanceTest.test_inheritance_to_mongo_keys -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.setUp -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_data_contains_id_field -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_db_embedded_doc_field_load -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_db_field_load -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_default_values -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_do_not_save_unchanged_references -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_falsey_pk -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_not_saved_eq -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_cascade_kwargs -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_cascade_meta_false -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_cascade_meta_true -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_cascades -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_cascades_generically -Person mongoengine/tests/document/instance.py /^ class Person(Document):$/;" c function:InstanceTest.test_save_max_recursion_not_hit -Person mongoengine/tests/document/instance.py /^ class Person(DynamicDocument):$/;" c function:InstanceTest.test_mixed_creation_dynamic -Person mongoengine/tests/document/instance.py /^ class Person(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_to_mongo -Person mongoengine/tests/document/validation.py /^ class Person(BasePerson):$/;" c function:ValidatorErrorTest.test_fields_rewrite -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_auto_sync -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_update_all -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_boolean_validation -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_dbref_reference_fields -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_dbref_to_mongo -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_comparison -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_storage -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_validation -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_nothing_set -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_set_to_None -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_when_deleting_value -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_when_setting_to_None -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_embedded_document_validation -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_float_validation -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_embedded_document -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_embedded_document_choices -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_list_embedded_document_choices -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_reference_is_none -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_int_validation -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_multiple_sequence_fields -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_multiple_sequence_fields_on_docs -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_object_id_validation -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_objectid_reference_fields -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_required_values -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_get_next_value -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_sequence_name -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_value_decorator -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_string_validation -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_uuid_field_binary -Person mongoengine/tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_uuid_field_string -Person mongoengine/tests/queryset/field_list.py /^ class Person(Document):$/;" c function:OnlyExcludeAllTest.setUp -Person mongoengine/tests/queryset/pickable.py /^class Person(Document):$/;" c -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.setUp -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_bool_performance -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_bool_with_ordering -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_bool_with_ordering_from_meta_dict -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_cached_queryset -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_get_changed_fields_query_count -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_item_frequencies_null_values -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_item_frequencies_on_embedded -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_item_frequencies_with_null_embedded -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_loop_over_invalid_id_does_not_crash -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_map_reduce_custom_output -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_no_cached_queryset -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_queryset_aggregation_framework -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_scalar_decimal -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_scalar_embedded -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_scalar_generic_reference_field -Person mongoengine/tests/queryset/queryset.py /^ class Person(Document):$/;" c function:QuerySetTest.test_scalar_reference_field -Person mongoengine/tests/queryset/visitor.py /^ class Person(Document):$/;" c function:QTest.setUp -Person mongoengine/tests/queryset/visitor.py /^ class Person(Document):$/;" c function:QTest.test_empty_q -Person mongoengine/tests/test_dereference.py /^ class Person(Document):$/;" c function:FieldTest.test_circular_reference -Person mongoengine/tests/test_dereference.py /^ class Person(Document):$/;" c function:FieldTest.test_circular_reference_on_self -Person mongoengine/tests/test_dereference.py /^ class Person(Document):$/;" c function:FieldTest.test_circular_tree_reference -Person mongoengine/tests/test_dereference.py /^ class Person(Document):$/;" c function:FieldTest.test_dict_in_dbref_instance -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_auto_sync -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_update_all -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_boolean_validation -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_dbref_reference_fields -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_dbref_to_mongo -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_comparison -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_storage -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_decimal_validation -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_nothing_set -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_set_to_None -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_when_deleting_value -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_default_values_when_setting_to_None -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_embedded_document_validation -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_float_validation -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_embedded_document -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_embedded_document_choices -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_list_embedded_document_choices -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_generic_reference_is_none -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_int_validation -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_multiple_sequence_fields -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_multiple_sequence_fields_on_docs -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_object_id_validation -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_objectid_reference_fields -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_required_values -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_get_next_value -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_sequence_name -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_sequence_field_value_decorator -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_string_validation -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_uuid_field_binary -Person tests/fields/fields.py /^ class Person(Document):$/;" c function:FieldTest.test_uuid_field_string -PersonAuto mongoengine/tests/fields/fields.py /^ class PersonAuto(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_decimal -PersonAuto tests/fields/fields.py /^ class PersonAuto(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_decimal -PersonMeta mongoengine/tests/queryset/queryset.py /^ class PersonMeta(EmbeddedDocument):$/;" c function:QuerySetTest.setUp -PersonPreferences mongoengine/tests/fields/fields.py /^ class PersonPreferences(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_validation -PersonPreferences tests/fields/fields.py /^ class PersonPreferences(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_validation -Persone mongoengine/tests/fields/fields.py /^ class Persone(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled -Persone tests/fields/fields.py /^ class Persone(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled -Phone mongoengine/tests/queryset/queryset.py /^ class Phone(EmbeddedDocument):$/;" c function:QuerySetTest.test_item_frequencies_on_embedded -PickleDynamicEmbedded mongoengine/tests/fixtures.py /^class PickleDynamicEmbedded(DynamicEmbeddedDocument):$/;" c -PickleDynamicTest mongoengine/tests/fixtures.py /^class PickleDynamicTest(DynamicDocument):$/;" c -PickleEmbedded mongoengine/tests/fixtures.py /^class PickleEmbedded(EmbeddedDocument):$/;" c -PickleSignalsTest mongoengine/tests/fixtures.py /^class PickleSignalsTest(Document):$/;" c -PickleTest mongoengine/tests/fixtures.py /^class PickleTest(Document):$/;" c -Pike mongoengine/tests/document/inheritance.py /^ class Pike(Fish):$/;" c function:InheritanceTest.test_dynamic_declarations -Place mongoengine/tests/document/indexes.py /^ class Place(Document):$/;" c function:IndexesTest.test_create_geohaystack_index -Place mongoengine/tests/document/indexes.py /^ class Place(Document):$/;" c function:IndexesTest.test_explicit_geo2d_index -Place mongoengine/tests/document/indexes.py /^ class Place(Document):$/;" c function:IndexesTest.test_explicit_geo2d_index_embedded -Place mongoengine/tests/document/indexes.py /^ class Place(Document):$/;" c function:IndexesTest.test_explicit_geohaystack_index -Place mongoengine/tests/document/indexes.py /^ class Place(Document):$/;" c function:IndexesTest.test_explicit_geosphere_index -Place mongoengine/tests/document/instance.py /^ class Place(Document):$/;" c function:InstanceTest.test_document_not_registered -Place mongoengine/tests/queryset/geo.py /^ class Place(Document):$/;" c function:GeoQueriesTest.test_aspymongo_with_only -Playlist mongoengine/tests/test_dereference.py /^ class Playlist(Document):$/;" c function:FieldTest.test_select_related_follows_embedded_referencefields -PlaylistItem mongoengine/tests/test_dereference.py /^ class PlaylistItem(EmbeddedDocument):$/;" c function:FieldTest.test_select_related_follows_embedded_referencefields -Point mongoengine/tests/queryset/geo.py /^ class Point(Document):$/;" c function:GeoQueriesTest.test_spherical_geospatial_operators -PointField mongoengine/fields.py /^class PointField(GeoJsonBaseField):$/;" c -PointField mongoengine/mongoengine/fields.py /^class PointField(GeoJsonBaseField):$/;" c -PolygonField mongoengine/fields.py /^class PolygonField(GeoJsonBaseField):$/;" c -PolygonField mongoengine/mongoengine/fields.py /^class PolygonField(GeoJsonBaseField):$/;" c -Post mongoengine/docs/code/tumblelog.py /^class Post(Document):$/;" c -Post mongoengine/tests/document/instance.py /^ class Post(Document):$/;" c function:InstanceTest.test_reload_of_non_strict_with_special_field_name -Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_embedded_sequence_field -Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference -Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_choices -Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_choices_no_dereference -Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list -Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list_choices -Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list_item_modification -Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_string_choices -Post mongoengine/tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_recursive_validation -Post mongoengine/tests/queryset/queryset.py /^ class Post(Base):$/;" c function:QuerySetTest.test_custom_querysets_inherited -Post mongoengine/tests/queryset/queryset.py /^ class Post(Base):$/;" c function:QuerySetTest.test_custom_querysets_inherited_direct -Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_call_after_limits_set -Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_count_limit_and_skip -Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_custom_querysets -Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_custom_querysets_managers_directly -Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_custom_querysets_set_manager_directly -Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_unset_reference -Post mongoengine/tests/queryset/queryset.py /^ class Post(Document):$/;" c function:QuerySetTest.test_updates_can_have_match_operators -Post mongoengine/tests/queryset/queryset.py /^ class Post(EmbeddedDocument):$/;" c function:QuerySetTest.test_bulk_insert -Post mongoengine/tests/queryset/queryset.py /^ class Post(EmbeddedDocument):$/;" c function:QuerySetTest.test_find_array_position -Post mongoengine/tests/queryset/queryset.py /^ class Post(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_array_position -Post mongoengine/tests/queryset/visitor.py /^ class Post(Document):$/;" c function:QTest.test_q_with_dbref -Post mongoengine/tests/queryset/visitor.py /^ class Post(EmbeddedDocument):$/;" c function:QTest.test_chained_q_or_filtering -Post mongoengine/tests/test_dereference.py /^ class Post(Document):$/;" c function:FieldTest.test_list_of_lists_of_references -Post mongoengine/tests/test_dereference.py /^ class Post(EmbeddedDocument):$/;" c function:FieldTest.test_dereferencing_embedded_listfield_referencefield -Post mongoengine/tests/test_signals.py /^ class Post(Document):$/;" c function:SignalTests.setUp -Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_embedded_sequence_field -Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference -Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_choices -Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_choices_no_dereference -Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list -Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list_choices -Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_list_item_modification -Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_generic_reference_string_choices -Post tests/fields/fields.py /^ class Post(Document):$/;" c function:FieldTest.test_recursive_validation -PowerUser mongoengine/tests/fields/fields.py /^ class PowerUser(User):$/;" c function:FieldTest.test_embedded_document_inheritance -PowerUser tests/fields/fields.py /^ class PowerUser(User):$/;" c function:FieldTest.test_embedded_document_inheritance -Product mongoengine/tests/fields/fields.py /^ class Product(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields -Product mongoengine/tests/fields/fields.py /^ class Product(Document):$/;" c function:FieldTest.test_undefined_reference -Product mongoengine/tests/queryset/queryset.py /^ class Product(Document):$/;" c function:QuerySetTest.test_distinct_handles_db_field -Product tests/fields/fields.py /^ class Product(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields -Product tests/fields/fields.py /^ class Product(Document):$/;" c function:FieldTest.test_undefined_reference -Profile mongoengine/tests/queryset/queryset.py /^ class Profile(EmbeddedDocument):$/;" c function:QuerySetTest.test_scalar_embedded -Project mongoengine/tests/queryset/queryset.py /^ class Project(Document):$/;" c function:QuerySetTest.test_get_changed_fields_query_count -PutFile mongoengine/tests/fields/file_tests.py /^ class PutFile(Document):$/;" c function:FileTest.test_copyable -PutFile mongoengine/tests/fields/file_tests.py /^ class PutFile(Document):$/;" c function:FileTest.test_file_fields -Q mongoengine/mongoengine/queryset/visitor.py /^class Q(QNode):$/;" c -QCombination mongoengine/mongoengine/queryset/visitor.py /^class QCombination(QNode):$/;" c -QNode mongoengine/mongoengine/queryset/visitor.py /^class QNode(object):$/;" c -QNodeVisitor mongoengine/mongoengine/queryset/visitor.py /^class QNodeVisitor(object):$/;" c -QTest mongoengine/tests/queryset/visitor.py /^class QTest(unittest.TestCase):$/;" c -QueryCompilerVisitor mongoengine/mongoengine/queryset/visitor.py /^class QueryCompilerVisitor(QNodeVisitor):$/;" c -QueryFieldList mongoengine/mongoengine/queryset/field_list.py /^class QueryFieldList(object):$/;" c -QueryFieldListTest mongoengine/tests/queryset/field_list.py /^class QueryFieldListTest(unittest.TestCase):$/;" c -QuerySet mongoengine/mongoengine/queryset/queryset.py /^class QuerySet(BaseQuerySet):$/;" c -QuerySetManager mongoengine/mongoengine/queryset/manager.py /^class QuerySetManager(object):$/;" c -QuerySetNoCache mongoengine/mongoengine/queryset/queryset.py /^class QuerySetNoCache(BaseQuerySet):$/;" c -QuerySetNoDeRef mongoengine/mongoengine/queryset/queryset.py /^class QuerySetNoDeRef(QuerySet):$/;" c -QuerySetTest mongoengine/tests/queryset/queryset.py /^class QuerySetTest(unittest.TestCase):$/;" c -READ_PREF mongoengine/tests/test_replicaset_connection.py /^ READ_PREF = ReadPreference.SECONDARY$/;" v -READ_PREF mongoengine/tests/test_replicaset_connection.py /^ READ_PREF = ReadPreference.SECONDARY_ONLY$/;" v -READ_PREFERENCE mongoengine/mongoengine/connection.py /^ READ_PREFERENCE = False$/;" v -READ_PREFERENCE mongoengine/mongoengine/connection.py /^ READ_PREFERENCE = ReadPreference.PRIMARY$/;" v -RECURSIVE_REFERENCE_CONSTANT mongoengine/fields.py /^RECURSIVE_REFERENCE_CONSTANT = 'self'$/;" v -RECURSIVE_REFERENCE_CONSTANT mongoengine/mongoengine/fields.py /^RECURSIVE_REFERENCE_CONSTANT = 'self'$/;" v -REPR_OUTPUT_SIZE mongoengine/mongoengine/queryset/queryset.py /^REPR_OUTPUT_SIZE = 20$/;" v -RE_TYPE mongoengine/mongoengine/queryset/base.py /^RE_TYPE = type(re.compile(''))$/;" v -Rank mongoengine/tests/document/indexes.py /^ class Rank(EmbeddedDocument):$/;" c function:IndexesTest.test_embedded_document_index_meta -Rank mongoengine/tests/document/instance.py /^ class Rank(EmbeddedDocument):$/;" c function:InstanceTest.test_db_embedded_doc_field_load -Recipient mongoengine/tests/document/instance.py /^ class Recipient(Document):$/;" c function:InstanceTest.test_save -Record mongoengine/tests/document/instance.py /^ class Record(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_pull -RecursiveDocument mongoengine/tests/document/indexes.py /^ class RecursiveDocument(Document):$/;" c function:IndexesTest.test_recursive_embedded_objects_dont_break_indexes -RecursiveObject mongoengine/tests/document/indexes.py /^ class RecursiveObject(EmbeddedDocument):$/;" c function:IndexesTest.test_recursive_embedded_objects_dont_break_indexes -ReferenceField mongoengine/fields.py /^class ReferenceField(BaseField):$/;" c -ReferenceField mongoengine/mongoengine/fields.py /^class ReferenceField(BaseField):$/;" c -Relation mongoengine/tests/test_dereference.py /^ class Relation(EmbeddedDocument):$/;" c function:FieldTest.test_circular_reference -ReportDictField mongoengine/tests/document/indexes.py /^ class ReportDictField(Document):$/;" c function:IndexesTest.test_compound_key_dictfield -ReportEmbedded mongoengine/tests/document/indexes.py /^ class ReportEmbedded(Document):$/;" c function:IndexesTest.test_compound_key_embedded -Road mongoengine/tests/queryset/geo.py /^ class Road(Document):$/;" c function:GeoQueriesTest.test_linestring -Road mongoengine/tests/queryset/geo.py /^ class Road(Document):$/;" c function:GeoQueriesTest.test_polygon -Room mongoengine/tests/test_dereference.py /^ class Room(Document):$/;" c function:FieldTest.test_dict_in_dbref_instance -SPHINXBUILD mongoengine/docs/Makefile /^SPHINXBUILD = sphinx-build$/;" m -SPHINXOPTS mongoengine/docs/Makefile /^SPHINXOPTS =$/;" m -STRICT mongoengine/mongoengine/base/document.py /^ STRICT = False$/;" v class:BaseDocument -STRING_OPERATORS mongoengine/mongoengine/queryset/transform.py /^STRING_OPERATORS = ('contains', 'icontains', 'startswith',$/;" v -SaveConditionError mongoengine/mongoengine/errors.py /^class SaveConditionError(OperationError):$/;" c -SchemeLink mongoengine/tests/fields/fields.py /^ class SchemeLink(Document):$/;" c function:FieldTest.test_url_scheme_validation -SchemeLink tests/fields/fields.py /^ class SchemeLink(Document):$/;" c function:FieldTest.test_url_scheme_validation -Scores mongoengine/tests/queryset/queryset.py /^ class Scores(Document):$/;" c function:QuerySetTest.test_update_min_max -ScottishCat mongoengine/tests/queryset/queryset.py /^ class ScottishCat(Cat):$/;" c function:QuerySetTest.test_subclass_field_query -SequenceField mongoengine/fields.py /^class SequenceField(BaseField):$/;" c -SequenceField mongoengine/mongoengine/fields.py /^class SequenceField(BaseField):$/;" c -SetFile mongoengine/tests/fields/file_tests.py /^ class SetFile(Document):$/;" c function:FileTest.test_file_fields_set -SettingBase mongoengine/tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_complex_mapfield -SettingBase mongoengine/tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_dictfield_complex -SettingBase mongoengine/tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_list_field_complex -SettingBase tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_complex_mapfield -SettingBase tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_dictfield_complex -SettingBase tests/fields/fields.py /^ class SettingBase(EmbeddedDocument):$/;" c function:FieldTest.test_list_field_complex -SettingValue mongoengine/tests/queryset/queryset.py /^ class SettingValue(Document):$/;" c function:QuerySetTest.test_scalar_primary_key -Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_allow_using_sets_as_choices -Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_get_field_display -Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_accept_possible_value -Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_allow_no_value -Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_reject_unknown_value -Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_get_field_display -Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_validation -Shirt mongoengine/tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_validation_invalid_value -Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_allow_using_sets_as_choices -Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_get_field_display -Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_accept_possible_value -Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_allow_no_value -Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_choices_validation_reject_unknown_value -Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_get_field_display -Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_validation -Shirt tests/fields/fields.py /^ class Shirt(Document):$/;" c function:FieldTest.test_simple_choices_validation_invalid_value -Sibling mongoengine/tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_abstract_reference_base_type -Sibling mongoengine/tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_reference_abstract_class -Sibling mongoengine/tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_reference_class_with_abstract_parent -Sibling tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_abstract_reference_base_type -Sibling tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_reference_abstract_class -Sibling tests/fields/fields.py /^ class Sibling(Document):$/;" c function:FieldTest.test_reference_class_with_abstract_parent -SignalTests mongoengine/tests/test_signals.py /^class SignalTests(unittest.TestCase):$/;" c -Simple mongoengine/tests/document/instance.py /^ class Simple(Document):$/;" c function:InstanceTest.test_can_save_if_not_included -Simple mongoengine/tests/document/json_serialisation.py /^ class Simple(Document):$/;" c function:TestJson.test_json_complex -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_atomic_update_dict_field -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_complex_field_required -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_complex_field_same_value_not_changed -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_del_slice_marks_field_as_changed -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_dictfield_complex -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_dictfield_strict -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_complex -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_rejects_strings -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_strict -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_with_negative_indices -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_mapfield -Simple mongoengine/tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_slice_marks_field_as_changed -Simple mongoengine/tests/queryset/queryset.py /^ class Simple(Document):$/;" c function:QuerySetTest.test_json_complex -Simple mongoengine/tests/queryset/queryset.py /^ class Simple(Document):$/;" c function:QuerySetTest.test_update_using_positional_operator_matches_first -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_atomic_update_dict_field -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_complex_field_required -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_complex_field_same_value_not_changed -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_del_slice_marks_field_as_changed -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_dictfield_complex -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_dictfield_strict -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_complex -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_rejects_strings -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_strict -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_list_field_with_negative_indices -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_mapfield -Simple tests/fields/fields.py /^ class Simple(Document):$/;" c function:FieldTest.test_slice_marks_field_as_changed -SimpleList mongoengine/tests/test_dereference.py /^ class SimpleList(Document):$/;" c function:FieldTest.test_list_of_lists_of_references -SimplificationVisitor mongoengine/mongoengine/queryset/visitor.py /^class SimplificationVisitor(QNodeVisitor):$/;" c -Sister mongoengine/tests/fields/fields.py /^ class Sister(Sibling):$/;" c function:FieldTest.test_reference_abstract_class -Sister mongoengine/tests/fields/fields.py /^ class Sister(Sibling):$/;" c function:FieldTest.test_reference_class_with_abstract_parent -Sister tests/fields/fields.py /^ class Sister(Sibling):$/;" c function:FieldTest.test_reference_abstract_class -Sister tests/fields/fields.py /^ class Sister(Sibling):$/;" c function:FieldTest.test_reference_class_with_abstract_parent -Site mongoengine/tests/document/instance.py /^ class Site(Document):$/;" c function:InstanceTest.test_embedded_update -Site mongoengine/tests/document/instance.py /^ class Site(Document):$/;" c function:InstanceTest.test_embedded_update_after_save -Site mongoengine/tests/document/instance.py /^ class Site(Document):$/;" c function:InstanceTest.test_embedded_update_db_field -Site mongoengine/tests/queryset/queryset.py /^ class Site(Document):$/;" c function:QuerySetTest.test_pull_from_nested_embedded -Site mongoengine/tests/queryset/queryset.py /^ class Site(Document):$/;" c function:QuerySetTest.test_pull_from_nested_mapfield -Site mongoengine/tests/queryset/queryset.py /^ class Site(Document):$/;" c function:QuerySetTest.test_pull_nested -Size mongoengine/tests/queryset/queryset.py /^ class Size(Document):$/;" c function:QuerySetTest.test_can_have_field_same_name_as_query_operator -SocialData mongoengine/tests/fields/fields.py /^ class SocialData(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference -SocialData tests/fields/fields.py /^ class SocialData(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_reference -SocialTest mongoengine/tests/fields/fields.py /^ class SocialTest(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_decimal -SocialTest tests/fields/fields.py /^ class SocialTest(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_field_decimal -Song mongoengine/tests/test_dereference.py /^ class Song(Document):$/;" c function:FieldTest.test_select_related_follows_embedded_referencefields -SortedListField mongoengine/fields.py /^class SortedListField(ListField):$/;" c -SortedListField mongoengine/mongoengine/fields.py /^class SortedListField(ListField):$/;" c -SpecialComment mongoengine/tests/document/inheritance.py /^ class SpecialComment(Comment):$/;" c class:InheritanceTest.test_allow_inheritance_embedded_document.Comment -SpecificStrictDict mongoengine/mongoengine/base/datastructures.py /^ class SpecificStrictDict(cls):$/;" c function:StrictDict.create -State mongoengine/tests/queryset/queryset.py /^ class State(Document):$/;" c function:QuerySetTest.test_scalar_generic_reference_field -State mongoengine/tests/queryset/queryset.py /^ class State(Document):$/;" c function:QuerySetTest.test_scalar_reference_field -Stats mongoengine/tests/document/instance.py /^ class Stats(Document):$/;" c function:InstanceTest.test_reference_inheritance -StreamFile mongoengine/tests/fields/file_tests.py /^ class StreamFile(Document):$/;" c function:FileTest.test_file_fields_stream -StreamFile mongoengine/tests/fields/file_tests.py /^ class StreamFile(Document):$/;" c function:FileTest.test_file_fields_stream_after_none -StrictDict mongoengine/mongoengine/base/datastructures.py /^class StrictDict(object):$/;" c -StringField mongoengine/fields.py /^class StringField(BaseField):$/;" c -StringField mongoengine/mongoengine/fields.py /^class StringField(BaseField):$/;" c -StringIO mongoengine/mongoengine/python_support.py /^ StringIO = cStringIO.StringIO$/;" v -StringIO mongoengine/mongoengine/python_support.py /^StringIO = six.BytesIO$/;" v -StringSetting mongoengine/tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_complex_mapfield -StringSetting mongoengine/tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_dictfield_complex -StringSetting mongoengine/tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_list_field_complex -StringSetting tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_complex_mapfield -StringSetting tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_dictfield_complex -StringSetting tests/fields/fields.py /^ class StringSetting(SettingBase):$/;" c function:FieldTest.test_list_field_complex -SubAnimal mongoengine/tests/fields/fields.py /^ class SubAnimal(Animal):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set -SubAnimal mongoengine/tests/fields/fields.py /^ class SubAnimal(Animal):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set -SubAnimal tests/fields/fields.py /^ class SubAnimal(Animal):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set -SubAnimal tests/fields/fields.py /^ class SubAnimal(Animal):$/;" c function:LazyReferenceFieldTest.test_lazy_reference_set -SubDoc mongoengine/tests/document/instance.py /^ class SubDoc(EmbeddedDocument):$/;" c function:InstanceTest.test_embedded_document_to_mongo_id -SubDoc mongoengine/tests/document/validation.py /^ class SubDoc(EmbeddedDocument):$/;" c function:ValidatorErrorTest.test_embedded_db_field_validate -SubDoc mongoengine/tests/document/validation.py /^ class SubDoc(EmbeddedDocument):$/;" c function:ValidatorErrorTest.test_embedded_weakref -SubDoc mongoengine/tests/queryset/queryset.py /^ class SubDoc(EmbeddedDocument):$/;" c function:QuerySetTest.test_reload_embedded_docs_instance -SubDoc mongoengine/tests/queryset/queryset.py /^ class SubDoc(EmbeddedDocument):$/;" c function:QuerySetTest.test_reload_list_embedded_docs_instance -SubDocument mongoengine/tests/document/indexes.py /^ class SubDocument(EmbeddedDocument):$/;" c function:IndexesTest.test_unique_embedded_document -SubDocument mongoengine/tests/document/indexes.py /^ class SubDocument(EmbeddedDocument):$/;" c function:IndexesTest.test_unique_embedded_document_in_list -SubDocument mongoengine/tests/document/indexes.py /^ class SubDocument(EmbeddedDocument):$/;" c function:IndexesTest.test_unique_with_embedded_document_and_embedded_unique -SuperPhylum mongoengine/tests/document/instance.py /^ class SuperPhylum(EmbeddedDocument):$/;" c function:InstanceTest.test_reload_sharded_nested -TEST_IMAGE2_PATH mongoengine/tests/fields/file_tests.py /^TEST_IMAGE2_PATH = os.path.join(os.path.dirname(__file__), 'mongodb_leaf.png')$/;" v -TEST_IMAGE_PATH mongoengine/tests/document/instance.py /^TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__),$/;" v -TEST_IMAGE_PATH mongoengine/tests/fields/file_tests.py /^TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__), 'mongoengine.png')$/;" v -TPS mongoengine/tests/fields/fields.py /^ TPS = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -TPS tests/fields/fields.py /^ TPS = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -TYPES mongoengine/tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person -TYPES mongoengine/tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone -TYPES mongoengine/tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person -TYPES tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person -TYPES tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone -TYPES tests/fields/fields.py /^ TYPES = ($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person -Tag mongoengine/tests/document/indexes.py /^ class Tag(EmbeddedDocument):$/;" c function:IndexesTest.test_list_embedded_document_index -Tag mongoengine/tests/test_dereference.py /^ class Tag(Document):$/;" c function:FieldTest.test_dereferencing_embedded_listfield_referencefield -Test mongoengine/tests/document/indexes.py /^ class Test(Document):$/;" c function:IndexesTest.test_covered_index -Test mongoengine/tests/document/instance.py /^ class Test(Document):$/;" c function:InstanceTest.test_dbref_equality -Test mongoengine/tests/document/instance.py /^ class Test(Document):$/;" c function:InstanceTest.test_embedded_document_equality -Test mongoengine/tests/fields/fields.py /^ class Test(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields_on_embedded_documents -Test mongoengine/tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_embedded_db_field -Test mongoengine/tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_embedded_mapfield_db_field -Test mongoengine/tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_mapfield_numerical_index -Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_cursor_in_an_if_stmt -Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_dict_with_custom_baseclass -Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_item_frequencies_normalize -Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_item_frequencies_with_0_values -Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_item_frequencies_with_False_values -Test mongoengine/tests/queryset/queryset.py /^ class Test(Document):$/;" c function:QuerySetTest.test_upsert_includes_cls -Test mongoengine/tests/queryset/visitor.py /^ class Test(Document):$/;" c function:QTest.test_multiple_occurence_in_field -Test tests/fields/fields.py /^ class Test(Document):$/;" c function:CachedReferenceFieldTest.test_cached_reference_fields_on_embedded_documents -Test tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_embedded_db_field -Test tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_embedded_mapfield_db_field -Test tests/fields/fields.py /^ class Test(Document):$/;" c function:FieldTest.test_mapfield_numerical_index -Test2 mongoengine/tests/document/instance.py /^ class Test2(Document):$/;" c function:InstanceTest.test_dbref_equality -Test3 mongoengine/tests/document/instance.py /^ class Test3(Document):$/;" c function:InstanceTest.test_dbref_equality -TestActivity mongoengine/tests/queryset/queryset.py /^ class TestActivity(Document):$/;" c function:QuerySetTest.test_generic_reference_field_with_only_and_as_pymongo -TestChildDoc mongoengine/tests/document/indexes.py /^ class TestChildDoc(TestDoc):$/;" c function:IndexesTest.test_index_dont_send_cls_option -TestDoc mongoengine/tests/document/indexes.py /^ class TestDoc(Document):$/;" c function:IndexesTest.test_compound_index_underscore_cls_not_overwritten -TestDoc mongoengine/tests/document/indexes.py /^ class TestDoc(Document):$/;" c function:IndexesTest.test_index_dont_send_cls_option -TestDoc mongoengine/tests/document/instance.py /^ class TestDoc(Document, DoubleMixIn):$/;" c function:InstanceTest.test_mixin_inheritance -TestDoc mongoengine/tests/fields/fields.py /^ class TestDoc(Document):$/;" c function:FieldTest.test_tuples_as_tuples -TestDoc mongoengine/tests/queryset/queryset.py /^ class TestDoc(Document):$/;" c function:QuerySetTest.test_scalar_db_field -TestDoc mongoengine/tests/queryset/queryset.py /^ class TestDoc(Document):$/;" c function:QuerySetTest.test_scalar_simple -TestDoc mongoengine/tests/queryset/visitor.py /^ class TestDoc(Document):$/;" c function:QTest.test_and_combination -TestDoc mongoengine/tests/queryset/visitor.py /^ class TestDoc(Document):$/;" c function:QTest.test_and_or_combination -TestDoc mongoengine/tests/queryset/visitor.py /^ class TestDoc(Document):$/;" c function:QTest.test_or_and_or_combination -TestDoc mongoengine/tests/queryset/visitor.py /^ class TestDoc(Document):$/;" c function:QTest.test_or_combination -TestDoc mongoengine/tests/queryset/visitor.py /^ class TestDoc(Document):$/;" c function:QTest.test_q_clone -TestDoc tests/fields/fields.py /^ class TestDoc(Document):$/;" c function:FieldTest.test_tuples_as_tuples -TestDocument mongoengine/tests/document/instance.py /^ class TestDocument(Document):$/;" c function:InstanceTest.test_document_clean -TestDocument mongoengine/tests/document/instance.py /^ class TestDocument(Document):$/;" c function:InstanceTest.test_document_embedded_clean -TestDocument mongoengine/tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_int_and_float_ne_operator -TestDocument mongoengine/tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_long_ne_operator -TestDocument mongoengine/tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_long_validation -TestDocument tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_int_and_float_ne_operator -TestDocument tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_long_ne_operator -TestDocument tests/fields/fields.py /^ class TestDocument(Document):$/;" c function:FieldTest.test_long_validation -TestEmbeddedDocument mongoengine/tests/document/instance.py /^ class TestEmbeddedDocument(EmbeddedDocument):$/;" c function:InstanceTest.test_document_embedded_clean -TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_copyable -TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_boolean -TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_cmp -TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_disk_space -TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_multidb -TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_reassigning -TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_file_uniqueness -TestFile mongoengine/tests/fields/file_tests.py /^ class TestFile(Document):$/;" c function:FileTest.test_image_field_reassigning -TestImage mongoengine/tests/fields/file_tests.py /^ class TestImage(Document):$/;" c function:FileTest.test_get_image_by_grid_id -TestImage mongoengine/tests/fields/file_tests.py /^ class TestImage(Document):$/;" c function:FileTest.test_image_field -TestImage mongoengine/tests/fields/file_tests.py /^ class TestImage(Document):$/;" c function:FileTest.test_image_field_resize -TestImage mongoengine/tests/fields/file_tests.py /^ class TestImage(Document):$/;" c function:FileTest.test_image_field_resize_force -TestImage mongoengine/tests/fields/file_tests.py /^ class TestImage(Document):$/;" c function:FileTest.test_image_field_thumbnail -TestJson mongoengine/tests/document/json_serialisation.py /^class TestJson(unittest.TestCase):$/;" c -TestLongFieldConsideredAsInt64 mongoengine/tests/fields/fields.py /^ class TestLongFieldConsideredAsInt64(Document):$/;" c function:FieldTest.test_long_field_is_considered_as_int64 -TestLongFieldConsideredAsInt64 tests/fields/fields.py /^ class TestLongFieldConsideredAsInt64(Document):$/;" c function:FieldTest.test_long_field_is_considered_as_int64 -TestOrganization mongoengine/tests/queryset/queryset.py /^ class TestOrganization(Document):$/;" c function:QuerySetTest.test_update_related_models -TestPerson mongoengine/tests/queryset/queryset.py /^ class TestPerson(Document):$/;" c function:QuerySetTest.test_update_related_models -TestPerson mongoengine/tests/queryset/queryset.py /^ class TestPerson(Document):$/;" c function:QuerySetTest.test_generic_reference_field_with_only_and_as_pymongo -TestQuerysetPickable mongoengine/tests/queryset/pickable.py /^class TestQuerysetPickable(unittest.TestCase):$/;" c -TestStrictDict mongoengine/tests/test_datastructures.py /^class TestStrictDict(unittest.TestCase):$/;" c -TextPost mongoengine/docs/code/tumblelog.py /^class TextPost(Post):$/;" c -Thing mongoengine/tests/document/instance.py /^ class Thing(EmbeddedDocument):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document -Thing mongoengine/tests/document/instance.py /^ class Thing(EmbeddedDocument):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false -Thing mongoengine/tests/document/instance.py /^ class Thing(EmbeddedDocument):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc -Thing mongoengine/tests/document/instance.py /^ class Thing(EmbeddedDocument):$/;" c function:InstanceTest.test_save_to_a_value_that_equates_to_false -ToEmbed mongoengine/tests/fields/fields.py /^ class ToEmbed(Document):$/;" c function:FieldTest.test_dictfield_dump_document -ToEmbed mongoengine/tests/fields/fields.py /^ class ToEmbed(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document -ToEmbed tests/fields/fields.py /^ class ToEmbed(Document):$/;" c function:FieldTest.test_dictfield_dump_document -ToEmbed tests/fields/fields.py /^ class ToEmbed(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document -ToEmbedChild mongoengine/tests/fields/fields.py /^ class ToEmbedChild(ToEmbedParent):$/;" c function:FieldTest.test_dictfield_dump_document -ToEmbedChild mongoengine/tests/fields/fields.py /^ class ToEmbedChild(ToEmbedParent):$/;" c function:FieldTest.test_dynamicfield_dump_document -ToEmbedChild tests/fields/fields.py /^ class ToEmbedChild(ToEmbedParent):$/;" c function:FieldTest.test_dictfield_dump_document -ToEmbedChild tests/fields/fields.py /^ class ToEmbedChild(ToEmbedParent):$/;" c function:FieldTest.test_dynamicfield_dump_document -ToEmbedParent mongoengine/tests/fields/fields.py /^ class ToEmbedParent(Document):$/;" c function:FieldTest.test_dictfield_dump_document -ToEmbedParent mongoengine/tests/fields/fields.py /^ class ToEmbedParent(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document -ToEmbedParent tests/fields/fields.py /^ class ToEmbedParent(Document):$/;" c function:FieldTest.test_dictfield_dump_document -ToEmbedParent tests/fields/fields.py /^ class ToEmbedParent(Document):$/;" c function:FieldTest.test_dynamicfield_dump_document -TopLevelDocumentMetaclass mongoengine/mongoengine/base/metaclasses.py /^class TopLevelDocumentMetaclass(DocumentMetaclass):$/;" c -Topic mongoengine/tests/test_dereference.py /^ class Topic(Document):$/;" c function:FieldTest.test_document_reload_reference_integrity -TransformTest mongoengine/tests/queryset/transform.py /^class TransformTest(unittest.TestCase):$/;" c -Tree mongoengine/tests/fields/fields.py /^ class Tree(Document):$/;" c function:FieldTest.test_recursive_embedding -Tree tests/fields/fields.py /^ class Tree(Document):$/;" c function:FieldTest.test_recursive_embedding -TreeNode mongoengine/tests/fields/fields.py /^ class TreeNode(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_embedding -TreeNode tests/fields/fields.py /^ class TreeNode(EmbeddedDocument):$/;" c function:FieldTest.test_recursive_embedding -UInfoDocument mongoengine/tests/document/delta.py /^ class UInfoDocument(Document):$/;" c function:DeltaTest.test_delta_for_nested_map_fields -UPDATE_OPERATORS mongoengine/mongoengine/base/common.py /^UPDATE_OPERATORS = set(['set', 'unset', 'inc', 'dec', 'pop', 'push',$/;" v -URLField mongoengine/fields.py /^class URLField(StringField):$/;" c -URLField mongoengine/mongoengine/fields.py /^class URLField(StringField):$/;" c -USER_REGEX mongoengine/fields.py /^ USER_REGEX = re.compile($/;" v class:EmailField -USER_REGEX mongoengine/mongoengine/fields.py /^ USER_REGEX = re.compile($/;" v class:EmailField -UTF8_USER_REGEX mongoengine/fields.py /^ UTF8_USER_REGEX = re.compile($/;" v class:EmailField -UTF8_USER_REGEX mongoengine/mongoengine/fields.py /^ UTF8_USER_REGEX = re.compile($/;" v class:EmailField -UUID mongoengine/tests/document/instance.py /^ def UUID(i):$/;" f function:InstanceTest.test_save_atomicity_condition -UUIDField mongoengine/fields.py /^class UUIDField(BaseField):$/;" c -UUIDField mongoengine/mongoengine/fields.py /^class UUIDField(BaseField):$/;" c -User mongoengine/docs/code/tumblelog.py /^class User(Document):$/;" c -User mongoengine/tests/document/delta.py /^ class User(Document):$/;" c function:DeltaTest.test_referenced_object_changed_attributes -User mongoengine/tests/document/indexes.py /^ class User(Document):$/;" c function:IndexesTest.test_disable_index_creation -User mongoengine/tests/document/indexes.py /^ class User(Document):$/;" c function:IndexesTest.test_unique_and_primary -User mongoengine/tests/document/indexes.py /^ class User(Document):$/;" c function:IndexesTest.test_unique_and_primary_create -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_custom_id_field -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_db_alias_tests -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_db_ref_usage -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_document_hash -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_list_search_by_embedded -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_load_undefined_fields -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_load_undefined_fields_with_strict_false -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_null_field -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_query_count_when_saving -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_with_custom_id_field -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_reverse_delete_rule_with_shared_id_among_collections -User mongoengine/tests/document/instance.py /^ class User(Document):$/;" c function:InstanceTest.test_save_to_a_value_that_equates_to_false -User mongoengine/tests/document/instance.py /^ class User(self.Person):$/;" c function:InstanceTest.test_save_only_changed_fields -User mongoengine/tests/document/instance.py /^ class User(self.Person):$/;" c function:InstanceTest.test_save_only_changed_fields_recursive -User mongoengine/tests/document/validation.py /^ class User(Document):$/;" c function:ValidatorErrorTest.test_model_validation -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_db_field_validation -User mongoengine/tests/fields/fields.py /^ class User(Basedoc):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_domain_whitelist -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_honors_regex -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_ip_domain -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_unicode_user -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_document_not_registered -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list_choices -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list_item_modification -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_list_validation -User mongoengine/tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_reference_validation -User mongoengine/tests/fields/fields.py /^ class User(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_inheritance -User mongoengine/tests/queryset/field_list.py /^ class User(Base):$/;" c function:OnlyExcludeAllTest.test_exclude_from_subclasses_docs -User mongoengine/tests/queryset/field_list.py /^ class User(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_exclude -User mongoengine/tests/queryset/field_list.py /^ class User(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_only_with_subfields -User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_as_pymongo -User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_as_pymongo_json_limit_fields -User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_cache_not_cloned -User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_comment -User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_in_operator_on_non_iterable -User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_nested_queryset_iterator -User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_no_dereference -User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_no_dereference_embedded_doc -User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_scalar -User mongoengine/tests/queryset/queryset.py /^ class User(Document):$/;" c function:QuerySetTest.test_set_generic_embedded_documents -User mongoengine/tests/queryset/queryset.py /^ class User(EmbeddedDocument):$/;" c function:QuerySetTest.test_find_embedded -User mongoengine/tests/queryset/queryset.py /^ class User(EmbeddedDocument):$/;" c function:QuerySetTest.test_find_empty_embedded -User mongoengine/tests/queryset/queryset.py /^ class User(EmbeddedDocument):$/;" c function:QuerySetTest.test_pull_from_nested_embedded -User mongoengine/tests/queryset/visitor.py /^ class User(Document):$/;" c function:QTest.test_q_merge_queries_edge_case -User mongoengine/tests/queryset/visitor.py /^ class User(Document):$/;" c function:QTest.test_q_with_dbref -User mongoengine/tests/test_context_managers.py /^ class User(Document):$/;" c function:ContextManagersTest.test_no_dereference_context_manager_dbref -User mongoengine/tests/test_context_managers.py /^ class User(Document):$/;" c function:ContextManagersTest.test_no_dereference_context_manager_object_id -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_document_reload_reference_integrity -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_handle_old_style_references -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_false_stores_as_type -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_list_of_lists_of_references -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_map_field_reference -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_migrate_references -User mongoengine/tests/test_dereference.py /^ class User(Document):$/;" c function:FieldTest.test_objectid_reference_across_databases -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_db_field_validation -User tests/fields/fields.py /^ class User(Basedoc):$/;" c function:FieldTest.test_embedded_document_inheritance_with_list -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_domain_whitelist -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_honors_regex -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_ip_domain -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_email_field_unicode_user -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_document_not_registered -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list_choices -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_generic_reference_list_item_modification -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_list_item_dereference -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_list_validation -User tests/fields/fields.py /^ class User(Document):$/;" c function:FieldTest.test_reference_validation -User tests/fields/fields.py /^ class User(EmbeddedDocument):$/;" c function:FieldTest.test_embedded_document_inheritance -UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_dict_field -UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_dict_field_no_field_inheritance -UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_generic_reference -UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_generic_reference_map_field -UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries -UserA mongoengine/tests/test_dereference.py /^ class UserA(Document):$/;" c function:FieldTest.test_list_field_complex -UserB mongoengine/tests/test_dereference.py /^ class UserB(Document):$/;" c function:FieldTest.test_dict_field -UserB mongoengine/tests/test_dereference.py /^ class UserB(Document):$/;" c function:FieldTest.test_generic_reference -UserB mongoengine/tests/test_dereference.py /^ class UserB(Document):$/;" c function:FieldTest.test_generic_reference_map_field -UserB mongoengine/tests/test_dereference.py /^ class UserB(Document):$/;" c function:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries -UserB mongoengine/tests/test_dereference.py /^ class UserB(Document):$/;" c function:FieldTest.test_list_field_complex -UserBase mongoengine/tests/document/indexes.py /^ class UserBase(Document):$/;" c function:IndexesTest.test_abstract_index_inheritance -UserC mongoengine/tests/test_dereference.py /^ class UserC(Document):$/;" c function:FieldTest.test_dict_field -UserC mongoengine/tests/test_dereference.py /^ class UserC(Document):$/;" c function:FieldTest.test_generic_reference -UserC mongoengine/tests/test_dereference.py /^ class UserC(Document):$/;" c function:FieldTest.test_generic_reference_map_field -UserC mongoengine/tests/test_dereference.py /^ class UserC(Document):$/;" c function:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries -UserC mongoengine/tests/test_dereference.py /^ class UserC(Document):$/;" c function:FieldTest.test_list_field_complex -UserComments mongoengine/tests/fields/fields.py /^ class UserComments(Comments):$/;" c function:FieldTest.test_choices_validation_documents_inheritance -UserComments mongoengine/tests/fields/fields.py /^ class UserComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents -UserComments mongoengine/tests/fields/fields.py /^ class UserComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_invalid -UserComments tests/fields/fields.py /^ class UserComments(Comments):$/;" c function:FieldTest.test_choices_validation_documents_inheritance -UserComments tests/fields/fields.py /^ class UserComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents -UserComments tests/fields/fields.py /^ class UserComments(EmbeddedDocument):$/;" c function:FieldTest.test_choices_validation_documents_invalid -UserDoc mongoengine/tests/queryset/queryset.py /^ class UserDoc(Document):$/;" c function:QuerySetTest.test_scalar_simple -UserSubscription mongoengine/tests/document/instance.py /^ class UserSubscription(Document):$/;" c function:InstanceTest.test_query_count_when_saving -UserVisit mongoengine/tests/queryset/queryset.py /^ class UserVisit(Document):$/;" c function:QuerySetTest.test_average_over_db_field -UserVisit mongoengine/tests/queryset/queryset.py /^ class UserVisit(Document):$/;" c function:QuerySetTest.test_sum_over_db_field -VALUE_DECORATOR mongoengine/fields.py /^ VALUE_DECORATOR = int$/;" v class:SequenceField -VALUE_DECORATOR mongoengine/mongoengine/fields.py /^ VALUE_DECORATOR = int$/;" v class:SequenceField -VERSION mongoengine/mongoengine/__init__.py /^VERSION = (0, 15, 0)$/;" v -VERSION mongoengine/setup.py /^VERSION = get_version(eval(version_line.split('=')[-1]))$/;" v -Vaccine mongoengine/tests/document/class_methods.py /^ class Vaccine(Document):$/;" c function:ClassMethodsTest.test_register_delete_rule_inherited -ValidationError mongoengine/mongoengine/errors.py /^class ValidationError(AssertionError):$/;" c -ValidatorErrorTest mongoengine/tests/document/validation.py /^class ValidatorErrorTest(unittest.TestCase):$/;" c -VariousData mongoengine/tests/queryset/field_list.py /^ class VariousData(EmbeddedDocument):$/;" c function:OnlyExcludeAllTest.test_only_with_subfields -Vegetal mongoengine/tests/fields/fields.py /^ class Vegetal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices -Vegetal tests/fields/fields.py /^ class Vegetal(Document):$/;" c function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices -Venue mongoengine/tests/fields/geo.py /^ class Venue(EmbeddedDocument):$/;" c function:GeoFieldTest.test_geopoint_embedded_indexes -Venue mongoengine/tests/fields/geo.py /^ class Venue(EmbeddedDocument):$/;" c function:GeoFieldTest.test_indexes_2dsphere_embedded -Venue mongoengine/tests/queryset/geo.py /^ class Venue(EmbeddedDocument):$/;" c function:GeoQueriesTest._test_embedded -Vote mongoengine/tests/queryset/queryset.py /^ class Vote(EmbeddedDocument):$/;" c function:QuerySetTest.test_update_using_positional_operator_embedded_document -Widget mongoengine/tests/document/instance.py /^ class Widget(Document):$/;" c function:InstanceTest.test_save_atomicity_condition -Word mongoengine/tests/document/instance.py /^ class Word(Document):$/;" c function:InstanceTest.test_invalid_son -Writer mongoengine/tests/document/instance.py /^ class Writer(self.Person):$/;" c function:InstanceTest.test_reverse_delete_rule_with_document_inheritance -Zoo mongoengine/tests/document/instance.py /^ class Zoo(Document):$/;" c function:InstanceTest.test_polymorphic_references -_FakeSignal mongoengine/mongoengine/signals.py /^ class _FakeSignal(object):$/;" c -_URL_REGEX mongoengine/fields.py /^ _URL_REGEX = re.compile($/;" v class:URLField -_URL_REGEX mongoengine/mongoengine/fields.py /^ _URL_REGEX = re.compile($/;" v class:URLField -_URL_SCHEMES mongoengine/fields.py /^ _URL_SCHEMES = ['http', 'https', 'ftp', 'ftps']$/;" v class:URLField -_URL_SCHEMES mongoengine/mongoengine/fields.py /^ _URL_SCHEMES = ['http', 'https', 'ftp', 'ftps']$/;" v class:URLField -__add__ mongoengine/mongoengine/queryset/field_list.py /^ def __add__(self, f):$/;" m class:QueryFieldList file: -__all__ mongoengine/fields.py /^__all__ = ($/;" v -__all__ mongoengine/mongoengine/__init__.py /^__all__ = (list(document.__all__) + list(fields.__all__) +$/;" v -__all__ mongoengine/mongoengine/base/__init__.py /^__all__ = ($/;" v -__all__ mongoengine/mongoengine/base/common.py /^__all__ = ('UPDATE_OPERATORS', 'get_document', '_document_registry')$/;" v -__all__ mongoengine/mongoengine/base/datastructures.py /^__all__ = ('BaseDict', 'BaseList', 'EmbeddedDocumentList', 'LazyReference')$/;" v -__all__ mongoengine/mongoengine/base/document.py /^__all__ = ('BaseDocument', 'NON_FIELD_ERRORS')$/;" v -__all__ mongoengine/mongoengine/base/fields.py /^__all__ = ('BaseField', 'ComplexBaseField', 'ObjectIdField',$/;" v -__all__ mongoengine/mongoengine/base/metaclasses.py /^__all__ = ('DocumentMetaclass', 'TopLevelDocumentMetaclass')$/;" v -__all__ mongoengine/mongoengine/connection.py /^__all__ = ['MongoEngineConnectionError', 'connect', 'register_connection',$/;" v -__all__ mongoengine/mongoengine/context_managers.py /^__all__ = ('switch_db', 'switch_collection', 'no_dereference',$/;" v -__all__ mongoengine/mongoengine/document.py /^__all__ = ('Document', 'EmbeddedDocument', 'DynamicDocument',$/;" v -__all__ mongoengine/mongoengine/errors.py /^__all__ = ('NotRegistered', 'InvalidDocumentError', 'LookUpError',$/;" v -__all__ mongoengine/mongoengine/fields.py /^__all__ = ($/;" v -__all__ mongoengine/mongoengine/queryset/__init__.py /^__all__ = ($/;" v -__all__ mongoengine/mongoengine/queryset/base.py /^__all__ = ('BaseQuerySet', 'DO_NOTHING', 'NULLIFY', 'CASCADE', 'DENY', 'PULL')$/;" v -__all__ mongoengine/mongoengine/queryset/field_list.py /^__all__ = ('QueryFieldList',)$/;" v -__all__ mongoengine/mongoengine/queryset/manager.py /^__all__ = ('queryset_manager', 'QuerySetManager')$/;" v -__all__ mongoengine/mongoengine/queryset/queryset.py /^__all__ = ('QuerySet', 'QuerySetNoCache', 'DO_NOTHING', 'NULLIFY', 'CASCADE',$/;" v -__all__ mongoengine/mongoengine/queryset/transform.py /^__all__ = ('query', 'update')$/;" v -__all__ mongoengine/mongoengine/queryset/visitor.py /^__all__ = ('Q',)$/;" v -__all__ mongoengine/mongoengine/signals.py /^__all__ = ('pre_init', 'post_init', 'pre_save', 'pre_save_post_validation',$/;" v -__all__ mongoengine/tests/all_warnings/__init__.py /^__all__ = ('AllWarnings', )$/;" v -__all__ mongoengine/tests/document/class_methods.py /^__all__ = ("ClassMethodsTest", )$/;" v -__all__ mongoengine/tests/document/delta.py /^__all__ = ("DeltaTest",)$/;" v -__all__ mongoengine/tests/document/dynamic.py /^__all__ = ("DynamicTest", )$/;" v -__all__ mongoengine/tests/document/indexes.py /^__all__ = ("IndexesTest", )$/;" v -__all__ mongoengine/tests/document/inheritance.py /^__all__ = ('InheritanceTest', )$/;" v -__all__ mongoengine/tests/document/instance.py /^__all__ = ("InstanceTest",)$/;" v -__all__ mongoengine/tests/document/json_serialisation.py /^__all__ = ("TestJson",)$/;" v -__all__ mongoengine/tests/document/validation.py /^__all__ = ("ValidatorErrorTest",)$/;" v -__all__ mongoengine/tests/fields/fields.py /^__all__ = ("FieldTest", "EmbeddedDocumentListFieldTestCase")$/;" v -__all__ mongoengine/tests/fields/geo.py /^__all__ = ("GeoFieldTest", )$/;" v -__all__ mongoengine/tests/queryset/field_list.py /^__all__ = ("QueryFieldListTest", "OnlyExcludeAllTest")$/;" v -__all__ mongoengine/tests/queryset/geo.py /^__all__ = ("GeoQueriesTest",)$/;" v -__all__ mongoengine/tests/queryset/modify.py /^__all__ = ("FindAndModifyTest",)$/;" v -__all__ mongoengine/tests/queryset/queryset.py /^__all__ = ("QuerySetTest",)$/;" v -__all__ mongoengine/tests/queryset/transform.py /^__all__ = ("TransformTest",)$/;" v -__all__ mongoengine/tests/queryset/visitor.py /^__all__ = ("QTest",)$/;" v -__all__ tests/fields/fields.py /^__all__ = ("FieldTest", "EmbeddedDocumentListFieldTestCase")$/;" v -__and__ mongoengine/mongoengine/queryset/visitor.py /^ def __and__(self, other):$/;" m class:QNode file: -__author__ mongoengine/tests/queryset/pickable.py /^__author__ = 'stas'$/;" v -__bool__ mongoengine/mongoengine/queryset/base.py /^ def __bool__(self):$/;" m class:BaseQuerySet file: -__call__ mongoengine/mongoengine/dereference.py /^ def __call__(self, items, max_depth=1, instance=None, name=None):$/;" m class:DeReference file: -__call__ mongoengine/mongoengine/queryset/base.py /^ def __call__(self, q_obj=None, class_check=True, read_preference=None,$/;" m class:BaseQuerySet file: -__contains__ mongoengine/mongoengine/base/datastructures.py /^ def __contains__(self, key):$/;" m class:StrictDict file: -__contains__ mongoengine/mongoengine/base/document.py /^ def __contains__(self, name):$/;" m class:BaseDocument file: -__copy__ mongoengine/fields.py /^ def __copy__(self):$/;" m class:GridFSProxy file: -__copy__ mongoengine/mongoengine/fields.py /^ def __copy__(self):$/;" m class:GridFSProxy file: -__deepcopy__ mongoengine/fields.py /^ def __deepcopy__(self, memo):$/;" m class:GridFSProxy file: -__deepcopy__ mongoengine/mongoengine/fields.py /^ def __deepcopy__(self, memo):$/;" m class:GridFSProxy file: -__deepcopy__ mongoengine/mongoengine/queryset/base.py /^ def __deepcopy__(self, memo):$/;" m class:BaseQuerySet file: -__delattr__ mongoengine/mongoengine/base/datastructures.py /^ def __delattr__(self, key, *args, **kwargs):$/;" m class:BaseDict file: -__delattr__ mongoengine/mongoengine/base/document.py /^ def __delattr__(self, *args, **kwargs):$/;" m class:BaseDocument file: -__delattr__ mongoengine/mongoengine/document.py /^ def __delattr__(self, *args, **kwargs):$/;" m class:DynamicDocument file: -__delattr__ mongoengine/mongoengine/document.py /^ def __delattr__(self, *args, **kwargs):$/;" m class:DynamicEmbeddedDocument file: -__delete__ mongoengine/mongoengine/base/datastructures.py /^ def __delete__(self, *args, **kwargs):$/;" m class:BaseDict file: -__delitem__ mongoengine/mongoengine/base/datastructures.py /^ def __delitem__(self, key, *args, **kwargs):$/;" m class:BaseDict file: -__delitem__ mongoengine/mongoengine/base/datastructures.py /^ def __delitem__(self, key, *args, **kwargs):$/;" m class:BaseList file: -__delslice__ mongoengine/mongoengine/base/datastructures.py /^ def __delslice__(self, *args, **kwargs):$/;" m class:BaseList file: -__dereference mongoengine/mongoengine/queryset/base.py /^ __dereference = False$/;" v class:BaseQuerySet -__dereference mongoengine/mongoengine/queryset/queryset.py /^ def __dereference(items, max_depth=1, instance=None, name=None):$/;" m class:QuerySetNoDeRef file: -__enter__ mongoengine/mongoengine/context_managers.py /^ def __enter__(self):$/;" m class:no_dereference file: -__enter__ mongoengine/mongoengine/context_managers.py /^ def __enter__(self):$/;" m class:no_sub_classes file: -__enter__ mongoengine/mongoengine/context_managers.py /^ def __enter__(self):$/;" m class:query_counter file: -__enter__ mongoengine/mongoengine/context_managers.py /^ def __enter__(self):$/;" m class:switch_collection file: -__enter__ mongoengine/mongoengine/context_managers.py /^ def __enter__(self):$/;" m class:switch_db file: -__eq__ mongoengine/fields.py /^ def __eq__(self, other):$/;" m class:GridFSProxy file: -__eq__ mongoengine/mongoengine/base/datastructures.py /^ def __eq__(self, other):$/;" m class:StrictDict file: -__eq__ mongoengine/mongoengine/base/document.py /^ def __eq__(self, other):$/;" m class:BaseDocument file: -__eq__ mongoengine/mongoengine/context_managers.py /^ def __eq__(self, value):$/;" m class:query_counter file: -__eq__ mongoengine/mongoengine/document.py /^ def __eq__(self, other):$/;" m class:EmbeddedDocument file: -__eq__ mongoengine/mongoengine/fields.py /^ def __eq__(self, other):$/;" m class:GridFSProxy file: -__eq__ mongoengine/tests/document/instance.py /^ def __eq__(self, other):$/;" m class:InstanceTest.test_kwargs_complex.Doc file: -__eq__ mongoengine/tests/document/instance.py /^ def __eq__(self, other):$/;" m class:InstanceTest.test_kwargs_simple.Doc file: -__eq__ mongoengine/tests/document/json_serialisation.py /^ def __eq__(self, other):$/;" m class:TestJson.test_json_complex.Doc file: -__eq__ mongoengine/tests/document/json_serialisation.py /^ def __eq__(self, other):$/;" m class:TestJson.test_json_simple.Doc file: -__exit__ mongoengine/mongoengine/context_managers.py /^ def __exit__(self, t, value, traceback):$/;" m class:no_dereference file: -__exit__ mongoengine/mongoengine/context_managers.py /^ def __exit__(self, t, value, traceback):$/;" m class:no_sub_classes file: -__exit__ mongoengine/mongoengine/context_managers.py /^ def __exit__(self, t, value, traceback):$/;" m class:query_counter file: -__exit__ mongoengine/mongoengine/context_managers.py /^ def __exit__(self, t, value, traceback):$/;" m class:switch_collection file: -__exit__ mongoengine/mongoengine/context_managers.py /^ def __exit__(self, t, value, traceback):$/;" m class:switch_db file: -__expand_dynamic_values mongoengine/mongoengine/base/document.py /^ def __expand_dynamic_values(self, name, value):$/;" m class:BaseDocument file: -__ge__ mongoengine/mongoengine/context_managers.py /^ def __ge__(self, value):$/;" m class:query_counter file: -__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:CachedReferenceField file: -__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ComplexDateTimeField file: -__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:FileField file: -__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:GenericLazyReferenceField file: -__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:GenericReferenceField file: -__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:LazyReferenceField file: -__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ListField file: -__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ReferenceField file: -__get__ mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:SequenceField file: -__get__ mongoengine/fields.py /^ def __get__(self, instance, value):$/;" m class:GridFSProxy file: -__get__ mongoengine/mongoengine/base/fields.py /^ def __get__(self, instance, owner):$/;" m class:BaseField file: -__get__ mongoengine/mongoengine/base/fields.py /^ def __get__(self, instance, owner):$/;" m class:ComplexBaseField file: -__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:CachedReferenceField file: -__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ComplexDateTimeField file: -__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:FileField file: -__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:GenericLazyReferenceField file: -__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:GenericReferenceField file: -__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:LazyReferenceField file: -__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ListField file: -__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:ReferenceField file: -__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, owner):$/;" m class:SequenceField file: -__get__ mongoengine/mongoengine/fields.py /^ def __get__(self, instance, value):$/;" m class:GridFSProxy file: -__get__ mongoengine/mongoengine/queryset/manager.py /^ def __get__(self, instance, owner):$/;" m class:QuerySetManager file: -__get_bases mongoengine/mongoengine/base/metaclasses.py /^ def __get_bases(cls, bases):$/;" m class:DocumentMetaclass file: -__get_field_display mongoengine/mongoengine/base/document.py /^ def __get_field_display(self, field):$/;" m class:BaseDocument file: -__getattr__ mongoengine/fields.py /^ def __getattr__(self, name):$/;" m class:GridFSProxy file: -__getattr__ mongoengine/mongoengine/base/datastructures.py /^ def __getattr__(self, name):$/;" m class:LazyReference file: -__getattr__ mongoengine/mongoengine/fields.py /^ def __getattr__(self, name):$/;" m class:GridFSProxy file: -__getattribute__ mongoengine/mongoengine/errors.py /^ def __getattribute__(self, name):$/;" m class:ValidationError file: -__getitem__ mongoengine/mongoengine/base/datastructures.py /^ def __getitem__(self, key):$/;" m class:StrictDict file: -__getitem__ mongoengine/mongoengine/base/datastructures.py /^ def __getitem__(self, key, *args, **kwargs):$/;" m class:BaseDict file: -__getitem__ mongoengine/mongoengine/base/datastructures.py /^ def __getitem__(self, key, *args, **kwargs):$/;" m class:BaseList file: -__getitem__ mongoengine/mongoengine/base/datastructures.py /^ def __getitem__(self, name):$/;" m class:LazyReference file: -__getitem__ mongoengine/mongoengine/base/document.py /^ def __getitem__(self, name):$/;" m class:BaseDocument file: -__getitem__ mongoengine/mongoengine/queryset/base.py /^ def __getitem__(self, key):$/;" m class:BaseQuerySet file: -__getstate__ mongoengine/fields.py /^ def __getstate__(self):$/;" m class:GridFSProxy file: -__getstate__ mongoengine/mongoengine/base/datastructures.py /^ def __getstate__(self):$/;" m class:BaseDict file: -__getstate__ mongoengine/mongoengine/base/datastructures.py /^ def __getstate__(self):$/;" m class:BaseList file: -__getstate__ mongoengine/mongoengine/base/document.py /^ def __getstate__(self):$/;" m class:BaseDocument file: -__getstate__ mongoengine/mongoengine/fields.py /^ def __getstate__(self):$/;" m class:GridFSProxy file: -__getstate__ mongoengine/mongoengine/queryset/base.py /^ def __getstate__(self):$/;" m class:BaseQuerySet file: -__gt__ mongoengine/mongoengine/context_managers.py /^ def __gt__(self, value):$/;" m class:query_counter file: -__hash__ mongoengine/mongoengine/document.py /^ __hash__ = None$/;" v class:EmbeddedDocument -__hash__ mongoengine/mongoengine/document.py /^ def __hash__(self):$/;" m class:Document file: -__iadd__ mongoengine/mongoengine/base/datastructures.py /^ def __iadd__(self, other):$/;" m class:BaseList file: -__imul__ mongoengine/mongoengine/base/datastructures.py /^ def __imul__(self, other):$/;" m class:BaseList file: -__init__ mongoengine/fields.py /^ def __init__(self, *args, **kwargs):$/;" m class:GenericLazyReferenceField -__init__ mongoengine/fields.py /^ def __init__(self, *args, **kwargs):$/;" m class:GenericReferenceField -__init__ mongoengine/fields.py /^ def __init__(self, basecls=None, field=None, *args, **kwargs):$/;" m class:DictField -__init__ mongoengine/fields.py /^ def __init__(self, binary=True, **kwargs):$/;" m class:UUIDField -__init__ mongoengine/fields.py /^ def __init__(self, collection_name=None, db_alias=None, sequence_name=None,$/;" m class:SequenceField -__init__ mongoengine/fields.py /^ def __init__(self, db_alias=DEFAULT_CONNECTION_NAME, collection_name='fs',$/;" m class:FileField -__init__ mongoengine/fields.py /^ def __init__(self, document_type, **kwargs):$/;" m class:EmbeddedDocumentField -__init__ mongoengine/fields.py /^ def __init__(self, document_type, **kwargs):$/;" m class:EmbeddedDocumentListField -__init__ mongoengine/fields.py /^ def __init__(self, document_type, dbref=False,$/;" m class:ReferenceField -__init__ mongoengine/fields.py /^ def __init__(self, document_type, fields=None, auto_sync=True, **kwargs):$/;" m class:CachedReferenceField -__init__ mongoengine/fields.py /^ def __init__(self, document_type, passthrough=False, dbref=False,$/;" m class:LazyReferenceField -__init__ mongoengine/fields.py /^ def __init__(self, domain_whitelist=None, allow_utf8_user=False,$/;" m class:EmailField -__init__ mongoengine/fields.py /^ def __init__(self, field, **kwargs):$/;" m class:SortedListField -__init__ mongoengine/fields.py /^ def __init__(self, field=None, **kwargs):$/;" m class:ListField -__init__ mongoengine/fields.py /^ def __init__(self, field=None, *args, **kwargs):$/;" m class:MapField -__init__ mongoengine/fields.py /^ def __init__(self, grid_id=None, key=None,$/;" m class:GridFSProxy -__init__ mongoengine/fields.py /^ def __init__(self, max_bytes=None, **kwargs):$/;" m class:BinaryField -__init__ mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:FloatField -__init__ mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:IntField -__init__ mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:LongField -__init__ mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, force_string=False,$/;" m class:DecimalField -__init__ mongoengine/fields.py /^ def __init__(self, regex=None, max_length=None, min_length=None, **kwargs):$/;" m class:StringField -__init__ mongoengine/fields.py /^ def __init__(self, separator=',', **kwargs):$/;" m class:ComplexDateTimeField -__init__ mongoengine/fields.py /^ def __init__(self, size=None, thumbnail_size=None,$/;" m class:ImageField -__init__ mongoengine/fields.py /^ def __init__(self, verify_exists=False, url_regex=None, schemes=None, **kwargs):$/;" m class:URLField -__init__ mongoengine/mongoengine/base/datastructures.py /^ def __init__(self, **kwargs):$/;" m class:StrictDict -__init__ mongoengine/mongoengine/base/datastructures.py /^ def __init__(self, dict_items, instance, name):$/;" m class:BaseDict -__init__ mongoengine/mongoengine/base/datastructures.py /^ def __init__(self, document_type, pk, cached_doc=None, passthrough=False):$/;" m class:LazyReference -__init__ mongoengine/mongoengine/base/datastructures.py /^ def __init__(self, list_items, instance, name):$/;" m class:BaseList -__init__ mongoengine/mongoengine/base/datastructures.py /^ def __init__(self, list_items, instance, name):$/;" m class:EmbeddedDocumentList -__init__ mongoengine/mongoengine/base/document.py /^ def __init__(self, *args, **values):$/;" m class:BaseDocument -__init__ mongoengine/mongoengine/base/fields.py /^ def __init__(self, auto_index=True, *args, **kwargs):$/;" m class:GeoJsonBaseField -__init__ mongoengine/mongoengine/base/fields.py /^ def __init__(self, db_field=None, name=None, required=False, default=None,$/;" m class:BaseField -__init__ mongoengine/mongoengine/context_managers.py /^ def __init__(self):$/;" m class:query_counter -__init__ mongoengine/mongoengine/context_managers.py /^ def __init__(self, cls):$/;" m class:no_dereference -__init__ mongoengine/mongoengine/context_managers.py /^ def __init__(self, cls):$/;" m class:no_sub_classes -__init__ mongoengine/mongoengine/context_managers.py /^ def __init__(self, cls, collection_name):$/;" m class:switch_collection -__init__ mongoengine/mongoengine/context_managers.py /^ def __init__(self, cls, db_alias):$/;" m class:switch_db -__init__ mongoengine/mongoengine/document.py /^ def __init__(self, *args, **kwargs):$/;" m class:EmbeddedDocument -__init__ mongoengine/mongoengine/document.py /^ def __init__(self, document, collection, key, value):$/;" m class:MapReduceDocument -__init__ mongoengine/mongoengine/errors.py /^ def __init__(self, message='', **kwargs):$/;" m class:ValidationError -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, *args, **kwargs):$/;" m class:GenericLazyReferenceField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, *args, **kwargs):$/;" m class:GenericReferenceField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, basecls=None, field=None, *args, **kwargs):$/;" m class:DictField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, binary=True, **kwargs):$/;" m class:UUIDField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, collection_name=None, db_alias=None, sequence_name=None,$/;" m class:SequenceField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, db_alias=DEFAULT_CONNECTION_NAME, collection_name='fs',$/;" m class:FileField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, document_type, **kwargs):$/;" m class:EmbeddedDocumentField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, document_type, **kwargs):$/;" m class:EmbeddedDocumentListField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, document_type, dbref=False,$/;" m class:ReferenceField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, document_type, fields=None, auto_sync=True, **kwargs):$/;" m class:CachedReferenceField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, document_type, passthrough=False, dbref=False,$/;" m class:LazyReferenceField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, domain_whitelist=None, allow_utf8_user=False,$/;" m class:EmailField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, field, **kwargs):$/;" m class:SortedListField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, field=None, **kwargs):$/;" m class:ListField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, field=None, *args, **kwargs):$/;" m class:MapField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, grid_id=None, key=None,$/;" m class:GridFSProxy -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, max_bytes=None, **kwargs):$/;" m class:BinaryField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:FloatField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:IntField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, **kwargs):$/;" m class:LongField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, min_value=None, max_value=None, force_string=False,$/;" m class:DecimalField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, regex=None, max_length=None, min_length=None, **kwargs):$/;" m class:StringField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, separator=',', **kwargs):$/;" m class:ComplexDateTimeField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, size=None, thumbnail_size=None,$/;" m class:ImageField -__init__ mongoengine/mongoengine/fields.py /^ def __init__(self, verify_exists=False, url_regex=None, schemes=None, **kwargs):$/;" m class:URLField -__init__ mongoengine/mongoengine/queryset/base.py /^ def __init__(self, document, collection):$/;" m class:BaseQuerySet -__init__ mongoengine/mongoengine/queryset/field_list.py /^ def __init__(self, fields=None, value=ONLY, always_include=None, _only_called=False):$/;" m class:QueryFieldList -__init__ mongoengine/mongoengine/queryset/manager.py /^ def __init__(self, queryset_func=None):$/;" m class:QuerySetManager -__init__ mongoengine/mongoengine/queryset/visitor.py /^ def __init__(self, **query):$/;" m class:Q -__init__ mongoengine/mongoengine/queryset/visitor.py /^ def __init__(self, document):$/;" m class:QueryCompilerVisitor -__init__ mongoengine/mongoengine/queryset/visitor.py /^ def __init__(self, operation, children):$/;" m class:QCombination -__init__ mongoengine/mongoengine/signals.py /^ def __init__(self, name, doc=None):$/;" m class:_FakeSignal -__init__ mongoengine/tests/fields/fields.py /^ def __init__(self, **kwargs):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField -__init__ tests/fields/fields.py /^ def __init__(self, **kwargs):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField -__int__ mongoengine/mongoengine/context_managers.py /^ def __int__(self):$/;" m class:query_counter file: -__iter__ mongoengine/mongoengine/base/datastructures.py /^ def __iter__(self):$/;" m class:BaseList file: -__iter__ mongoengine/mongoengine/base/datastructures.py /^ def __iter__(self):$/;" m class:StrictDict file: -__iter__ mongoengine/mongoengine/base/document.py /^ def __iter__(self):$/;" m class:BaseDocument file: -__iter__ mongoengine/mongoengine/queryset/base.py /^ def __iter__(self):$/;" m class:BaseQuerySet file: -__iter__ mongoengine/mongoengine/queryset/queryset.py /^ def __iter__(self):$/;" m class:QuerySet file: -__iter__ mongoengine/mongoengine/queryset/queryset.py /^ def __iter__(self):$/;" m class:QuerySetNoCache file: -__le__ mongoengine/mongoengine/context_managers.py /^ def __le__(self, value):$/;" m class:query_counter file: -__len__ mongoengine/mongoengine/base/datastructures.py /^ def __len__(self):$/;" m class:StrictDict file: -__len__ mongoengine/mongoengine/base/document.py /^ def __len__(self):$/;" m class:BaseDocument file: -__len__ mongoengine/mongoengine/queryset/queryset.py /^ def __len__(self):$/;" m class:QuerySet file: -__lt__ mongoengine/mongoengine/context_managers.py /^ def __lt__(self, value):$/;" m class:query_counter file: -__match_all mongoengine/mongoengine/base/datastructures.py /^ def __match_all(cls, embedded_doc, kwargs):$/;" m class:EmbeddedDocumentList file: -__metaclass__ mongoengine/mongoengine/document.py /^ __metaclass__ = DocumentMetaclass$/;" v class:DynamicEmbeddedDocument -__metaclass__ mongoengine/mongoengine/document.py /^ __metaclass__ = DocumentMetaclass$/;" v class:EmbeddedDocument -__metaclass__ mongoengine/mongoengine/document.py /^ __metaclass__ = TopLevelDocumentMetaclass$/;" v class:Document -__metaclass__ mongoengine/mongoengine/document.py /^ __metaclass__ = TopLevelDocumentMetaclass$/;" v class:DynamicDocument -__ne__ mongoengine/fields.py /^ def __ne__(self, other):$/;" m class:GridFSProxy file: -__ne__ mongoengine/mongoengine/base/datastructures.py /^ def __ne__(self, other):$/;" m class:StrictDict file: -__ne__ mongoengine/mongoengine/base/document.py /^ def __ne__(self, other):$/;" m class:BaseDocument file: -__ne__ mongoengine/mongoengine/context_managers.py /^ def __ne__(self, value):$/;" m class:query_counter file: -__ne__ mongoengine/mongoengine/document.py /^ def __ne__(self, other):$/;" m class:EmbeddedDocument file: -__ne__ mongoengine/mongoengine/fields.py /^ def __ne__(self, other):$/;" m class:GridFSProxy file: -__new__ mongoengine/mongoengine/base/metaclasses.py /^ def __new__(cls, name, bases, attrs):$/;" m class:DocumentMetaclass file: -__new__ mongoengine/mongoengine/base/metaclasses.py /^ def __new__(cls, name, bases, attrs):$/;" m class:TopLevelDocumentMetaclass file: -__nonzero__ mongoengine/fields.py /^ def __nonzero__(self):$/;" m class:GridFSProxy file: -__nonzero__ mongoengine/mongoengine/fields.py /^ def __nonzero__(self):$/;" m class:GridFSProxy file: -__nonzero__ mongoengine/mongoengine/queryset/base.py /^ def __nonzero__(self):$/;" m class:BaseQuerySet file: -__nonzero__ mongoengine/mongoengine/queryset/field_list.py /^ def __nonzero__(self):$/;" m class:QueryFieldList file: -__only_matches mongoengine/mongoengine/base/datastructures.py /^ def __only_matches(cls, embedded_docs, kwargs):$/;" m class:EmbeddedDocumentList file: -__or__ mongoengine/mongoengine/queryset/visitor.py /^ def __or__(self, other):$/;" m class:QNode file: -__raw__ mongoengine/tests/queryset/queryset.py /^ __raw__={"$addToSet": {"tags": {"$each": ["code", "mongodb", "code"]}}})$/;" v class:QuerySetTest.test_update_push_and_pull_add_to_set.BlogPost -__raw__ mongoengine/tests/queryset/queryset.py /^ __raw__={'document.a_name': 'A doc'}).count(), 1)$/;" v class:QuerySetTest.test_query_generic_embedded_document.Doc -__raw__ mongoengine/tests/queryset/queryset.py /^ __raw__={'document.b_name': 'B doc'}).count(), 1)$/;" v class:QuerySetTest.test_query_generic_embedded_document.Doc -__repr__ mongoengine/fields.py /^ def __repr__(self):$/;" m class:GridFSProxy file: -__repr__ mongoengine/mongoengine/base/datastructures.py /^ def __repr__(self):$/;" m class:StrictDict.create.SpecificStrictDict file: -__repr__ mongoengine/mongoengine/base/datastructures.py /^ def __repr__(self):$/;" m class:LazyReference file: -__repr__ mongoengine/mongoengine/base/document.py /^ def __repr__(self):$/;" m class:BaseDocument file: -__repr__ mongoengine/mongoengine/context_managers.py /^ def __repr__(self):$/;" m class:query_counter file: -__repr__ mongoengine/mongoengine/errors.py /^ def __repr__(self):$/;" m class:ValidationError file: -__repr__ mongoengine/mongoengine/fields.py /^ def __repr__(self):$/;" m class:GridFSProxy file: -__repr__ mongoengine/mongoengine/queryset/queryset.py /^ def __repr__(self):$/;" m class:QuerySet file: -__repr__ mongoengine/mongoengine/queryset/queryset.py /^ def __repr__(self):$/;" m class:QuerySetNoCache file: -__repr__ mongoengine/tests/queryset/queryset.py /^ def __repr__(self):$/;" m class:QuerySetTest.test_repr.Doc file: -__repr__ mongoengine/tests/test_dereference.py /^ def __repr__(self):$/;" m class:FieldTest.test_circular_reference.Person file: -__repr__ mongoengine/tests/test_dereference.py /^ def __repr__(self):$/;" m class:FieldTest.test_circular_reference_on_self.Person file: -__repr__ mongoengine/tests/test_dereference.py /^ def __repr__(self):$/;" m class:FieldTest.test_circular_tree_reference.Person file: -__set__ mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:BinaryField file: -__set__ mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:ComplexDateTimeField file: -__set__ mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:FileField file: -__set__ mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:SequenceField file: -__set__ mongoengine/mongoengine/base/fields.py /^ def __set__(self, instance, value):$/;" m class:BaseField file: -__set__ mongoengine/mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:BinaryField file: -__set__ mongoengine/mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:ComplexDateTimeField file: -__set__ mongoengine/mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:FileField file: -__set__ mongoengine/mongoengine/fields.py /^ def __set__(self, instance, value):$/;" m class:SequenceField file: -__set_field_display mongoengine/mongoengine/base/document.py /^ def __set_field_display(self):$/;" m class:BaseDocument file: -__setattr__ mongoengine/mongoengine/base/document.py /^ def __setattr__(self, name, value):$/;" m class:BaseDocument file: -__setitem__ mongoengine/mongoengine/base/datastructures.py /^ def __setitem__(self, key, value):$/;" m class:StrictDict file: -__setitem__ mongoengine/mongoengine/base/datastructures.py /^ def __setitem__(self, key, value, *args, **kwargs):$/;" m class:BaseDict file: -__setitem__ mongoengine/mongoengine/base/datastructures.py /^ def __setitem__(self, key, value, *args, **kwargs):$/;" m class:BaseList file: -__setitem__ mongoengine/mongoengine/base/document.py /^ def __setitem__(self, name, value):$/;" m class:BaseDocument file: -__setslice__ mongoengine/mongoengine/base/datastructures.py /^ def __setslice__(self, *args, **kwargs):$/;" m class:BaseList file: -__setstate__ mongoengine/mongoengine/base/datastructures.py /^ def __setstate__(self, state):$/;" m class:BaseDict file: -__setstate__ mongoengine/mongoengine/base/datastructures.py /^ def __setstate__(self, state):$/;" m class:BaseList file: -__setstate__ mongoengine/mongoengine/base/document.py /^ def __setstate__(self, data):$/;" m class:BaseDocument file: -__setstate__ mongoengine/mongoengine/queryset/base.py /^ def __setstate__(self, obj_dict):$/;" m class:BaseQuerySet file: -__slots__ mongoengine/mongoengine/base/datastructures.py /^ __slots__ = allowed_keys_tuple$/;" v class:StrictDict.create.SpecificStrictDict -__slots__ mongoengine/mongoengine/base/datastructures.py /^ __slots__ = ('_cached_doc', 'passthrough', 'document_type')$/;" v class:LazyReference -__slots__ mongoengine/mongoengine/base/datastructures.py /^ __slots__ = ()$/;" v class:StrictDict -__slots__ mongoengine/mongoengine/base/document.py /^ __slots__ = ('_changed_fields', '_initialised', '_created', '_data',$/;" v class:BaseDocument -__slots__ mongoengine/mongoengine/document.py /^ __slots__ = ('__objects',)$/;" v class:Document -__slots__ mongoengine/mongoengine/document.py /^ __slots__ = ('_instance', )$/;" v class:EmbeddedDocument -__str__ mongoengine/fields.py /^ def __str__(self):$/;" m class:GridFSProxy file: -__str__ mongoengine/mongoengine/base/document.py /^ def __str__(self):$/;" m class:BaseDocument file: -__str__ mongoengine/mongoengine/errors.py /^ def __str__(self):$/;" m class:ValidationError file: -__str__ mongoengine/mongoengine/fields.py /^ def __str__(self):$/;" m class:GridFSProxy file: -__str__ mongoengine/tests/document/instance.py /^ def __str__(self):$/;" m class:InstanceTest.test_db_ref_usage.Book file: -__str__ mongoengine/tests/document/instance.py /^ def __str__(self):$/;" m class:InstanceTest.test_repr_none.Article file: -__unicode__ mongoengine/tests/document/instance.py /^ def __unicode__(self):$/;" m class:InstanceTest.test_db_ref_usage.Book file: -__unicode__ mongoengine/tests/document/instance.py /^ def __unicode__(self):$/;" m class:InstanceTest.test_repr.Article file: -__unicode__ mongoengine/tests/queryset/geo.py /^ def __unicode__(self):$/;" m class:GeoQueriesTest._create_event_data.Event file: -__unicode__ mongoengine/tests/queryset/queryset.py /^ def __unicode__(self):$/;" m class:QuerySetTest.test_cache_not_cloned.User file: -__unicode__ mongoengine/tests/queryset/queryset.py /^ def __unicode__(self):$/;" m class:QuerySetTest.test_nested_queryset_iterator.User file: -__unicode__ mongoengine/tests/queryset/queryset.py /^ def __unicode__(self):$/;" m class:QuerySetTest.test_pull_from_nested_embedded.User file: -__unicode__ mongoengine/tests/queryset/queryset.py /^ def __unicode__(self):$/;" m class:QuerySetTest.test_pull_from_nested_mapfield.Collaborator file: -__unicode__ mongoengine/tests/queryset/queryset.py /^ def __unicode__(self):$/;" m class:QuerySetTest.test_pull_nested.Collaborator file: -__unicode__ mongoengine/tests/test_signals.py /^ def __unicode__(self):$/;" m class:SignalTests.setUp.Another file: -__unicode__ mongoengine/tests/test_signals.py /^ def __unicode__(self):$/;" m class:SignalTests.setUp.Author file: -__unicode__ mongoengine/tests/test_signals.py /^ def __unicode__(self):$/;" m class:SignalTests.setUp.Post file: -__version__ mongoengine/mongoengine/__init__.py /^__version__ = get_version()$/;" v -_attach_objects mongoengine/mongoengine/dereference.py /^ def _attach_objects(self, items, depth=0, instance=None, name=None):$/;" m class:DeReference -_auto_dereference mongoengine/mongoengine/base/fields.py /^ _auto_dereference = True$/;" v class:BaseField -_auto_dereference mongoengine/mongoengine/queryset/base.py /^ _auto_dereference = True$/;" v class:BaseQuerySet -_auto_gen mongoengine/fields.py /^ _auto_gen = True$/;" v class:SequenceField -_auto_gen mongoengine/mongoengine/base/fields.py /^ _auto_gen = False # Call `generate` to generate a value$/;" v class:BaseField -_auto_gen mongoengine/mongoengine/fields.py /^ _auto_gen = True$/;" v class:SequenceField -_binary mongoengine/fields.py /^ _binary = None$/;" v class:UUIDField -_binary mongoengine/mongoengine/fields.py /^ _binary = None$/;" v class:UUIDField -_build_index_spec mongoengine/mongoengine/base/document.py /^ def _build_index_spec(cls, spec):$/;" m class:BaseDocument -_build_index_specs mongoengine/mongoengine/base/document.py /^ def _build_index_specs(cls, meta_indexes):$/;" m class:BaseDocument -_chainable_method mongoengine/mongoengine/queryset/base.py /^ def _chainable_method(self, method_name, val):$/;" m class:BaseQuerySet -_class_registry_cache mongoengine/mongoengine/common.py /^_class_registry_cache = {}$/;" v -_classes mongoengine/mongoengine/base/datastructures.py /^ _classes = {}$/;" v class:StrictDict -_clean_settings mongoengine/mongoengine/connection.py /^ def _clean_settings(settings_dict):$/;" f function:get_connection -_clean_slice mongoengine/mongoengine/queryset/field_list.py /^ def _clean_slice(self):$/;" m class:QueryFieldList -_clear_changed_fields mongoengine/mongoengine/base/document.py /^ def _clear_changed_fields(self):$/;" m class:BaseDocument -_clone_into mongoengine/mongoengine/queryset/base.py /^ def _clone_into(self, new_qs):$/;" m class:BaseQuerySet -_collection mongoengine/mongoengine/queryset/base.py /^ def _collection(self):$/;" m class:BaseQuerySet -_combine mongoengine/mongoengine/queryset/visitor.py /^ def _combine(self, other, operation):$/;" m class:QNode -_connection_settings mongoengine/mongoengine/connection.py /^_connection_settings = {}$/;" v -_connections mongoengine/mongoengine/connection.py /^_connections = {}$/;" v -_convert_from_datetime mongoengine/fields.py /^ def _convert_from_datetime(self, val):$/;" m class:ComplexDateTimeField -_convert_from_datetime mongoengine/mongoengine/fields.py /^ def _convert_from_datetime(self, val):$/;" m class:ComplexDateTimeField -_convert_from_string mongoengine/fields.py /^ def _convert_from_string(self, data):$/;" m class:ComplexDateTimeField -_convert_from_string mongoengine/mongoengine/fields.py /^ def _convert_from_string(self, data):$/;" m class:ComplexDateTimeField -_create_event_data mongoengine/tests/queryset/geo.py /^ def _create_event_data(self, point_field_class=GeoPointField):$/;" m class:GeoQueriesTest -_cursor mongoengine/mongoengine/queryset/base.py /^ def _cursor(self):$/;" m class:BaseQuerySet -_cursor_args mongoengine/mongoengine/queryset/base.py /^ def _cursor_args(self):$/;" m class:BaseQuerySet -_dbs mongoengine/mongoengine/connection.py /^_dbs = {}$/;" v -_decorated_with_ver_requirement mongoengine/tests/utils.py /^def _decorated_with_ver_requirement(func, ver_tuple):$/;" f -_delta mongoengine/mongoengine/base/document.py /^ def _delta(self):$/;" m class:BaseDocument -_dereference mongoengine/mongoengine/queryset/base.py /^ def _dereference(self):$/;" m class:BaseQuerySet -_dereferenced mongoengine/mongoengine/base/datastructures.py /^ _dereferenced = False$/;" v class:BaseDict -_dereferenced mongoengine/mongoengine/base/datastructures.py /^ _dereferenced = False$/;" v class:BaseList -_document_registry mongoengine/mongoengine/base/common.py /^_document_registry = {}$/;" v -_dynamic mongoengine/mongoengine/base/document.py /^ _dynamic = False$/;" v class:BaseDocument -_dynamic mongoengine/mongoengine/document.py /^ _dynamic = True$/;" v class:DynamicDocument -_dynamic mongoengine/mongoengine/document.py /^ _dynamic = True$/;" v class:DynamicEmbeddedDocument -_dynamic_lock mongoengine/mongoengine/base/document.py /^ _dynamic_lock = True$/;" v class:BaseDocument -_ensure_indexes mongoengine/mongoengine/queryset/base.py /^ def _ensure_indexes(self):$/;" m class:BaseQuerySet -_fail mongoengine/mongoengine/signals.py /^ def _fail(self, *args, **kwargs):$/;" m class:_FakeSignal -_fetch_objects mongoengine/mongoengine/dereference.py /^ def _fetch_objects(self, doc_type=None):$/;" m class:DeReference -_field_list_cache mongoengine/mongoengine/common.py /^_field_list_cache = []$/;" v -_fields_to_dbfields mongoengine/mongoengine/queryset/base.py /^ def _fields_to_dbfields(self, fields):$/;" m class:BaseQuerySet -_find_references mongoengine/mongoengine/dereference.py /^ def _find_references(self, items, depth=0):$/;" m class:DeReference -_format_errors mongoengine/mongoengine/errors.py /^ def _format_errors(self):$/;" m class:ValidationError -_from_son mongoengine/mongoengine/base/document.py /^ def _from_son(cls, son, _auto_dereference=True, only_fields=None, created=False):$/;" m class:BaseDocument -_fs mongoengine/fields.py /^ _fs = None$/;" v class:GridFSProxy -_fs mongoengine/mongoengine/fields.py /^ _fs = None$/;" v class:GridFSProxy -_geo_index mongoengine/fields.py /^ _geo_index = pymongo.GEO2D$/;" v class:GeoPointField -_geo_index mongoengine/mongoengine/base/fields.py /^ _geo_index = False$/;" v class:BaseField -_geo_index mongoengine/mongoengine/base/fields.py /^ _geo_index = pymongo.GEOSPHERE$/;" v class:GeoJsonBaseField -_geo_index mongoengine/mongoengine/fields.py /^ _geo_index = pymongo.GEO2D$/;" v class:GeoPointField -_geo_indices mongoengine/mongoengine/base/document.py /^ def _geo_indices(cls, inspected=None, parent_field=None):$/;" m class:BaseDocument -_geo_operator mongoengine/mongoengine/queryset/transform.py /^def _geo_operator(field, op, value):$/;" f -_get_as_pymongo mongoengine/mongoengine/queryset/base.py /^ def _get_as_pymongo(self, doc):$/;" m class:BaseQuerySet -_get_bases mongoengine/mongoengine/base/metaclasses.py /^ def _get_bases(cls, bases):$/;" m class:DocumentMetaclass -_get_capped_collection mongoengine/mongoengine/document.py /^ def _get_capped_collection(cls):$/;" m class:Document -_get_changed_fields mongoengine/mongoengine/base/document.py /^ def _get_changed_fields(self, inspected=None):$/;" m class:BaseDocument -_get_collection mongoengine/mongoengine/document.py /^ def _get_collection(cls):$/;" m class:Document -_get_collection_name mongoengine/mongoengine/base/document.py /^ def _get_collection_name(cls):$/;" m class:BaseDocument -_get_collection_name mongoengine/mongoengine/context_managers.py /^ def _get_collection_name(cls):$/;" f function:switch_collection.__enter__ -_get_connection mongoengine/mongoengine/connection.py /^_get_connection = get_connection$/;" v -_get_count mongoengine/mongoengine/context_managers.py /^ def _get_count(self):$/;" m class:query_counter -_get_db mongoengine/mongoengine/connection.py /^_get_db = get_db$/;" v -_get_db mongoengine/mongoengine/document.py /^ def _get_db(cls):$/;" m class:Document -_get_items mongoengine/mongoengine/dereference.py /^ def _get_items(items):$/;" f function:DeReference.__call__ -_get_loaded mongoengine/tests/queryset/pickable.py /^ def _get_loaded(self, qs):$/;" m class:TestQuerysetPickable -_get_message mongoengine/mongoengine/errors.py /^ def _get_message(self):$/;" m class:ValidationError -_get_order_by mongoengine/mongoengine/queryset/base.py /^ def _get_order_by(self, keys):$/;" m class:BaseQuerySet -_get_scalar mongoengine/mongoengine/queryset/base.py /^ def _get_scalar(self, doc):$/;" m class:BaseQuerySet -_get_update_doc mongoengine/mongoengine/document.py /^ def _get_update_doc(self):$/;" m class:Document -_has_data mongoengine/mongoengine/queryset/base.py /^ def _has_data(self):$/;" m class:BaseQuerySet -_has_more mongoengine/mongoengine/queryset/queryset.py /^ _has_more = True$/;" v class:QuerySet -_import_class mongoengine/mongoengine/common.py /^def _import_class(cls_name):$/;" f -_import_classes mongoengine/mongoengine/base/metaclasses.py /^ def _import_classes(cls):$/;" m class:DocumentMetaclass -_index_test mongoengine/tests/document/indexes.py /^ def _index_test(self, InheritFrom):$/;" m class:IndexesTest -_index_test_inheritance mongoengine/tests/document/indexes.py /^ def _index_test_inheritance(self, InheritFrom):$/;" m class:IndexesTest -_infer_geometry mongoengine/mongoengine/queryset/transform.py /^def _infer_geometry(value):$/;" f -_inner mongoengine/tests/utils.py /^ def _inner(*args, **kwargs):$/;" f function:_decorated_with_ver_requirement -_inner mongoengine/tests/utils.py /^ def _inner(*args, **kwargs):$/;" f function:skip_pymongo3 -_instance mongoengine/mongoengine/base/datastructures.py /^ _instance = None$/;" v class:BaseDict -_instance mongoengine/mongoengine/base/datastructures.py /^ _instance = None$/;" v class:BaseList -_item_frequencies_exec_js mongoengine/mongoengine/queryset/base.py /^ def _item_frequencies_exec_js(self, field, normalize=False):$/;" m class:BaseQuerySet -_item_frequencies_map_reduce mongoengine/mongoengine/queryset/base.py /^ def _item_frequencies_map_reduce(self, field, normalize=False):$/;" m class:BaseQuerySet -_iter_results mongoengine/mongoengine/queryset/queryset.py /^ def _iter_results(self):$/;" m class:QuerySet -_len mongoengine/mongoengine/queryset/queryset.py /^ _len = None$/;" v class:QuerySet -_lookup_field mongoengine/mongoengine/base/document.py /^ def _lookup_field(cls, parts):$/;" m class:BaseDocument -_mark_as_changed mongoengine/fields.py /^ def _mark_as_changed(self):$/;" m class:GridFSProxy -_mark_as_changed mongoengine/mongoengine/base/datastructures.py /^ def _mark_as_changed(self, key=None):$/;" m class:BaseDict -_mark_as_changed mongoengine/mongoengine/base/datastructures.py /^ def _mark_as_changed(self, key=None):$/;" m class:BaseList -_mark_as_changed mongoengine/mongoengine/base/document.py /^ def _mark_as_changed(self, key):$/;" m class:BaseDocument -_mark_as_changed mongoengine/mongoengine/fields.py /^ def _mark_as_changed(self):$/;" m class:GridFSProxy -_merge_options mongoengine/mongoengine/base/metaclasses.py /^ _merge_options = ('indexes',)$/;" v class:MetaDict -_message mongoengine/mongoengine/errors.py /^ _message = None$/;" v class:ValidationError -_name mongoengine/mongoengine/base/datastructures.py /^ _name = None$/;" v class:BaseDict -_name mongoengine/mongoengine/base/datastructures.py /^ _name = None$/;" v class:BaseList -_nestable_types_changed_fields mongoengine/mongoengine/base/document.py /^ def _nestable_types_changed_fields(self, changed_fields, key, data, inspected):$/;" m class:BaseDocument -_object_key mongoengine/mongoengine/document.py /^ def _object_key(self):$/;" m class:Document -_order_reverse mongoengine/fields.py /^ _order_reverse = False$/;" v class:SortedListField -_order_reverse mongoengine/mongoengine/fields.py /^ _order_reverse = False$/;" v class:SortedListField -_ordering mongoengine/fields.py /^ _ordering = None$/;" v class:SortedListField -_ordering mongoengine/mongoengine/fields.py /^ _ordering = None$/;" v class:SortedListField -_populate_cache mongoengine/mongoengine/queryset/queryset.py /^ def _populate_cache(self):$/;" m class:QuerySet -_prepare_query_for_iterable mongoengine/mongoengine/queryset/transform.py /^def _prepare_query_for_iterable(field, op, value):$/;" f -_put_thumbnail mongoengine/fields.py /^ def _put_thumbnail(self, thumbnail, format, progressive, **kwargs):$/;" m class:ImageGridFsProxy -_put_thumbnail mongoengine/mongoengine/fields.py /^ def _put_thumbnail(self, thumbnail, format, progressive, **kwargs):$/;" m class:ImageGridFsProxy -_qs mongoengine/mongoengine/document.py /^ def _qs(self):$/;" m class:Document -_query mongoengine/mongoengine/queryset/base.py /^ def _query(self):$/;" m class:BaseQuerySet -_query_conjunction mongoengine/mongoengine/queryset/visitor.py /^ def _query_conjunction(self, queries):$/;" m class:SimplificationVisitor -_rank mongoengine/tests/document/instance.py /^ _rank = StringField(required=False, db_field="rank")$/;" v class:InstanceTest.test_db_field_load.Person -_reload mongoengine/mongoengine/document.py /^ def _reload(self, key, value):$/;" m class:Document -_result_cache mongoengine/mongoengine/queryset/queryset.py /^ _result_cache = None$/;" v class:QuerySet -_save_create mongoengine/mongoengine/document.py /^ def _save_create(self, doc, force_insert, write_concern):$/;" m class:Document -_save_update mongoengine/mongoengine/document.py /^ def _save_update(self, doc, save_condition, write_concern):$/;" m class:Document -_set_message mongoengine/mongoengine/errors.py /^ def _set_message(self, message):$/;" m class:ValidationError -_set_owner_document mongoengine/mongoengine/base/fields.py /^ def _set_owner_document(self, owner_document):$/;" m class:BaseField -_set_owner_document mongoengine/mongoengine/base/fields.py /^ def _set_owner_document(self, owner_document):$/;" m class:ComplexBaseField -_signals mongoengine/mongoengine/signals.py /^_signals = Namespace()$/;" v -_sort_key mongoengine/mongoengine/queryset/base.py /^ def _sort_key(field_tuple):$/;" f function:BaseQuerySet.fields -_special_fields mongoengine/mongoengine/base/datastructures.py /^ _special_fields = set(['get', 'pop', 'iteritems', 'items', 'keys', 'create'])$/;" v class:StrictDict -_sub_js_fields mongoengine/mongoengine/queryset/base.py /^ def _sub_js_fields(self, code):$/;" m class:BaseQuerySet -_test_embedded mongoengine/tests/queryset/geo.py /^ def _test_embedded(self, point_field_class):$/;" m class:GeoQueriesTest -_test_for_expected_error mongoengine/tests/fields/geo.py /^ def _test_for_expected_error(self, Cls, loc, expected):$/;" m class:GeoFieldTest -_to_mongo_safe_call mongoengine/mongoengine/base/fields.py /^ def _to_mongo_safe_call(self, value, use_db_field=True, fields=None):$/;" m class:BaseField -_translate_field_name mongoengine/mongoengine/base/document.py /^ def _translate_field_name(cls, field, sep='.'):$/;" m class:BaseDocument -_type mongoengine/fields.py /^ _type = 'LineString'$/;" v class:LineStringField -_type mongoengine/fields.py /^ _type = 'MultiLineString'$/;" v class:MultiLineStringField -_type mongoengine/fields.py /^ _type = 'MultiPoint'$/;" v class:MultiPointField -_type mongoengine/fields.py /^ _type = 'MultiPolygon'$/;" v class:MultiPolygonField -_type mongoengine/fields.py /^ _type = 'Point'$/;" v class:PointField -_type mongoengine/fields.py /^ _type = 'Polygon'$/;" v class:PolygonField -_type mongoengine/mongoengine/base/fields.py /^ _type = 'GeoBase'$/;" v class:GeoJsonBaseField -_type mongoengine/mongoengine/fields.py /^ _type = 'LineString'$/;" v class:LineStringField -_type mongoengine/mongoengine/fields.py /^ _type = 'MultiLineString'$/;" v class:MultiLineStringField -_type mongoengine/mongoengine/fields.py /^ _type = 'MultiPoint'$/;" v class:MultiPointField -_type mongoengine/mongoengine/fields.py /^ _type = 'MultiPolygon'$/;" v class:MultiPolygonField -_type mongoengine/mongoengine/fields.py /^ _type = 'Point'$/;" v class:PointField -_type mongoengine/mongoengine/fields.py /^ _type = 'Polygon'$/;" v class:PolygonField -_unique_with_indexes mongoengine/mongoengine/base/document.py /^ def _unique_with_indexes(cls, namespace=''):$/;" m class:BaseDocument -_validate mongoengine/mongoengine/base/fields.py /^ def _validate(self, value, **kwargs):$/;" m class:BaseField -_validate_choices mongoengine/fields.py /^ def _validate_choices(self, value):$/;" m class:GenericLazyReferenceField -_validate_choices mongoengine/fields.py /^ def _validate_choices(self, value):$/;" m class:GenericReferenceField -_validate_choices mongoengine/mongoengine/base/fields.py /^ def _validate_choices(self, value):$/;" m class:BaseField -_validate_choices mongoengine/mongoengine/fields.py /^ def _validate_choices(self, value):$/;" m class:GenericLazyReferenceField -_validate_choices mongoengine/mongoengine/fields.py /^ def _validate_choices(self, value):$/;" m class:GenericReferenceField -_validate_linestring mongoengine/mongoengine/base/fields.py /^ def _validate_linestring(self, value, top_level=True):$/;" m class:GeoJsonBaseField -_validate_multilinestring mongoengine/mongoengine/base/fields.py /^ def _validate_multilinestring(self, value, top_level=True):$/;" m class:GeoJsonBaseField -_validate_multipoint mongoengine/mongoengine/base/fields.py /^ def _validate_multipoint(self, value):$/;" m class:GeoJsonBaseField -_validate_multipolygon mongoengine/mongoengine/base/fields.py /^ def _validate_multipolygon(self, value):$/;" m class:GeoJsonBaseField -_validate_point mongoengine/mongoengine/base/fields.py /^ def _validate_point(self, value):$/;" m class:GeoJsonBaseField -_validate_polygon mongoengine/mongoengine/base/fields.py /^ def _validate_polygon(self, value, top_level=True):$/;" m class:GeoJsonBaseField -a mongoengine/tests/document/indexes.py /^ a = IntField()$/;" v class:IndexesTest.test_covered_index.Test -a mongoengine/tests/document/inheritance.py /^ a = StringField()$/;" v class:InheritanceTest.test_indexes_and_multiple_inheritance.A -a mongoengine/tests/queryset/field_list.py /^ a = ListField()$/;" v class:OnlyExcludeAllTest.test_mix_slice_with_other_fields.MyDoc -a mongoengine/tests/queryset/field_list.py /^ a = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc -a mongoengine/tests/queryset/field_list.py /^ a = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc -a mongoengine/tests/queryset/queryset.py /^ a = ReferenceField(A)$/;" v class:QuerySetTest.test_query_reference_to_custom_pk_doc.B -a mongoengine/tests/queryset/transform.py /^ a = ReferenceField(A)$/;" v class:TransformTest.test_chaining.B -a mongoengine/tests/queryset/transform.py /^ a = StringField()$/;" v class:TransformTest.test_raw_query_and_Q_objects.Foo -a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i)$/;" v class:FieldTest.test_dict_field.Group -a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i)$/;" v class:FieldTest.test_dict_field_no_field_inheritance.Group -a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i)$/;" v class:FieldTest.test_generic_reference.Group -a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i)$/;" v class:FieldTest.test_generic_reference_map_field.Group -a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i)$/;" v class:FieldTest.test_list_field_complex.Group -a mongoengine/tests/test_dereference.py /^ a = UserA(name='User A %s' % i).save()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group -a_field mongoengine/tests/fields/fields.py /^ a_field = IntField()$/;" v class:EmbeddedDocumentListFieldTestCase.test_custom_data.CustomData -a_field tests/fields/fields.py /^ a_field = IntField()$/;" v class:EmbeddedDocumentListFieldTestCase.test_custom_data.CustomData -a_name mongoengine/tests/queryset/queryset.py /^ a_name = StringField()$/;" v class:QuerySetTest.test_query_generic_embedded_document.A -accept mongoengine/mongoengine/queryset/visitor.py /^ def accept(self, visitor):$/;" m class:Q -accept mongoengine/mongoengine/queryset/visitor.py /^ def accept(self, visitor):$/;" m class:QCombination -accept mongoengine/mongoengine/queryset/visitor.py /^ def accept(self, visitor):$/;" m class:QNode -actions mongoengine/tests/fields/fields.py /^ actions = MapField(EmbeddedDocumentField(Action))$/;" v class:FieldTest.test_map_field_lookup.Log -actions mongoengine/tests/fields/fields.py /^ actions={'friends': Action(operation='drink', object='beer')}).save()$/;" v class:FieldTest.test_map_field_lookup.Log -actions tests/fields/fields.py /^ actions = MapField(EmbeddedDocumentField(Action))$/;" v class:FieldTest.test_map_field_lookup.Log -actions tests/fields/fields.py /^ actions={'friends': Action(operation='drink', object='beer')}).save()$/;" v class:FieldTest.test_map_field_lookup.Log -actions__friends__object mongoengine/tests/fields/fields.py /^ actions__friends__object='beer').count())$/;" v class:FieldTest.test_map_field_lookup.Log -actions__friends__object tests/fields/fields.py /^ actions__friends__object='beer').count())$/;" v class:FieldTest.test_map_field_lookup.Log -actions__friends__operation mongoengine/tests/fields/fields.py /^ actions__friends__operation='drink',$/;" v class:FieldTest.test_map_field_lookup.Log -actions__friends__operation tests/fields/fields.py /^ actions__friends__operation='drink',$/;" v class:FieldTest.test_map_field_lookup.Log -active mongoengine/tests/document/instance.py /^ active = BooleanField(default=True)$/;" v class:InstanceTest.test_save_only_changed_fields.User -active mongoengine/tests/document/instance.py /^ active = BooleanField(default=True)$/;" v class:InstanceTest.test_save_only_changed_fields_recursive.User -active mongoengine/tests/queryset/queryset.py /^ active = BooleanField(default=False)$/;" v class:QuerySetTest.test_custom_manager_overriding_objects_works.Foo -active mongoengine/tests/queryset/queryset.py /^ active = BooleanField(default=True)$/;" v class:QuerySetTest.test_inherit_objects.Foo -active mongoengine/tests/queryset/queryset.py /^ active = BooleanField(default=True)$/;" v class:QuerySetTest.test_inherit_objects_override.Foo -active mongoengine/tests/test_signals.py /^ active = BooleanField(default=False)$/;" v class:SignalTests.setUp.Post -actual mongoengine/tests/fields/fields.py /^ actual = list(Person.objects().scalar(field_name))$/;" v class:FieldTest.test_decimal_storage.Person -actual tests/fields/fields.py /^ actual = list(Person.objects().scalar(field_name))$/;" v class:FieldTest.test_decimal_storage.Person -add_to_class mongoengine/mongoengine/base/metaclasses.py /^ def add_to_class(self, name, value):$/;" m class:DocumentMetaclass -address mongoengine/tests/document/dynamic.py /^ address = EmbeddedDocumentField(Address)$/;" v class:DynamicTest.test_dynamic_embedded_works_with_only.Person -admin mongoengine/tests/fields/fields.py /^ admin = BooleanField()$/;" v class:FieldTest.test_boolean_validation.Person -admin mongoengine/tests/queryset/queryset.py /^ admin = ListField(ReferenceField(User))$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Organization -admin tests/fields/fields.py /^ admin = BooleanField()$/;" v class:FieldTest.test_boolean_validation.Person -adult mongoengine/tests/queryset/queryset.py /^ adult = (User.objects.filter(age__gte=18)$/;" v class:QuerySetTest.test_comment.User -age mongoengine/tests/document/class_methods.py /^ age = IntField()$/;" v class:ClassMethodsTest.setUp.Person -age mongoengine/tests/document/delta.py /^ age = IntField()$/;" v class:DeltaTest.setUp.Person -age mongoengine/tests/document/indexes.py /^ age = IntField()$/;" v class:IndexesTest.setUp.Person -age mongoengine/tests/document/inheritance.py /^ age = IntField()$/;" v class:InheritanceTest.test_inheritance_meta_data.Person -age mongoengine/tests/document/inheritance.py /^ age = IntField()$/;" v class:InheritanceTest.test_inheritance_to_mongo_keys.Person -age mongoengine/tests/document/instance.py /^ age = IntField()$/;" v class:InstanceTest.setUp.Person -age mongoengine/tests/document/instance.py /^ age = IntField()$/;" v class:InstanceTest.test_do_not_save_unchanged_references.Person -age mongoengine/tests/document/instance.py /^ age = IntField()$/;" v class:InstanceTest.test_embedded_document_to_mongo.Person -age mongoengine/tests/document/instance.py /^ age = IntField()$/;" v class:InstanceTest.test_mixin_inheritance.TestDoc -age mongoengine/tests/document/instance.py /^ age = IntField(primary_key=True)$/;" v class:InstanceTest.test_falsey_pk.Person -age mongoengine/tests/document/validation.py /^ age = IntField()$/;" v class:ValidatorErrorTest.test_fields_rewrite.BasePerson -age mongoengine/tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_nothing_set.Person -age mongoengine/tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_set_to_None.Person -age mongoengine/tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person -age mongoengine/tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person -age mongoengine/tests/fields/fields.py /^ age = IntField(min_value=0, max_value=110)$/;" v class:FieldTest.test_int_validation.Person -age mongoengine/tests/fields/fields.py /^ age = IntField(required=True)$/;" v class:FieldTest.test_required_values.Person -age mongoengine/tests/queryset/field_list.py /^ age = IntField()$/;" v class:OnlyExcludeAllTest.setUp.Person -age mongoengine/tests/queryset/pickable.py /^ age = IntField()$/;" v class:Person -age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.setUp.Person -age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_as_pymongo.User -age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_comment.User -age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person -age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_mapfield_update.Member -age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_queryset_aggregation_framework.Person -age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_scalar_embedded.Profile -age mongoengine/tests/queryset/queryset.py /^ age = IntField()$/;" v class:QuerySetTest.test_scalar_simple.UserDoc -age mongoengine/tests/queryset/queryset.py /^ age=51,$/;" v class:QuerySetTest.test_as_pymongo.User -age mongoengine/tests/queryset/visitor.py /^ age = IntField()$/;" v class:QTest.setUp.Person -age mongoengine/tests/queryset/visitor.py /^ age = IntField()$/;" v class:QTest.test_empty_q.Person -age tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_nothing_set.Person -age tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_set_to_None.Person -age tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person -age tests/fields/fields.py /^ age = IntField(default=30, required=False)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person -age tests/fields/fields.py /^ age = IntField(min_value=0, max_value=110)$/;" v class:FieldTest.test_int_validation.Person -age tests/fields/fields.py /^ age = IntField(required=True)$/;" v class:FieldTest.test_required_values.Person -aggregate mongoengine/mongoengine/queryset/base.py /^ def aggregate(self, *pipeline, **kwargs):$/;" m class:BaseQuerySet -all mongoengine/mongoengine/queryset/base.py /^ def all(self):$/;" m class:BaseQuerySet -all_fields mongoengine/mongoengine/queryset/base.py /^ def all_fields(self):$/;" m class:BaseQuerySet -animal mongoengine/tests/fields/fields.py /^ animal=Animal(name="Leopard", tag="heavy").save()).save()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence -animal mongoengine/tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence -animal mongoengine/tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -animal mongoengine/tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Ocorrence -animal mongoengine/tests/fields/fields.py /^ animal = CachedReferenceField(Animal)$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence -animal mongoengine/tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Ocurrence -animal mongoengine/tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Ocurrence -animal mongoengine/tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Ocurrence -animal mongoengine/tests/fields/fields.py /^ animal = GenericLazyReferenceField(choices=['Animal'])$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Ocurrence -animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Ocurrence -animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Ocurrence -animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Ocurrence -animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Ocurrence -animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Ocurrence -animal mongoengine/tests/fields/fields.py /^ animal = LazyReferenceField(Animal, passthrough=False)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Ocurrence -animal tests/fields/fields.py /^ animal=Animal(name="Leopard", tag="heavy").save()).save()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence -animal tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence -animal tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -animal tests/fields/fields.py /^ animal = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Ocorrence -animal tests/fields/fields.py /^ animal = CachedReferenceField(Animal)$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence -animal tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Ocurrence -animal tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Ocurrence -animal tests/fields/fields.py /^ animal = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Ocurrence -animal tests/fields/fields.py /^ animal = GenericLazyReferenceField(choices=['Animal'])$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Ocurrence -animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Ocurrence -animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Ocurrence -animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Ocurrence -animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Ocurrence -animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Ocurrence -animal tests/fields/fields.py /^ animal = LazyReferenceField(Animal, passthrough=False)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Ocurrence -animal__owner__tags mongoengine/tests/fields/fields.py /^ animal__owner__tags='cool').first()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -animal__owner__tags tests/fields/fields.py /^ animal__owner__tags='cool').first()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -animal__owner__tp mongoengine/tests/fields/fields.py /^ animal__owner__tp='u').first()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence -animal__owner__tp tests/fields/fields.py /^ animal__owner__tp='u').first()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence -animal__tag mongoengine/tests/fields/fields.py /^ animal__tag='heavy',$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence -animal__tag mongoengine/tests/fields/fields.py /^ animal__tag='heavy',$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -animal__tag tests/fields/fields.py /^ animal__tag='heavy',$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence -animal__tag tests/fields/fields.py /^ animal__tag='heavy',$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -animal_passthrough mongoengine/tests/fields/fields.py /^ animal_passthrough = LazyReferenceField(Animal, passthrough=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Ocurrence -animal_passthrough tests/fields/fields.py /^ animal_passthrough = LazyReferenceField(Animal, passthrough=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Ocurrence -animals mongoengine/tests/document/instance.py /^ animals = ListField(GenericReferenceField())$/;" v class:InstanceTest.test_polymorphic_references.Zoo -animals mongoengine/tests/document/instance.py /^ animals = ListField(ReferenceField(Animal))$/;" v class:InstanceTest.test_polymorphic_references.Zoo -anon mongoengine/tests/queryset/field_list.py /^ anon = BooleanField()$/;" v class:OnlyExcludeAllTest.test_exclude_from_subclasses_docs.Anon -api_key mongoengine/tests/fields/fields.py /^ api_key = UUIDField(binary=False)$/;" v class:FieldTest.test_uuid_field_string.Person -api_key mongoengine/tests/fields/fields.py /^ api_key = UUIDField(binary=True)$/;" v class:FieldTest.test_uuid_field_binary.Person -api_key tests/fields/fields.py /^ api_key = UUIDField(binary=False)$/;" v class:FieldTest.test_uuid_field_string.Person -api_key tests/fields/fields.py /^ api_key = UUIDField(binary=True)$/;" v class:FieldTest.test_uuid_field_binary.Person -append mongoengine/mongoengine/base/datastructures.py /^ def append(self, *args, **kwargs):$/;" m class:BaseList -append_to_warning_list mongoengine/tests/all_warnings/__init__.py /^ def append_to_warning_list(self, message, category, *args):$/;" m class:AllWarnings -archived mongoengine/tests/document/instance.py /^ archived = BooleanField(default=False, required=True)$/;" v class:InstanceTest.test_can_save_false_values.Doc -as_dict mongoengine/mongoengine/queryset/field_list.py /^ def as_dict(self):$/;" m class:QueryFieldList -as_pymongo mongoengine/mongoengine/queryset/base.py /^ def as_pymongo(self):$/;" m class:BaseQuerySet -assertDbEqual mongoengine/tests/document/instance.py /^ def assertDbEqual(self, docs):$/;" m class:InstanceTest -assertDbEqual mongoengine/tests/queryset/modify.py /^ def assertDbEqual(self, docs):$/;" m class:FindAndModifyTest -assertHasInstance mongoengine/tests/document/instance.py /^ def assertHasInstance(self, field, instance):$/;" m class:InstanceTest -assertSequence mongoengine/tests/queryset/queryset.py /^ def assertSequence(self, qs, expected):$/;" m class:QuerySetTest -attachments mongoengine/tests/queryset/field_list.py /^ attachments = ListField(EmbeddedDocumentField(Attachment))$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email -author mongoengine/docs/code/tumblelog.py /^ author = ReferenceField(User)$/;" v class:Post -author mongoengine/tests/document/class_methods.py /^ author = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes.BlogPost -author mongoengine/tests/document/class_methods.py /^ author = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPost -author mongoengine/tests/document/class_methods.py /^ author = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPost -author mongoengine/tests/document/class_methods.py /^ author = StringField()$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPost -author mongoengine/tests/document/instance.py /^ author = ReferenceField(User)$/;" v class:InstanceTest.test_db_alias_tests.AuthorBooks -author mongoengine/tests/document/instance.py /^ author = ReferenceField(User)$/;" v class:InstanceTest.test_db_ref_usage.Book -author mongoengine/tests/document/instance.py /^ author = ReferenceField(User, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_with_custom_id_field.Book -author mongoengine/tests/document/instance.py /^ author = ReferenceField(User, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_with_shared_id_among_collections.Book -author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person)$/;" v class:InstanceTest.test_save_reference.BlogPost -author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify.BlogPost -author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_recurs.BlogPost -author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal.BlogPost -author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_with_document_inheritance.BlogPost -author mongoengine/tests/document/instance.py /^ author = ReferenceField(self.Person, reverse_delete_rule=DENY)$/;" v class:InstanceTest.test_reverse_delete_rule_deny.BlogPost -author mongoengine/tests/fields/fields.py /^ author = EmbeddedDocumentField(Author, required=True)$/;" v class:FieldTest.test_recursive_validation.Comment -author mongoengine/tests/fields/fields.py /^ author = EmbeddedDocumentField(User)$/;" v class:FieldTest.test_embedded_document_inheritance.BlogPost -author mongoengine/tests/fields/fields.py /^ author = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.BlogPost -author mongoengine/tests/fields/fields.py /^ author = LazyReferenceField(Member, dbref=False)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.BlogPost -author mongoengine/tests/fields/fields.py /^ author = LazyReferenceField(Member, dbref=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.BlogPost -author mongoengine/tests/fields/fields.py /^ author = ReferenceField(Member, dbref=False)$/;" v class:FieldTest.test_reference_query_conversion.BlogPost -author mongoengine/tests/fields/fields.py /^ author = ReferenceField(Member, dbref=True)$/;" v class:FieldTest.test_reference_query_conversion_dbref.BlogPost -author mongoengine/tests/fields/fields.py /^ author = ReferenceField(User)$/;" v class:FieldTest.test_reference_validation.BlogPost -author mongoengine/tests/fields/fields.py /^ author = StringField()$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.Comments -author mongoengine/tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents.UserComments -author mongoengine/tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments -author mongoengine/tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.ModeratorComments -author mongoengine/tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.UserComments -author mongoengine/tests/queryset/field_list.py /^ author = EmbeddedDocumentField(User)$/;" v class:OnlyExcludeAllTest.test_exclude.BlogPost -author mongoengine/tests/queryset/field_list.py /^ author = EmbeddedDocumentField(User)$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.BlogPost -author mongoengine/tests/queryset/queryset.py /^ author = EmbeddedDocumentField(User)$/;" v class:QuerySetTest.test_find_embedded.BlogPost -author mongoengine/tests/queryset/queryset.py /^ author = EmbeddedDocumentField(User)$/;" v class:QuerySetTest.test_find_empty_embedded.BlogPost -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person)$/;" v class:QuerySetTest.test_cannot_perform_joins_references.BlogPost -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person)$/;" v class:QuerySetTest.test_confirm_order_by_reference_wont_work.Author -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person)$/;" v class:QuerySetTest.test_query_value_conversion.BlogPost -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person)$/;" v class:QuerySetTest.test_reference_field_find.BlogPost -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, dbref=True)$/;" v class:QuerySetTest.test_reference_field_find_dbref.BlogPost -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_delete_with_limit_handles_delete_rules.BlogPost -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade.BlogPost -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_on_abstract_document.AbstractBlogPost -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=DENY)$/;" v class:QuerySetTest.test_reverse_delete_rule_deny.BlogPost -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=DENY)$/;" v class:QuerySetTest.test_reverse_delete_rule_deny_on_abstract_document.AbstractBlogPost -author mongoengine/tests/queryset/queryset.py /^ author = ReferenceField(self.Person, reverse_delete_rule=NULLIFY)$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify_on_abstract_document.AbstractBlogPost -author mongoengine/tests/queryset/queryset.py /^ author=user,$/;" v class:QuerySetTest.test_find_embedded.BlogPost -author mongoengine/tests/test_dereference.py /^ author = ReferenceField(User)$/;" v class:FieldTest.test_document_reload_reference_integrity.Message -author mongoengine/tests/test_dereference.py /^ author = ReferenceField(User)$/;" v class:FieldTest.test_objectid_reference_across_databases.Book -author mongoengine/tests/test_dereference.py /^ author = ReferenceField(User, dbref=False)$/;" v class:FieldTest.test_migrate_references.Group -author mongoengine/tests/test_dereference.py /^ author = ReferenceField(User, dbref=True)$/;" v class:FieldTest.test_migrate_references.Group -author tests/fields/fields.py /^ author = EmbeddedDocumentField(Author, required=True)$/;" v class:FieldTest.test_recursive_validation.Comment -author tests/fields/fields.py /^ author = EmbeddedDocumentField(User)$/;" v class:FieldTest.test_embedded_document_inheritance.BlogPost -author tests/fields/fields.py /^ author = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.BlogPost -author tests/fields/fields.py /^ author = LazyReferenceField(Member, dbref=False)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.BlogPost -author tests/fields/fields.py /^ author = LazyReferenceField(Member, dbref=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.BlogPost -author tests/fields/fields.py /^ author = ReferenceField(Member, dbref=False)$/;" v class:FieldTest.test_reference_query_conversion.BlogPost -author tests/fields/fields.py /^ author = ReferenceField(Member, dbref=True)$/;" v class:FieldTest.test_reference_query_conversion_dbref.BlogPost -author tests/fields/fields.py /^ author = ReferenceField(User)$/;" v class:FieldTest.test_reference_validation.BlogPost -author tests/fields/fields.py /^ author = StringField()$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.Comments -author tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents.UserComments -author tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments -author tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.ModeratorComments -author tests/fields/fields.py /^ author = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.UserComments -author2 mongoengine/tests/queryset/queryset.py /^ author2 = GenericReferenceField()$/;" v class:QuerySetTest.test_cannot_perform_joins_references.BlogPost -authors mongoengine/tests/document/instance.py /^ authors = MapField(ReferenceField($/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Blog -authors mongoengine/tests/document/instance.py /^ authors = ListField(ReferenceField($/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify_complex_field.BlogPost -authors mongoengine/tests/fields/fields.py /^ authors = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_validation.BlogPost -authors mongoengine/tests/queryset/queryset.py /^ authors=[author])$/;" v class:QuerySetTest.test_in_operator_on_non_iterable.BlogPost -authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(EmbeddedDocumentField('Author'))$/;" v class:QuerySetTest.test_set_list_embedded_documents.Message -authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(EmbeddedDocumentField(Author))$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField.Book -authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(EmbeddedDocumentField(Author))$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Book -authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(ReferenceField(User))$/;" v class:QuerySetTest.test_in_operator_on_non_iterable.BlogPost -authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(ReferenceField(self.Person,$/;" v class:QuerySetTest.test_reverse_delete_rule_pull.BlogPost -authors mongoengine/tests/queryset/queryset.py /^ authors = ListField(ReferenceField(self.Person,$/;" v class:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents.AbstractBlogPost -authors tests/fields/fields.py /^ authors = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_validation.BlogPost -authors_as_lazy mongoengine/tests/fields/fields.py /^ authors_as_lazy = ListField(LazyReferenceField(User))$/;" v class:FieldTest.test_list_validation.BlogPost -authors_as_lazy tests/fields/fields.py /^ authors_as_lazy = ListField(LazyReferenceField(User))$/;" v class:FieldTest.test_list_validation.BlogPost -auto_creation_counter mongoengine/mongoengine/base/fields.py /^ auto_creation_counter = -1$/;" v class:BaseField -autoclass_content mongoengine/docs/conf.py /^autoclass_content = 'both'$/;" v -average mongoengine/mongoengine/queryset/base.py /^ def average(self, field):$/;" m class:BaseQuerySet -b mongoengine/tests/document/indexes.py /^ b = IntField()$/;" v class:IndexesTest.test_covered_index.Test -b mongoengine/tests/document/inheritance.py /^ b = StringField()$/;" v class:InheritanceTest.test_indexes_and_multiple_inheritance.B -b mongoengine/tests/document/instance.py /^ b = EmbeddedDocumentField(B, default=lambda: B())$/;" v class:InstanceTest.test_mutating_documents.A -b mongoengine/tests/document/instance.py /^ b = Foo.objects.with_id(a.id)$/;" v class:InstanceTest.test_save_max_recursion_not_hit_with_file_field.Foo -b mongoengine/tests/fields/fields.py /^ b = EmbeddedDocumentField(B, db_field='fb')$/;" v class:FieldTest.test_double_embedded_db_field.A -b mongoengine/tests/fields/fields.py /^ b = EmbeddedDocumentField(B, db_field='fb')$/;" v class:FieldTest.test_double_embedded_db_field_from_son.A -b mongoengine/tests/fields/fields.py /^ b=B($/;" v class:FieldTest.test_double_embedded_db_field.A -b mongoengine/tests/queryset/field_list.py /^ b = ListField()$/;" v class:OnlyExcludeAllTest.test_mix_slice_with_other_fields.MyDoc -b mongoengine/tests/queryset/field_list.py /^ b = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc -b mongoengine/tests/queryset/field_list.py /^ b = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc -b mongoengine/tests/queryset/queryset.py /^ b = ListField(EmbeddedDocumentField(B))$/;" v class:QuerySetTest.test_count_list_embedded.A -b mongoengine/tests/queryset/transform.py /^ b = StringField()$/;" v class:TransformTest.test_raw_query_and_Q_objects.Foo -b mongoengine/tests/test_dereference.py /^ b = UserB(name='User B %s' % i)$/;" v class:FieldTest.test_dict_field.Group -b mongoengine/tests/test_dereference.py /^ b = UserB(name='User B %s' % i)$/;" v class:FieldTest.test_generic_reference.Group -b mongoengine/tests/test_dereference.py /^ b = UserB(name='User B %s' % i)$/;" v class:FieldTest.test_generic_reference_map_field.Group -b mongoengine/tests/test_dereference.py /^ b = UserB(name='User B %s' % i)$/;" v class:FieldTest.test_list_field_complex.Group -b mongoengine/tests/test_dereference.py /^ b = UserB(name='User B %s' % i).save()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group -b tests/fields/fields.py /^ b = EmbeddedDocumentField(B, db_field='fb')$/;" v class:FieldTest.test_double_embedded_db_field.A -b tests/fields/fields.py /^ b = EmbeddedDocumentField(B, db_field='fb')$/;" v class:FieldTest.test_double_embedded_db_field_from_son.A -b tests/fields/fields.py /^ b=B($/;" v class:FieldTest.test_double_embedded_db_field.A -b_name mongoengine/tests/queryset/queryset.py /^ b_name = StringField()$/;" v class:QuerySetTest.test_query_generic_embedded_document.B -bar mongoengine/tests/document/instance.py /^ bar = ReferenceField('self')$/;" v class:InstanceTest.test_save_max_recursion_not_hit_with_file_field.Foo -bar mongoengine/tests/document/instance.py /^ bar = ReferenceField(Bar)$/;" v class:InstanceTest.test_two_way_reverse_delete_rule.Foo -bar mongoengine/tests/document/instance.py /^ bar = StringField()$/;" v class:InstanceTest.test_shard_key_in_embedded_document.Bar -bar mongoengine/tests/document/instance.py /^ bar = StringField(default=None)$/;" v class:InstanceTest.test_set_unset_one_operation.FooBar -bar mongoengine/tests/queryset/queryset.py /^ bar = GenericEmbeddedDocumentField(choices=[Bar,])$/;" v class:QuerySetTest.test_set_generic_embedded_documents.User -bar mongoengine/tests/queryset/queryset.py /^ bar = ReferenceField("Bar")$/;" v class:QuerySetTest.test_distinct_handles_references.Foo -bar mongoengine/tests/queryset/queryset.py /^ bar = ReferenceField("Bar")$/;" v class:QuerySetTest.test_distinct_handles_references_to_alias.Foo -bar mongoengine/tests/queryset/queryset.py /^ bar = ReferenceField('Bar')$/;" v class:QuerySetTest.test_distinct_ListField_ReferenceField.Foo -bar mongoengine/tests/queryset/queryset.py /^ bar = StringField(default='bar')$/;" v class:QuerySetTest.test_custom_manager_overriding_objects_works.Foo -bar mongoengine/tests/test_dereference.py /^ bar = ReferenceField('Bar')$/;" v class:FieldTest.test_document_reload_no_inheritance.Foo -bar_lst mongoengine/tests/queryset/queryset.py /^ bar_lst = ListField(ReferenceField('Bar'))$/;" v class:QuerySetTest.test_distinct_ListField_ReferenceField.Foo -bars mongoengine/tests/fields/fields.py /^ bars = ListField(ReferenceField("Bar"))$/;" v class:FieldTest.test_list_field_passed_in_value.Foo -bars tests/fields/fields.py /^ bars = ListField(ReferenceField("Bar"))$/;" v class:FieldTest.test_list_field_passed_in_value.Foo -batch_size mongoengine/mongoengine/queryset/base.py /^ def batch_size(self, size):$/;" m class:BaseQuerySet -baz mongoengine/tests/test_dereference.py /^ baz = ReferenceField('Baz')$/;" v class:FieldTest.test_document_reload_no_inheritance.Foo -blob mongoengine/tests/fields/fields.py /^ blob = BinaryField()$/;" v class:FieldTest.test_binary_fields.Attachment -blob mongoengine/tests/fields/fields.py /^ blob = BinaryField()$/;" v class:FieldTest.test_binary_validation.Attachment -blob mongoengine/tests/fields/fields.py /^ blob = BinaryField(max_bytes=4)$/;" v class:FieldTest.test_binary_validation.AttachmentSizeLimit -blob mongoengine/tests/fields/fields.py /^ blob = BinaryField(required=True)$/;" v class:FieldTest.test_binary_validation.AttachmentRequired -blob mongoengine/tests/fields/fields.py /^ blob=six.b('\\xe6\\x00\\xc4\\xff\\x07'))$/;" v class:FieldTest.test_binary_validation.AttachmentSizeLimit -blob tests/fields/fields.py /^ blob = BinaryField()$/;" v class:FieldTest.test_binary_fields.Attachment -blob tests/fields/fields.py /^ blob = BinaryField()$/;" v class:FieldTest.test_binary_validation.Attachment -blob tests/fields/fields.py /^ blob = BinaryField(max_bytes=4)$/;" v class:FieldTest.test_binary_validation.AttachmentSizeLimit -blob tests/fields/fields.py /^ blob = BinaryField(required=True)$/;" v class:FieldTest.test_binary_validation.AttachmentRequired -blob tests/fields/fields.py /^ blob=six.b('\\xe6\\x00\\xc4\\xff\\x07'))$/;" v class:FieldTest.test_binary_validation.AttachmentSizeLimit -blog mongoengine/tests/queryset/queryset.py /^ blog = Blog.objects.first()$/;" v class:QuerySetTest.test_bulk_insert.Blog -blog mongoengine/tests/queryset/queryset.py /^ blog = ReferenceField(Blog)$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -blog mongoengine/tests/queryset/queryset.py /^ blog=blog_1,$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -blog mongoengine/tests/queryset/queryset.py /^ blog=blog_2,$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -blog mongoengine/tests/queryset/queryset.py /^ blog=blog_3,$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -blogs mongoengine/tests/queryset/queryset.py /^ blogs = Blog.objects$/;" v class:QuerySetTest.test_bulk_insert.Blog -blogs mongoengine/tests/queryset/queryset.py /^ blogs = []$/;" v class:QuerySetTest.test_bulk_insert.Blog -body mongoengine/tests/queryset/field_list.py /^ body = StringField()$/;" v class:OnlyExcludeAllTest.test_all_fields.Email -body mongoengine/tests/queryset/field_list.py /^ body = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email -body mongoengine/tests/test_dereference.py /^ body = StringField()$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Post -book mongoengine/tests/document/instance.py /^ book = ReferenceField(Book)$/;" v class:InstanceTest.test_db_alias_tests.AuthorBooks -bookmark_object mongoengine/tests/fields/fields.py /^ bookmark_object = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference.Bookmark -bookmark_object mongoengine/tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=('Post', Link))$/;" v class:FieldTest.test_generic_reference_string_choices.Bookmark -bookmark_object mongoengine/tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=(Post, ))$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Bookmark -bookmark_object mongoengine/tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=(Post,))$/;" v class:FieldTest.test_generic_reference_choices.Bookmark -bookmark_object tests/fields/fields.py /^ bookmark_object = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference.Bookmark -bookmark_object tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=('Post', Link))$/;" v class:FieldTest.test_generic_reference_string_choices.Bookmark -bookmark_object tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=(Post, ))$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Bookmark -bookmark_object tests/fields/fields.py /^ bookmark_object = GenericReferenceField(choices=(Post,))$/;" v class:FieldTest.test_generic_reference_choices.Bookmark -bookmarks mongoengine/tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_document_not_registered.User -bookmarks mongoengine/tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_list.User -bookmarks mongoengine/tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_list_item_modification.User -bookmarks mongoengine/tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField(choices=(Post,)))$/;" v class:FieldTest.test_generic_reference_list_choices.User -bookmarks tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_document_not_registered.User -bookmarks tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_list.User -bookmarks tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_list_item_modification.User -bookmarks tests/fields/fields.py /^ bookmarks = ListField(GenericReferenceField(choices=(Post,)))$/;" v class:FieldTest.test_generic_reference_list_choices.User -bool_info mongoengine/tests/fields/fields.py /^ bool_info = ListField(BooleanField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost -bool_info tests/fields/fields.py /^ bool_info = ListField(BooleanField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost -boolean_field mongoengine/tests/document/instance.py /^ boolean_field = BooleanField(default=True)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -boolean_field mongoengine/tests/document/json_serialisation.py /^ boolean_field = BooleanField(default=True)$/;" v class:TestJson.test_json_complex.Doc -boolean_field mongoengine/tests/queryset/queryset.py /^ boolean_field = BooleanField(default=True)$/;" v class:QuerySetTest.test_json_complex.Doc -boolfield mongoengine/tests/queryset/queryset.py /^ boolfield = BooleanField(default=False)$/;" v class:QuerySetTest.test_chaining.B -boss mongoengine/tests/fields/fields.py /^ boss = ReferenceField('self')$/;" v class:FieldTest.test_recursive_reference.Employee -boss mongoengine/tests/test_dereference.py /^ boss = ReferenceField('self')$/;" v class:FieldTest.test_recursive_reference.Employee -boss tests/fields/fields.py /^ boss = ReferenceField('self')$/;" v class:FieldTest.test_recursive_reference.Employee -brands mongoengine/tests/test_dereference.py /^ brands = ListField(ReferenceField("Brand", dbref=True))$/;" v class:FieldTest.test_non_ascii_pk.BrandGroup -build_dict mongoengine/mongoengine/errors.py /^ def build_dict(source):$/;" f function:ValidationError.to_dict -build_lazyref mongoengine/fields.py /^ def build_lazyref(self, value):$/;" m class:GenericLazyReferenceField -build_lazyref mongoengine/fields.py /^ def build_lazyref(self, value):$/;" m class:LazyReferenceField -build_lazyref mongoengine/mongoengine/fields.py /^ def build_lazyref(self, value):$/;" m class:GenericLazyReferenceField -build_lazyref mongoengine/mongoengine/fields.py /^ def build_lazyref(self, value):$/;" m class:LazyReferenceField -bulk_create_author mongoengine/tests/test_signals.py /^ def bulk_create_author():$/;" f function:SignalTests.test_signal_kwargs -bulk_create_author_with_load mongoengine/tests/test_signals.py /^ def bulk_create_author_with_load():$/;" f function:SignalTests.test_model_signals -bulk_create_author_without_load mongoengine/tests/test_signals.py /^ def bulk_create_author_without_load():$/;" f function:SignalTests.test_model_signals -bulk_set_active_post mongoengine/tests/test_signals.py /^ def bulk_set_active_post():$/;" f function:SignalTests.test_signals_bulk_insert -by mongoengine/tests/queryset/queryset.py /^ by = StringField()$/;" v class:QuerySetTest.test_update_using_positional_operator.Comment -by mongoengine/tests/queryset/queryset.py /^ by = StringField()$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.Comment -c mongoengine/tests/document/indexes.py /^ c = StringField()$/;" v class:IndexesTest.test_index_no_cls.B -c mongoengine/tests/fields/fields.py /^ c=C(txt='hi')$/;" v class:FieldTest.test_double_embedded_db_field.A -c mongoengine/tests/fields/fields.py /^ c = EmbeddedDocumentField(C, db_field='fc')$/;" v class:FieldTest.test_double_embedded_db_field.B -c mongoengine/tests/fields/fields.py /^ c = EmbeddedDocumentField(C, db_field='fc')$/;" v class:FieldTest.test_double_embedded_db_field_from_son.B -c mongoengine/tests/queryset/field_list.py /^ c = ListField()$/;" v class:OnlyExcludeAllTest.test_mix_slice_with_other_fields.MyDoc -c mongoengine/tests/queryset/field_list.py /^ c = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc -c mongoengine/tests/queryset/field_list.py /^ c = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc -c mongoengine/tests/queryset/queryset.py /^ c = StringField()$/;" v class:QuerySetTest.test_count_list_embedded.B -c mongoengine/tests/queryset/transform.py /^ c = StringField()$/;" v class:TransformTest.test_raw_query_and_Q_objects.Foo -c mongoengine/tests/test_dereference.py /^ c = UserC(name='User C %s' % i)$/;" v class:FieldTest.test_dict_field.Group -c mongoengine/tests/test_dereference.py /^ c = UserC(name='User C %s' % i)$/;" v class:FieldTest.test_generic_reference.Group -c mongoengine/tests/test_dereference.py /^ c = UserC(name='User C %s' % i)$/;" v class:FieldTest.test_generic_reference_map_field.Group -c mongoengine/tests/test_dereference.py /^ c = UserC(name='User C %s' % i)$/;" v class:FieldTest.test_list_field_complex.Group -c mongoengine/tests/test_dereference.py /^ c = UserC(name='User C %s' % i).save()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group -c tests/fields/fields.py /^ c=C(txt='hi')$/;" v class:FieldTest.test_double_embedded_db_field.A -c tests/fields/fields.py /^ c = EmbeddedDocumentField(C, db_field='fc')$/;" v class:FieldTest.test_double_embedded_db_field.B -c tests/fields/fields.py /^ c = EmbeddedDocumentField(C, db_field='fc')$/;" v class:FieldTest.test_double_embedded_db_field_from_son.B -c_field mongoengine/tests/document/instance.py /^ c_field = StringField(default='cfield')$/;" v class:InstanceTest.test_mutating_documents.C -c_field mongoengine/tests/fields/fields.py /^ c_field = IntField(custom_data=custom_data)$/;" v class:EmbeddedDocumentListFieldTestCase.test_custom_data.CustomData -c_field tests/fields/fields.py /^ c_field = IntField(custom_data=custom_data)$/;" v class:EmbeddedDocumentListFieldTestCase.test_custom_data.CustomData -cache mongoengine/mongoengine/queryset/queryset.py /^ def cache(self):$/;" m class:QuerySetNoCache -cascade_save mongoengine/mongoengine/document.py /^ def cascade_save(self, **kwargs):$/;" m class:Document -cat mongoengine/tests/queryset/queryset.py /^ cat = ReferenceField(Category, reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_complex_cycle.Dummy -categories mongoengine/tests/document/indexes.py /^ categories = ListField()$/;" v class:IndexesTest.test_index_on_id.BlogPost -categories mongoengine/tests/fields/fields.py /^ categories = SortedListField(EmbeddedDocumentField(Category),$/;" v class:FieldTest.test_reverse_list_sorting.CategoryList -categories tests/fields/fields.py /^ categories = SortedListField(EmbeddedDocumentField(Category),$/;" v class:FieldTest.test_reverse_list_sorting.CategoryList -category mongoengine/tests/document/indexes.py /^ category = StringField()$/;" v class:IndexesTest._index_test.BlogPost -category mongoengine/tests/document/indexes.py /^ category = StringField()$/;" v class:IndexesTest._index_test_inheritance.BlogPost -category mongoengine/tests/document/indexes.py /^ category = StringField()$/;" v class:IndexesTest.test_dictionary_indexes.BlogPost -category mongoengine/tests/queryset/queryset.py /^ category = ReferenceField(Category, reverse_delete_rule=NULLIFY)$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify.BlogPost -cdt_f mongoengine/tests/queryset/queryset.py /^ cdt_f = ComplexDateTimeField()$/;" v class:QuerySetTest.test_update_validate.Doc -cdt_fld mongoengine/tests/document/instance.py /^ cdt_fld = ComplexDateTimeField(null=True)$/;" v class:InstanceTest.test_null_field.User -ceo mongoengine/tests/queryset/queryset.py /^ ceo = ReferenceField(User)$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Organization -check_fields_type mongoengine/tests/fields/fields.py /^ def check_fields_type(occ):$/;" f function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded -check_fields_type mongoengine/tests/fields/fields.py /^ def check_fields_type(occ):$/;" f function:LazyReferenceFieldTest.test_lazy_reference_embedded -check_fields_type tests/fields/fields.py /^ def check_fields_type(occ):$/;" f function:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded -check_fields_type tests/fields/fields.py /^ def check_fields_type(occ):$/;" f function:LazyReferenceFieldTest.test_lazy_reference_embedded -child mongoengine/tests/queryset/queryset.py /^ child = Category(name=child_name, parent=base)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category -child_child mongoengine/tests/queryset/queryset.py /^ child_child = Category(name=child_child_name, parent=child)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category -child_child_name mongoengine/tests/queryset/queryset.py /^ child_child_name = 'Child-Child-%i' % i$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category -child_name mongoengine/tests/queryset/queryset.py /^ child_name = 'Child-%i' % i$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category -children mongoengine/tests/document/instance.py /^ children = ListField(ReferenceField('self', reverse_delete_rule=PULL))$/;" v class:InstanceTest.test_reverse_delete_rule_pull.Record -children mongoengine/tests/fields/fields.py /^ children = ListField(EmbeddedDocumentField('TreeNode'))$/;" v class:FieldTest.test_recursive_embedding.Tree -children mongoengine/tests/fields/fields.py /^ children = ListField(EmbeddedDocumentField('self'))$/;" v class:FieldTest.test_recursive_embedding.TreeNode -children mongoengine/tests/test_dereference.py /^ children = ListField(GenericReferenceField())$/;" v class:FieldTest.test_multidirectional_lists.Asset -children tests/fields/fields.py /^ children = ListField(EmbeddedDocumentField('TreeNode'))$/;" v class:FieldTest.test_recursive_embedding.Tree -children tests/fields/fields.py /^ children = ListField(EmbeddedDocumentField('self'))$/;" v class:FieldTest.test_recursive_embedding.TreeNode -choices mongoengine/tests/fields/fields.py /^ choices=('Small', 'Baggy', 'wide'),$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt -choices mongoengine/tests/fields/fields.py /^ choices=('S', 'M', 'L', 'XL', 'XXL'))$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt -choices mongoengine/tests/fields/fields.py /^ choices=('S', 'M', 'L', 'XL', 'XXL'))$/;" v class:FieldTest.test_simple_choices_validation.Shirt -choices mongoengine/tests/fields/fields.py /^ choices=TPS)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -choices mongoengine/tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person -choices mongoengine/tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone -choices mongoengine/tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person -choices mongoengine/tests/queryset/queryset.py /^ choices=[Foo, ]))$/;" v class:QuerySetTest.test_pull_in_genericembedded_field.Bar -choices tests/fields/fields.py /^ choices=('Small', 'Baggy', 'wide'),$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt -choices tests/fields/fields.py /^ choices=('S', 'M', 'L', 'XL', 'XXL'))$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt -choices tests/fields/fields.py /^ choices=('S', 'M', 'L', 'XL', 'XXL'))$/;" v class:FieldTest.test_simple_choices_validation.Shirt -choices tests/fields/fields.py /^ choices=TPS)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -choices tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person -choices tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone -choices tests/fields/fields.py /^ choices=TYPES$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person -circular_reference_deltas mongoengine/tests/document/delta.py /^ def circular_reference_deltas(self, DocClass1, DocClass2):$/;" m class:DeltaTest -circular_reference_deltas_2 mongoengine/tests/document/delta.py /^ def circular_reference_deltas_2(self, DocClass1, DocClass2, dbref=True):$/;" m class:DeltaTest -city mongoengine/tests/document/dynamic.py /^ city = StringField()$/;" v class:DynamicTest.test_dynamic_and_embedded.Address -city mongoengine/tests/document/dynamic.py /^ city = StringField()$/;" v class:DynamicTest.test_dynamic_and_embedded_dict_access.Address -city mongoengine/tests/document/dynamic.py /^ city = StringField()$/;" v class:DynamicTest.test_dynamic_embedded_works_with_only.Address -city mongoengine/tests/fields/fields.py /^ city = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_is_none.Person -city mongoengine/tests/queryset/queryset.py /^ city = StringField()$/;" v class:QuerySetTest.test_item_frequencies_null_values.Person -city mongoengine/tests/queryset/queryset.py /^ city = StringField()$/;" v class:QuerySetTest.test_scalar_embedded.Locale -city tests/fields/fields.py /^ city = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_is_none.Person -city_id mongoengine/tests/document/inheritance.py /^ city_id = IntField(primary_key=True)$/;" v class:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class.City -clean mongoengine/mongoengine/base/document.py /^ def clean(self):$/;" m class:BaseDocument -clean mongoengine/tests/document/instance.py /^ def clean(self):$/;" m class:InstanceTest.test_document_clean.TestDocument -clean mongoengine/tests/document/instance.py /^ def clean(self):$/;" m class:InstanceTest.test_document_embedded_clean.TestEmbeddedDocument -clear mongoengine/mongoengine/base/datastructures.py /^ def clear(self, *args, **kwargs):$/;" m class:BaseDict -clone mongoengine/mongoengine/queryset/base.py /^ def clone(self):$/;" m class:BaseQuerySet -close mongoengine/fields.py /^ def close(self):$/;" m class:GridFSProxy -close mongoengine/mongoengine/fields.py /^ def close(self):$/;" m class:GridFSProxy -collaborators mongoengine/tests/queryset/queryset.py /^ collaborators = EmbeddedDocumentField(Collaborator)$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Site -collaborators mongoengine/tests/queryset/queryset.py /^ collaborators = ListField(EmbeddedDocumentField(Collaborator))$/;" v class:QuerySetTest.test_pull_nested.Site -collaborators mongoengine/tests/queryset/queryset.py /^ collaborators = MapField($/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Site -collection_name mongoengine/tests/fields/file_tests.py /^ collection_name="macumba")$/;" v class:FileTest.test_file_multidb.TestFile -color mongoengine/tests/fields/fields.py /^ color = StringField(max_length=1, choices=COLORS)$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt -color mongoengine/tests/queryset/queryset.py /^ color = StringField()$/;" v class:QuerySetTest.test_elem_match.Foo -color tests/fields/fields.py /^ color = StringField(max_length=1, choices=COLORS)$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt -comment mongoengine/mongoengine/queryset/base.py /^ def comment(self, text):$/;" m class:BaseQuerySet -comment mongoengine/tests/document/instance.py /^ comment = StringField()$/;" v class:InstanceTest.test_list_search_by_embedded.Comment -comment mongoengine/tests/document/instance.py /^ comment = StringField()$/;" v class:InstanceTest.test_mixin_inheritance.DoubleMixIn -comment mongoengine/tests/queryset/queryset.py /^ comment = ReferenceField(Comment)$/;" v class:QuerySetTest.test_unset_reference.Post -comment1 mongoengine/tests/queryset/queryset.py /^ comment1 = Comment(name='testa')$/;" v class:QuerySetTest.test_bulk_insert.Blog -comment2 mongoengine/tests/queryset/queryset.py /^ comment2 = Comment(name='testb')$/;" v class:QuerySetTest.test_bulk_insert.Blog -comment_id mongoengine/tests/document/indexes.py /^ comment_id = IntField(required=True)$/;" v class:IndexesTest.test_index_with_pk.Comment -comments mongoengine/docs/code/tumblelog.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:Post -comments mongoengine/tests/document/indexes.py /^ comments = EmbeddedDocumentField(Comment)$/;" v class:IndexesTest.test_index_with_pk.Comment.BlogPost -comments mongoengine/tests/document/instance.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:InstanceTest.test_list_search_by_embedded.Page -comments mongoengine/tests/document/instance.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:InstanceTest.test_save_list.BlogPost -comments mongoengine/tests/document/instance.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:InstanceTest.test_save_only_changed_fields_recursive.User -comments mongoengine/tests/fields/fields.py /^ comments=[Comment(content="NoSQL Rocks"),$/;" v class:FieldTest.test_embedded_sequence_field.Post -comments mongoengine/tests/fields/fields.py /^ comments = EmbeddedDocumentListField(Comments)$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.BlogPost -comments mongoengine/tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents.BlogPost -comments mongoengine/tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents_inheritance.BlogPost -comments mongoengine/tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents_invalid.BlogPost -comments mongoengine/tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_embedded_sequence_field.Post -comments mongoengine/tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_list_validation.BlogPost -comments mongoengine/tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_recursive_validation.Post -comments mongoengine/tests/fields/fields.py /^ comments = SortedListField(EmbeddedDocumentField(Comment),$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost -comments mongoengine/tests/queryset/field_list.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:OnlyExcludeAllTest.test_exclude.BlogPost -comments mongoengine/tests/queryset/field_list.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.BlogPost -comments mongoengine/tests/queryset/queryset.py /^ comments=[comm1, comm2]).save()$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Post -comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField("Comment"))$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Post -comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:QuerySetTest.test_bulk_insert.Post -comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:QuerySetTest.test_find_array_position.Post -comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:QuerySetTest.test_update_array_position.Post -comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:QuerySetTest.test_update_using_positional_operator.BlogPost -comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.BlogPost -comments mongoengine/tests/queryset/queryset.py /^ comments = ListField(EmbeddedDocumentField(Comment),$/;" v class:QuerySetTest.test_exec_js_field_sub.BlogPost -comments mongoengine/tests/queryset/transform.py /^ comments = ListField(EmbeddedDocumentField(Comment),$/;" v class:TransformTest.test_query_field_name.BlogPost -comments mongoengine/tests/test_dereference.py /^ comments = ListField(ReferenceField(Comment))$/;" v class:FieldTest.test_list_lookup_not_checked_in_map.Message -comments tests/fields/fields.py /^ comments=[Comment(content="NoSQL Rocks"),$/;" v class:FieldTest.test_embedded_sequence_field.Post -comments tests/fields/fields.py /^ comments = EmbeddedDocumentListField(Comments)$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.BlogPost -comments tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents.BlogPost -comments tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents_inheritance.BlogPost -comments tests/fields/fields.py /^ comments = ListField($/;" v class:FieldTest.test_choices_validation_documents_invalid.BlogPost -comments tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_embedded_sequence_field.Post -comments tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_list_validation.BlogPost -comments tests/fields/fields.py /^ comments = ListField(EmbeddedDocumentField(Comment))$/;" v class:FieldTest.test_recursive_validation.Post -comments tests/fields/fields.py /^ comments = SortedListField(EmbeddedDocumentField(Comment),$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost -comments_dict mongoengine/tests/document/instance.py /^ comments_dict = DictField()$/;" v class:InstanceTest.test_save_only_changed_fields_recursive.User -comp_dt_fld mongoengine/tests/fields/fields.py /^ comp_dt_fld = ComplexDateTimeField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -comp_dt_fld mongoengine/tests/fields/fields.py /^ comp_dt_fld = ComplexDateTimeField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields -comp_dt_fld tests/fields/fields.py /^ comp_dt_fld = ComplexDateTimeField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -comp_dt_fld tests/fields/fields.py /^ comp_dt_fld = ComplexDateTimeField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields -company mongoengine/tests/fields/fields.py /^ company = ReferenceField('Company')$/;" v class:FieldTest.test_undefined_reference.Product -company tests/fields/fields.py /^ company = ReferenceField('Company')$/;" v class:FieldTest.test_undefined_reference.Product -compare_indexes mongoengine/mongoengine/document.py /^ def compare_indexes(cls):$/;" m class:Document -complex_datetime_field mongoengine/tests/document/instance.py /^ complex_datetime_field = ComplexDateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -complex_datetime_field mongoengine/tests/document/json_serialisation.py /^ complex_datetime_field = ComplexDateTimeField(default=datetime.now)$/;" v class:TestJson.test_json_complex.Doc -complex_datetime_field mongoengine/tests/queryset/queryset.py /^ complex_datetime_field = ComplexDateTimeField(default=datetime.datetime.now)$/;" v class:QuerySetTest.test_json_complex.Doc -connect mongoengine/mongoengine/connection.py /^def connect(db=None, alias=DEFAULT_CONNECTION_NAME, **kwargs):$/;" f -content mongoengine/docs/code/tumblelog.py /^ content = StringField()$/;" v class:Comment -content mongoengine/docs/code/tumblelog.py /^ content = StringField()$/;" v class:TextPost -content mongoengine/tests/document/dynamic.py /^ content = URLField()$/;" v class:DynamicTest.test_complex_embedded_document_validation.Embedded -content mongoengine/tests/document/inheritance.py /^ content = StringField()$/;" v class:InheritanceTest.test_allow_inheritance_embedded_document.Comment -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Blog -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_embedded_document.Comment -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify.BlogPost -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify_complex_field.BlogPost -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_recurs.BlogPost -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal.BlogPost -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_deny.BlogPost -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_with_document_inheritance.BlogPost -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_save_list.BlogPost -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_save_list.Comment -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_save_reference.BlogPost -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_two_way_reverse_delete_rule.Bar -content mongoengine/tests/document/instance.py /^ content = StringField()$/;" v class:InstanceTest.test_two_way_reverse_delete_rule.Foo -content mongoengine/tests/document/validation.py /^ content = StringField(required=True)$/;" v class:ValidatorErrorTest.test_embedded_document_validation.Comment -content mongoengine/tests/fields/fields.py /^ content = ListField(StringField())$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Group -content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance.BlogPost -content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_embedded_document_validation.Comment -content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_list_validation.BlogPost -content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_list_validation.Comment -content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_reference_validation.BlogPost -content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost -content mongoengine/tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_sorted_list_sorting.Comment -content mongoengine/tests/fields/fields.py /^ content = StringField(required=True)$/;" v class:FieldTest.test_embedded_sequence_field.Comment -content mongoengine/tests/fields/fields.py /^ content = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Comment -content mongoengine/tests/queryset/field_list.py /^ content = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude.BlogPost -content mongoengine/tests/queryset/field_list.py /^ content = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Attachment -content mongoengine/tests/queryset/field_list.py /^ content = StringField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content="Com o brasil nas quartas de finais teremos um "$/;" v class:QuerySetTest.test_text_indexes.News -content mongoengine/tests/queryset/queryset.py /^ content="O Brasil sofre com a perda de Neymar").save()$/;" v class:QuerySetTest.test_text_indexes.News -content mongoengine/tests/queryset/queryset.py /^ content=u"A candidata dilma roussef já começa o teu planejamento",$/;" v class:QuerySetTest.test_text_indexes.News -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_delete_with_limit_handles_delete_rules.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_find_embedded.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_find_empty_embedded.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_in_operator_on_non_iterable.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reference_field_find.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reference_field_find_dbref.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_on_abstract_document.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_deny.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_deny_on_abstract_document.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify_on_abstract_document.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_pull.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents.BlogPost -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_text_indexes.News -content mongoengine/tests/queryset/queryset.py /^ content = StringField()$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Comment -content mongoengine/tests/queryset/queryset.py /^ content = StringField(db_field='body')$/;" v class:QuerySetTest.test_exec_js_field_sub.Comment -content mongoengine/tests/queryset/queryset.py /^ content='Had a good coffee today...'$/;" v class:QuerySetTest.test_find_embedded.BlogPost -content mongoengine/tests/queryset/transform.py /^ content = StringField(db_field='commentContent')$/;" v class:TransformTest.test_query_field_name.Comment -content mongoengine/tests/test_signals.py /^ content = StringField()$/;" v class:SignalTests.setUp.Post -content tests/fields/fields.py /^ content = ListField(StringField())$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Group -content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance.BlogPost -content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_embedded_document_validation.Comment -content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_list_validation.BlogPost -content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_list_validation.Comment -content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_reference_validation.BlogPost -content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost -content tests/fields/fields.py /^ content = StringField()$/;" v class:FieldTest.test_sorted_list_sorting.Comment -content tests/fields/fields.py /^ content = StringField(required=True)$/;" v class:FieldTest.test_embedded_sequence_field.Comment -content tests/fields/fields.py /^ content = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Comment -content_type mongoengine/tests/fields/fields.py /^ content_type = StringField()$/;" v class:FieldTest.test_binary_fields.Attachment -content_type mongoengine/tests/queryset/field_list.py /^ content_type = StringField()$/;" v class:OnlyExcludeAllTest.test_all_fields.Email -content_type mongoengine/tests/queryset/field_list.py /^ content_type = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email -content_type tests/fields/fields.py /^ content_type = StringField()$/;" v class:FieldTest.test_binary_fields.Attachment -continent mongoengine/tests/document/inheritance.py /^ continent = StringField()$/;" v class:InheritanceTest.test_abstract_document_creation_does_not_fail.City -continent mongoengine/tests/document/inheritance.py /^ continent = StringField()$/;" v class:InheritanceTest.test_abstract_handle_ids_in_metaclass_properly.City -continent mongoengine/tests/document/inheritance.py /^ continent = StringField()$/;" v class:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class.City -continent mongoengine/tests/document/inheritance.py /^ continent = StringField()$/;" v class:InheritanceTest.test_auto_id_vs_non_pk_id_field.City -continent mongoengine/tests/queryset/queryset.py /^ continent = EmbeddedDocumentField(Continent)$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Country -continent_name mongoengine/tests/queryset/queryset.py /^ continent_name = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Continent -copyright mongoengine/docs/conf.py /^copyright = u'2009, MongoEngine Authors'$/;" v -count mongoengine/mongoengine/base/datastructures.py /^ def count(self):$/;" m class:EmbeddedDocumentList -count mongoengine/mongoengine/queryset/base.py /^ def count(self, with_limit_and_skip=False):$/;" m class:BaseQuerySet -count mongoengine/mongoengine/queryset/queryset.py /^ def count(self, with_limit_and_skip=False):$/;" m class:QuerySet -count mongoengine/tests/document/instance.py /^ count = IntField()$/;" v class:InstanceTest.test_mixin_inheritance.BaseMixIn -count mongoengine/tests/document/instance.py /^ count = IntField()$/;" v class:InstanceTest.test_save_to_a_value_that_equates_to_false.Thing -count mongoengine/tests/document/instance.py /^ count = IntField(default=0)$/;" v class:InstanceTest.test_save_atomicity_condition.Widget -count mongoengine/tests/document/instance.py /^ count = IntField(default=1)$/;" v class:InstanceTest.test_invalid_son.Word -count mongoengine/tests/fields/fields.py /^ count = IntField()$/;" v class:FieldTest.test_reverse_list_sorting.Category -count tests/fields/fields.py /^ count = IntField()$/;" v class:FieldTest.test_reverse_list_sorting.Category -counter mongoengine/tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_inherited_sequencefield.Base -counter mongoengine/tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_multiple_sequence_fields.Person -counter mongoengine/tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Bar -counter mongoengine/tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Foo -counter mongoengine/tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_sequence_fields_reload.Animal -counter tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_inherited_sequencefield.Base -counter tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_multiple_sequence_fields.Person -counter tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Bar -counter tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Foo -counter tests/fields/fields.py /^ counter = SequenceField()$/;" v class:FieldTest.test_sequence_fields_reload.Animal -country mongoengine/tests/queryset/queryset.py /^ country = EmbeddedDocumentField(Country)$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Author -country mongoengine/tests/queryset/queryset.py /^ country = StringField()$/;" v class:QuerySetTest.test_scalar_embedded.Locale -country_name mongoengine/tests/queryset/queryset.py /^ country_name = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Country -create mongoengine/mongoengine/base/datastructures.py /^ def create(cls, allowed_keys):$/;" m class:StrictDict -create mongoengine/mongoengine/base/datastructures.py /^ def create(self, **values):$/;" m class:EmbeddedDocumentList -create mongoengine/mongoengine/queryset/base.py /^ def create(self, **kwargs):$/;" m class:BaseQuerySet -create_author mongoengine/tests/test_signals.py /^ def create_author():$/;" f function:SignalTests.test_model_signals -create_index mongoengine/mongoengine/document.py /^ def create_index(cls, keys, background=False, **kwargs):$/;" m class:Document -created mongoengine/tests/document/indexes.py /^ created = DateTimeField(default=datetime.now)$/;" v class:IndexesTest.test_ttl_indexes.Log -created mongoengine/tests/document/instance.py /^ created = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_reference_inheritance.Stats -created mongoengine/tests/fields/fields.py /^ created=datetime.datetime(2014, 6, 12))$/;" v class:FieldTest.test_default_values_when_deleting_value.Person -created mongoengine/tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_nothing_set.Person -created mongoengine/tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_set_to_None.Person -created mongoengine/tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person -created mongoengine/tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person -created tests/fields/fields.py /^ created=datetime.datetime(2014, 6, 12))$/;" v class:FieldTest.test_default_values_when_deleting_value.Person -created tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_nothing_set.Person -created tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_set_to_None.Person -created tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person -created tests/fields/fields.py /^ created = DateTimeField(default=datetime.datetime.utcnow)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person -created_on mongoengine/tests/document/instance.py /^ created_on = DateTimeField(default=lambda: datetime.utcnow())$/;" v class:InstanceTest.test_default_values.Person -created_user mongoengine/tests/queryset/visitor.py /^ created_user = ReferenceField(User)$/;" v class:QTest.test_q_with_dbref.Post -creation_counter mongoengine/mongoengine/base/fields.py /^ creation_counter = 0$/;" v class:BaseField -current mongoengine/tests/document/indexes.py /^ current = DictField(field=EmbeddedDocumentField('EmbeddedLocation'))$/;" v class:IndexesTest.test_explicit_geo2d_index_embedded.Place -cursor_args_fields mongoengine/tests/queryset/queryset.py /^ cursor_args_fields = cursor_args['fields']$/;" v class:QuerySetTest.test_text_indexes.News -cursor_args_fields mongoengine/tests/queryset/queryset.py /^ cursor_args_fields = cursor_args['projection']$/;" v class:QuerySetTest.test_text_indexes.News -cust_id mongoengine/tests/document/indexes.py /^ cust_id = IntField(unique=True, required=True)$/;" v class:IndexesTest.test_unique_and_indexes.Customer -custom mongoengine/tests/document/class_methods.py /^ custom = DictField()$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPostWithCustomField -d mongoengine/tests/document/indexes.py /^ d = StringField()$/;" v class:IndexesTest.test_index_no_cls.B -d mongoengine/tests/fields/fields.py /^ d = datetime.datetime(i, 1, 1, 0, 0, 1)$/;" v class:FieldTest.test_datetime_usage.LogEntry -d mongoengine/tests/fields/fields.py /^ d = datetime.datetime(i, 1, 1, 0, 0, 1, 999)$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -d mongoengine/tests/queryset/field_list.py /^ d = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc -d mongoengine/tests/queryset/field_list.py /^ d = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc -d tests/fields/fields.py /^ d = datetime.datetime(i, 1, 1, 0, 0, 1)$/;" v class:FieldTest.test_datetime_usage.LogEntry -d tests/fields/fields.py /^ d = datetime.datetime(i, 1, 1, 0, 0, 1, 999)$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -d1 mongoengine/tests/fields/fields.py /^ d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999)$/;" v class:FieldTest.test_datetime.LogEntry -d1 mongoengine/tests/fields/fields.py /^ d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, i)$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry -d1 tests/fields/fields.py /^ d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, 999)$/;" v class:FieldTest.test_datetime.LogEntry -d1 tests/fields/fields.py /^ d1 = datetime.datetime(1969, 12, 31, 23, 59, 59, i)$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry -d2 mongoengine/tests/fields/fields.py /^ d2 = datetime.datetime(1969, 12, 31, 23, 59, 59)$/;" v class:FieldTest.test_datetime.LogEntry -d2 tests/fields/fields.py /^ d2 = datetime.datetime(1969, 12, 31, 23, 59, 59)$/;" v class:FieldTest.test_datetime.LogEntry -data mongoengine/tests/document/instance.py /^ data = StringField()$/;" v class:InstanceTest.test_mixin_inheritance.BaseMixIn -data mongoengine/tests/fields/fields.py /^ data = DictField()$/;" v class:FieldTest.test_ensure_unique_default_instances.D -data mongoengine/tests/queryset/queryset.py /^ data = EmbeddedDocumentField(Data, required=True)$/;" v class:QuerySetTest.test_item_frequencies_with_null_embedded.Person -data tests/fields/fields.py /^ data = DictField()$/;" v class:FieldTest.test_ensure_unique_default_instances.D -data2 mongoengine/tests/fields/fields.py /^ data2 = DictField(default=lambda: {})$/;" v class:FieldTest.test_ensure_unique_default_instances.D -data2 tests/fields/fields.py /^ data2 = DictField(default=lambda: {})$/;" v class:FieldTest.test_ensure_unique_default_instances.D -date mongoengine/tests/document/indexes.py /^ date = DateTimeField(db_field='addDate', default=datetime.now)$/;" v class:IndexesTest._index_test.BlogPost -date mongoengine/tests/document/indexes.py /^ date = DateTimeField(db_field='addDate', default=datetime.now)$/;" v class:IndexesTest._index_test_inheritance.BlogPost -date mongoengine/tests/document/indexes.py /^ date = DateTimeField(db_field='addDate', default=datetime.now)$/;" v class:IndexesTest.test_dictionary_indexes.BlogPost -date mongoengine/tests/document/indexes.py /^ date = EmbeddedDocumentField(Date)$/;" v class:IndexesTest.test_embedded_document_index.BlogPost -date mongoengine/tests/document/indexes.py /^ date = EmbeddedDocumentField(Date)$/;" v class:IndexesTest.test_unique_with.BlogPost -date mongoengine/tests/document/instance.py /^ date = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_capped_collection.Log -date mongoengine/tests/document/instance.py /^ date = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_capped_collection_default.Log -date mongoengine/tests/document/instance.py /^ date = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_capped_collection_no_max_size_problems.Log -date mongoengine/tests/document/validation.py /^ date = DateTimeField()$/;" v class:ValidatorErrorTest.test_embedded_document_validation.Comment -date mongoengine/tests/fields/fields.py /^ date=datetime.datetime(2015, 1, 1, 0, 0, 0, microsecond)$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -date mongoengine/tests/fields/fields.py /^ date = ComplexDateTimeField()$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry -date mongoengine/tests/fields/fields.py /^ date = ComplexDateTimeField()$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -date mongoengine/tests/fields/fields.py /^ date = DateTimeField()$/;" v class:FieldTest.test_datetime.LogEntry -date mongoengine/tests/fields/fields.py /^ date = DateTimeField()$/;" v class:FieldTest.test_datetime_usage.LogEntry -date mongoengine/tests/fixtures.py /^ date = DateTimeField(default=datetime.now)$/;" v class:PickleDynamicEmbedded -date mongoengine/tests/fixtures.py /^ date = DateTimeField(default=datetime.now)$/;" v class:PickleEmbedded -date mongoengine/tests/queryset/geo.py /^ date = DateTimeField()$/;" v class:GeoQueriesTest._create_event_data.Event -date mongoengine/tests/queryset/geo.py /^ date=datetime.datetime.now() - datetime.timedelta(days=1),$/;" v class:GeoQueriesTest._create_event_data.Event -date mongoengine/tests/queryset/geo.py /^ date=datetime.datetime.now() - datetime.timedelta(days=10),$/;" v class:GeoQueriesTest._create_event_data.Event -date mongoengine/tests/queryset/geo.py /^ date=datetime.datetime.now(),$/;" v class:GeoQueriesTest._create_event_data.Event -date mongoengine/tests/queryset/queryset.py /^ date = DateTimeField(default=datetime.datetime.now)$/;" v class:QuerySetTest.test_custom_manager.BlogPost -date tests/fields/fields.py /^ date=datetime.datetime(2015, 1, 1, 0, 0, 0, microsecond)$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -date tests/fields/fields.py /^ date = ComplexDateTimeField()$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry -date tests/fields/fields.py /^ date = ComplexDateTimeField()$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -date tests/fields/fields.py /^ date = DateTimeField()$/;" v class:FieldTest.test_datetime.LogEntry -date tests/fields/fields.py /^ date = DateTimeField()$/;" v class:FieldTest.test_datetime_usage.LogEntry -date__gte mongoengine/tests/fields/fields.py /^ date__gte=datetime.datetime(1975, 1, 1),$/;" v class:FieldTest.test_datetime_usage.LogEntry -date__gte mongoengine/tests/fields/fields.py /^ date__gte=datetime.datetime(2000, 1, 1),$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -date__gte tests/fields/fields.py /^ date__gte=datetime.datetime(1975, 1, 1),$/;" v class:FieldTest.test_datetime_usage.LogEntry -date__gte tests/fields/fields.py /^ date__gte=datetime.datetime(2000, 1, 1),$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -date__lte mongoengine/tests/fields/fields.py /^ date__lte=datetime.datetime(1980, 1, 1),$/;" v class:FieldTest.test_datetime_usage.LogEntry -date__lte mongoengine/tests/fields/fields.py /^ date__lte=datetime.datetime(2011, 1, 1),$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -date__lte mongoengine/tests/fields/fields.py /^ date__lte=datetime.datetime(2015, 1, 1, 0, 0, 0, 10000))$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -date__lte tests/fields/fields.py /^ date__lte=datetime.datetime(1980, 1, 1),$/;" v class:FieldTest.test_datetime_usage.LogEntry -date__lte tests/fields/fields.py /^ date__lte=datetime.datetime(2011, 1, 1),$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -date__lte tests/fields/fields.py /^ date__lte=datetime.datetime(2015, 1, 1, 0, 0, 0, 10000))$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -date_with_dots mongoengine/tests/fields/fields.py /^ date_with_dots = ComplexDateTimeField(separator='.')$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry -date_with_dots tests/fields/fields.py /^ date_with_dots = ComplexDateTimeField(separator='.')$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry -datetime mongoengine/tests/fields/geo.py /^ datetime = DateTimeField()$/;" v class:GeoFieldTest.test_geo_indexes_auto_index.Log -datetime_field mongoengine/tests/document/instance.py /^ datetime_field = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -datetime_field mongoengine/tests/document/json_serialisation.py /^ datetime_field = DateTimeField(default=datetime.now)$/;" v class:TestJson.test_json_complex.Doc -datetime_field mongoengine/tests/queryset/queryset.py /^ datetime_field = DateTimeField(default=datetime.datetime.now)$/;" v class:QuerySetTest.test_json_complex.Doc -dateutil mongoengine/fields.py /^ dateutil = None$/;" v -dateutil mongoengine/mongoengine/fields.py /^ dateutil = None$/;" v -dateutil mongoengine/tests/fields/fields.py /^ dateutil = None$/;" v -dateutil tests/fields/fields.py /^ dateutil = None$/;" v -db_field mongoengine/tests/document/delta.py /^ db_field='db_embedded_field')$/;" v class:DeltaTest.delta_recursive_db_field.Doc -db_field mongoengine/tests/document/instance.py /^ db_field='rank')$/;" v class:InstanceTest.test_db_embedded_doc_field_load.Person -db_field mongoengine/tests/document/instance.py /^ db_field="page_log_message",$/;" v class:InstanceTest.test_embedded_update_db_field.Page -db_field mongoengine/tests/fields/fields.py /^ db_field='x')$/;" v class:FieldTest.test_embedded_mapfield_db_field.Test -db_field mongoengine/tests/fields/fields.py /^ db_field="t",$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -db_field mongoengine/tests/queryset/queryset.py /^ db_field='cmnts')$/;" v class:QuerySetTest.test_exec_js_field_sub.BlogPost -db_field mongoengine/tests/queryset/transform.py /^ db_field='postComments')$/;" v class:TransformTest.test_query_field_name.BlogPost -db_field tests/fields/fields.py /^ db_field='x')$/;" v class:FieldTest.test_embedded_mapfield_db_field.Test -db_field tests/fields/fields.py /^ db_field="t",$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -db_ops_tracker mongoengine/tests/queryset/queryset.py /^class db_ops_tracker(query_counter):$/;" c -decimal_field mongoengine/tests/document/instance.py /^ decimal_field = DecimalField(default=1.0)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -decimal_field mongoengine/tests/document/json_serialisation.py /^ decimal_field = DecimalField(default=1.0)$/;" v class:TestJson.test_json_complex.Doc -decimal_field mongoengine/tests/queryset/queryset.py /^ decimal_field = DecimalField(default=1.0)$/;" v class:QuerySetTest.test_json_complex.Doc -default mongoengine/mongoengine/queryset/manager.py /^ default = QuerySet$/;" v class:QuerySetManager -default mongoengine/tests/document/instance.py /^ default=lambda: [1, 2, 3])$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -default mongoengine/tests/document/instance.py /^ default=lambda: EmbeddedDoc())$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -default mongoengine/tests/document/instance.py /^ default=lambda: Simple().save())$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -default mongoengine/tests/document/json_serialisation.py /^ default=lambda: [1, 2, 3])$/;" v class:TestJson.test_json_complex.Doc -default mongoengine/tests/document/json_serialisation.py /^ default=lambda: Simple().save())$/;" v class:TestJson.test_json_complex.Doc -default mongoengine/tests/document/json_serialisation.py /^ default=lambda: EmbeddedDoc())$/;" v class:TestJson.test_json_complex.Doc -default mongoengine/tests/fields/fields.py /^ default='Small')$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt -default mongoengine/tests/queryset/queryset.py /^ default=lambda: [1, 2, 3])$/;" v class:QuerySetTest.test_json_complex.Doc -default mongoengine/tests/queryset/queryset.py /^ default=lambda: EmbeddedDoc())$/;" v class:QuerySetTest.test_json_complex.Doc -default mongoengine/tests/queryset/queryset.py /^ default=lambda: Simple().save())$/;" v class:QuerySetTest.test_json_complex.Doc -default tests/fields/fields.py /^ default='Small')$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt -delete mongoengine/fields.py /^ def delete(self):$/;" m class:GridFSProxy -delete mongoengine/fields.py /^ def delete(self, *args, **kwargs):$/;" m class:ImageGridFsProxy -delete mongoengine/mongoengine/base/datastructures.py /^ def delete(self):$/;" m class:EmbeddedDocumentList -delete mongoengine/mongoengine/document.py /^ def delete(self, signal_kwargs=None, **write_concern):$/;" m class:Document -delete mongoengine/mongoengine/fields.py /^ def delete(self):$/;" m class:GridFSProxy -delete mongoengine/mongoengine/fields.py /^ def delete(self, *args, **kwargs):$/;" m class:ImageGridFsProxy -delete mongoengine/mongoengine/queryset/base.py /^ def delete(self, write_concern=None, _from_doc_delete=False,$/;" m class:BaseQuerySet -deleted mongoengine/tests/queryset/queryset.py /^ deleted = BooleanField(default=False)$/;" v class:QuerySetTest.test_custom_manager.BlogPost -delta mongoengine/tests/document/delta.py /^ def delta(self, DocClass):$/;" m class:DeltaTest -delta_db_field mongoengine/tests/document/delta.py /^ def delta_db_field(self, DocClass):$/;" m class:DeltaTest -delta_recursive mongoengine/tests/document/delta.py /^ def delta_recursive(self, DocClass, EmbeddedClass):$/;" m class:DeltaTest -delta_recursive_db_field mongoengine/tests/document/delta.py /^ def delta_recursive_db_field(self, DocClass, EmbeddedClass):$/;" m class:DeltaTest -dereference mongoengine/fields.py /^ def dereference(self, value):$/;" m class:GenericReferenceField -dereference mongoengine/mongoengine/fields.py /^ def dereference(self, value):$/;" m class:GenericReferenceField -description mongoengine/tests/document/class_methods.py /^ description = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes.BlogPost -description mongoengine/tests/document/class_methods.py /^ description = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPost -description mongoengine/tests/document/class_methods.py /^ description = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPost -description mongoengine/tests/document/class_methods.py /^ description = StringField()$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPost -description mongoengine/tests/document/indexes.py /^ description = StringField()$/;" v class:IndexesTest.test_inherited_index.B -description mongoengine/tests/document/indexes.py /^ description = StringField(required=True)$/;" v class:IndexesTest.test_index_on_id.BlogPost -description mongoengine/tests/fields/fields.py /^ description = StringField()$/;" v class:FieldTest.test_map_field_unicode.Info -description mongoengine/tests/queryset/queryset.py /^ description = StringField(max_length=50)$/;" v class:QuerySetTest.test_add_to_set_each.Item -description tests/fields/fields.py /^ description = StringField()$/;" v class:FieldTest.test_map_field_unicode.Info -details mongoengine/tests/document/instance.py /^ details = EmbeddedDocumentField(EmployeeDetails)$/;" v class:InstanceTest.test_save_embedded_document.Employee -details mongoengine/tests/document/instance.py /^ details = EmbeddedDocumentField(EmployeeDetails)$/;" v class:InstanceTest.test_updating_an_embedded_document.Employee -df mongoengine/tests/queryset/transform.py /^ df = DynamicField()$/;" v class:TransformTest.test_type.Doc -dictField mongoengine/tests/queryset/transform.py /^ dictField = DictField()$/;" v class:TransformTest.test_transform_update.DicDoc -dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField()$/;" v class:DeltaTest.delta.Doc -dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField()$/;" v class:DeltaTest.delta_recursive.Doc -dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField()$/;" v class:DeltaTest.delta_recursive.Embedded -dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField(db_field='db_dict_field')$/;" v class:DeltaTest.delta_db_field.Doc -dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField(db_field='db_dict_field')$/;" v class:DeltaTest.delta_recursive_db_field.Doc -dict_field mongoengine/tests/document/delta.py /^ dict_field = DictField(db_field='db_dict_field')$/;" v class:DeltaTest.delta_recursive_db_field.Embedded -dict_field mongoengine/tests/document/instance.py /^ dict_field = DictField()$/;" v class:InstanceTest.test_reload_referencing.Doc -dict_field mongoengine/tests/document/instance.py /^ dict_field = DictField()$/;" v class:InstanceTest.test_reload_referencing.Embedded -dict_field mongoengine/tests/document/instance.py /^ dict_field = DictField(default=lambda: {"hello": "world"})$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -dict_field mongoengine/tests/document/json_serialisation.py /^ dict_field = DictField(default=lambda: {"hello": "world"})$/;" v class:TestJson.test_json_complex.Doc -dict_field mongoengine/tests/queryset/queryset.py /^ dict_field = DictField(default=lambda: {"hello": "world"})$/;" v class:QuerySetTest.test_json_complex.Doc -dictionary mongoengine/tests/fields/fields.py /^ dictionary = DictField(required=True)$/;" v class:FieldTest.test_invalid_dict_value.DictFieldTest -dictionary tests/fields/fields.py /^ dictionary = DictField(required=True)$/;" v class:FieldTest.test_invalid_dict_value.DictFieldTest -direct mongoengine/tests/fields/fields.py /^ direct = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.EmbeddedOcurrence -direct mongoengine/tests/fields/fields.py /^ direct = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence -direct mongoengine/tests/fields/fields.py /^ direct = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.EmbeddedOcurrence -direct mongoengine/tests/fields/fields.py /^ direct = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence -direct tests/fields/fields.py /^ direct = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.EmbeddedOcurrence -direct tests/fields/fields.py /^ direct = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence -direct tests/fields/fields.py /^ direct = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.EmbeddedOcurrence -direct tests/fields/fields.py /^ direct = LazyReferenceField(Animal)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence -disconnect mongoengine/mongoengine/connection.py /^def disconnect(alias=DEFAULT_CONNECTION_NAME):$/;" f -distinct mongoengine/mongoengine/queryset/base.py /^ def distinct(self, field):$/;" m class:BaseQuerySet -doc mongoengine/tests/document/instance.py /^ doc = EmbeddedDocumentField(Embedded)$/;" v class:InstanceTest.test_kwargs_simple.Doc -doc mongoengine/tests/document/instance.py /^ doc = EmbeddedDocumentField(TestEmbeddedDocument)$/;" v class:InstanceTest.test_document_embedded_clean.TestDocument -doc_a mongoengine/tests/fields/file_tests.py /^ doc_a = GridDocument()$/;" v class:FileTest.test_file_field_no_default.GridDocument -doc_b mongoengine/tests/fields/file_tests.py /^ doc_b = GridDocument.objects.with_id(doc_a.id)$/;" v class:FileTest.test_file_field_no_default.GridDocument -doc_c mongoengine/tests/fields/file_tests.py /^ doc_c = GridDocument.objects.with_id(doc_b.id)$/;" v class:FileTest.test_file_field_no_default.GridDocument -doc_d mongoengine/tests/fields/file_tests.py /^ doc_d = GridDocument(the_file=six.b(''))$/;" v class:FileTest.test_file_field_no_default.GridDocument -doc_e mongoengine/tests/fields/file_tests.py /^ doc_e = GridDocument.objects.with_id(doc_d.id)$/;" v class:FileTest.test_file_field_no_default.GridDocument -doc_f mongoengine/tests/fields/file_tests.py /^ doc_f = GridDocument.objects.with_id(doc_e.id)$/;" v class:FileTest.test_file_field_no_default.GridDocument -doc_name mongoengine/tests/document/instance.py /^ doc_name = StringField()$/;" v class:InstanceTest.test_kwargs_complex.Doc -doc_name mongoengine/tests/document/instance.py /^ doc_name = StringField()$/;" v class:InstanceTest.test_kwargs_simple.Doc -docs mongoengine/tests/document/instance.py /^ docs = ListField(EmbeddedDocumentField(Embedded))$/;" v class:InstanceTest.test_kwargs_complex.Doc -doctype mongoengine/tests/fields/fields.py /^ doctype = StringField(require=True, default='userdata')$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.User -doctype tests/fields/fields.py /^ doctype = StringField(require=True, default='userdata')$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.User -document mongoengine/tests/queryset/queryset.py /^ document = GenericEmbeddedDocumentField(choices=(A, B))$/;" v class:QuerySetTest.test_query_generic_embedded_document.Doc -document_type mongoengine/fields.py /^ def document_type(self):$/;" m class:CachedReferenceField -document_type mongoengine/fields.py /^ def document_type(self):$/;" m class:EmbeddedDocumentField -document_type mongoengine/fields.py /^ def document_type(self):$/;" m class:LazyReferenceField -document_type mongoengine/fields.py /^ def document_type(self):$/;" m class:ReferenceField -document_type mongoengine/mongoengine/fields.py /^ def document_type(self):$/;" m class:CachedReferenceField -document_type mongoengine/mongoengine/fields.py /^ def document_type(self):$/;" m class:EmbeddedDocumentField -document_type mongoengine/mongoengine/fields.py /^ def document_type(self):$/;" m class:LazyReferenceField -document_type mongoengine/mongoengine/fields.py /^ def document_type(self):$/;" m class:ReferenceField -down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=105,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=124,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=13,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=17,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=530,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -down_votes mongoengine/tests/queryset/queryset.py /^ down_votes=553,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -down_votes mongoengine/tests/queryset/queryset.py /^ down_votes = IntField()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -drink mongoengine/tests/document/inheritance.py /^ drink = GenericReferenceField()$/;" v class:InheritanceTest.test_inherited_collections.Drinker -drop_collection mongoengine/mongoengine/document.py /^ def drop_collection(cls):$/;" m class:Document -dt mongoengine/tests/fields/fields.py /^ dt = DateTimeField()$/;" v class:FieldTest.test_datetime_from_empty_string.MyDoc -dt mongoengine/tests/fields/fields.py /^ dt = DateTimeField()$/;" v class:FieldTest.test_datetime_from_whitespace_string.MyDoc -dt tests/fields/fields.py /^ dt = DateTimeField()$/;" v class:FieldTest.test_datetime_from_empty_string.MyDoc -dt tests/fields/fields.py /^ dt = DateTimeField()$/;" v class:FieldTest.test_datetime_from_whitespace_string.MyDoc -dt_f mongoengine/tests/queryset/queryset.py /^ dt_f = DateTimeField()$/;" v class:QuerySetTest.test_update_validate.Doc -dt_fld mongoengine/tests/document/instance.py /^ dt_fld = DateTimeField(null=True)$/;" v class:InstanceTest.test_null_field.User -dynamic_field mongoengine/tests/document/instance.py /^ dynamic_field = DynamicField(default=1)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -dynamic_field mongoengine/tests/document/json_serialisation.py /^ dynamic_field = DynamicField(default=1)$/;" v class:TestJson.test_json_complex.Doc -dynamic_field mongoengine/tests/queryset/queryset.py /^ dynamic_field = DynamicField(default=1)$/;" v class:QuerySetTest.test_json_complex.Doc -e mongoengine/tests/document/validation.py /^ e = EmbeddedDocumentField(SubDoc, db_field='eb')$/;" v class:ValidatorErrorTest.test_embedded_db_field_validate.Doc -e mongoengine/tests/document/validation.py /^ e = EmbeddedDocumentField(SubDoc, db_field='eb')$/;" v class:ValidatorErrorTest.test_embedded_weakref.Doc -e mongoengine/tests/queryset/field_list.py /^ e = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc -e mongoengine/tests/queryset/field_list.py /^ e = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc -ed_f mongoengine/tests/queryset/queryset.py /^ ed_f = EmbeddedDocumentField(EmDoc)$/;" v class:QuerySetTest.test_update_validate.Doc -editor mongoengine/tests/document/instance.py /^ editor = ReferenceField(Editor)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal.BlogPost -email mongoengine/docs/code/tumblelog.py /^ email = StringField(required=True)$/;" v class:User -email mongoengine/tests/document/instance.py /^ email = StringField(primary_key=True)$/;" v class:InstanceTest.test_custom_id_field.User.EmailUser -email mongoengine/tests/document/instance.py /^ email = EmailField()$/;" v class:InstanceTest.test_instance_is_set_on_setattr.Email -email mongoengine/tests/document/instance.py /^ email = EmailField()$/;" v class:InstanceTest.test_instance_is_set_on_setattr_on_embedded_document_list.Email -email mongoengine/tests/document/instance.py /^ email = EmailField(required=True)$/;" v class:InstanceTest.test_save.Recipient -email mongoengine/tests/document/instance.py /^ email = EmbeddedDocumentField(Email)$/;" v class:InstanceTest.test_instance_is_set_on_setattr.Account -email mongoengine/tests/document/instance.py /^ email = StringField()$/;" v class:InstanceTest.test_custom_id_field.EmailUser -email mongoengine/tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field.User -email mongoengine/tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_domain_whitelist.User -email mongoengine/tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_ip_domain.User -email mongoengine/tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_unicode_user.User -email mongoengine/tests/fields/fields.py /^ email = EmailField(allow_ip_domain=True)$/;" v class:FieldTest.test_email_field_ip_domain.User -email mongoengine/tests/fields/fields.py /^ email = EmailField(allow_utf8_user=True)$/;" v class:FieldTest.test_email_field_unicode_user.User -email mongoengine/tests/fields/fields.py /^ email = EmailField(domain_whitelist=['localhost'])$/;" v class:FieldTest.test_email_field_domain_whitelist.User -email mongoengine/tests/fields/fields.py /^ email = EmailField(regex=r'\\w+@example.com')$/;" v class:FieldTest.test_email_field_honors_regex.User -email mongoengine/tests/queryset/field_list.py /^ email = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude.User -email mongoengine/tests/queryset/field_list.py /^ email = StringField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.User -email mongoengine/tests/queryset/queryset.py /^ email = EmailField(unique=True, required=True)$/;" v class:QuerySetTest.test_as_pymongo_json_limit_fields.User -email mongoengine/tests/queryset/visitor.py /^ email = EmailField(required=False)$/;" v class:QTest.test_q_merge_queries_edge_case.User -email tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field.User -email tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_domain_whitelist.User -email tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_ip_domain.User -email tests/fields/fields.py /^ email = EmailField()$/;" v class:FieldTest.test_email_field_unicode_user.User -email tests/fields/fields.py /^ email = EmailField(allow_ip_domain=True)$/;" v class:FieldTest.test_email_field_ip_domain.User -email tests/fields/fields.py /^ email = EmailField(allow_utf8_user=True)$/;" v class:FieldTest.test_email_field_unicode_user.User -email tests/fields/fields.py /^ email = EmailField(domain_whitelist=['localhost'])$/;" v class:FieldTest.test_email_field_domain_whitelist.User -email tests/fields/fields.py /^ email = EmailField(regex=r'\\w+@example.com')$/;" v class:FieldTest.test_email_field_honors_regex.User -email_field mongoengine/tests/document/instance.py /^ email_field = EmailField(default="ross@example.com")$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -email_field mongoengine/tests/document/json_serialisation.py /^ email_field = EmailField(default="ross@example.com")$/;" v class:TestJson.test_json_complex.Doc -email_field mongoengine/tests/queryset/queryset.py /^ email_field = EmailField(default="ross@example.com")$/;" v class:QuerySetTest.test_json_complex.Doc -emails mongoengine/tests/document/instance.py /^ emails = EmbeddedDocumentListField(Email)$/;" v class:InstanceTest.test_instance_is_set_on_setattr_on_embedded_document_list.Account -embed mongoengine/tests/queryset/queryset.py /^ embed = EmbeddedDocumentField(Embed, default=Embed)$/;" v class:QuerySetTest.test_save_and_only_on_fields_with_default.B -embed_me mongoengine/tests/fields/fields.py /^ embed_me = DynamicField(db_field='e')$/;" v class:FieldTest.test_dynamic_fields_class.Doc -embed_me mongoengine/tests/fields/fields.py /^ embed_me = DynamicField(db_field='e')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc -embed_me tests/fields/fields.py /^ embed_me = DynamicField(db_field='e')$/;" v class:FieldTest.test_dynamic_fields_class.Doc -embed_me tests/fields/fields.py /^ embed_me = DynamicField(db_field='e')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc -embed_no_default mongoengine/tests/queryset/queryset.py /^ embed_no_default = EmbeddedDocumentField(Embed)$/;" v class:QuerySetTest.test_save_and_only_on_fields_with_default.B -embedded mongoengine/tests/document/json_serialisation.py /^ embedded = EmbeddedDocumentField(Embedded, db_field='e')$/;" v class:TestJson.test_json_names.Doc -embedded mongoengine/tests/fields/fields.py /^ embedded = EmbeddedDocumentField(Embedded, db_field='x')$/;" v class:FieldTest.test_embedded_db_field.Test -embedded mongoengine/tests/fixtures.py /^ embedded = EmbeddedDocumentField(PickleEmbedded)$/;" v class:NewDocumentPickleTest -embedded mongoengine/tests/fixtures.py /^ embedded = EmbeddedDocumentField(PickleEmbedded)$/;" v class:PickleSignalsTest -embedded mongoengine/tests/fixtures.py /^ embedded = EmbeddedDocumentField(PickleEmbedded)$/;" v class:PickleTest -embedded mongoengine/tests/queryset/field_list.py /^ embedded = EmbeddedDocumentField(EmbeddedNumber)$/;" v class:OnlyExcludeAllTest.test_slicing_nested_fields.Numbers -embedded mongoengine/tests/queryset/queryset.py /^ embedded = EmbeddedDocumentField(SubDoc)$/;" v class:QuerySetTest.test_reload_embedded_docs_instance.Doc -embedded mongoengine/tests/queryset/queryset.py /^ embedded = ListField(EmbeddedDocumentField(SubDoc))$/;" v class:QuerySetTest.test_reload_list_embedded_docs_instance.Doc -embedded tests/fields/fields.py /^ embedded = EmbeddedDocumentField(Embedded, db_field='x')$/;" v class:FieldTest.test_embedded_db_field.Test -embedded_document_field mongoengine/tests/document/instance.py /^ embedded_document_field = EmbeddedDocumentField($/;" v class:InstanceTest.test_can_save_if_not_included.Doc -embedded_document_field mongoengine/tests/document/json_serialisation.py /^ embedded_document_field = EmbeddedDocumentField(EmbeddedDoc,$/;" v class:TestJson.test_json_complex.Doc -embedded_document_field mongoengine/tests/queryset/queryset.py /^ embedded_document_field = EmbeddedDocumentField($/;" v class:QuerySetTest.test_json_complex.Doc -embedded_field mongoengine/tests/document/delta.py /^ embedded_field = EmbeddedDocumentField(Embedded)$/;" v class:DeltaTest.delta_recursive.Doc -embedded_field mongoengine/tests/document/delta.py /^ embedded_field = EmbeddedDocumentField(Embedded,$/;" v class:DeltaTest.delta_recursive_db_field.Doc -embedded_field mongoengine/tests/document/instance.py /^ embedded_field = EmbeddedDocumentField(Embedded)$/;" v class:InstanceTest.test_embedded_document_instance.Doc -embedded_field mongoengine/tests/document/instance.py /^ embedded_field = EmbeddedDocumentField(Embedded)$/;" v class:InstanceTest.test_reload_referencing.Doc -embedded_field mongoengine/tests/document/instance.py /^ embedded_field = ListField(EmbeddedDocumentField(Embedded))$/;" v class:InstanceTest.test_embedded_document_complex_instance.Doc -embedded_field mongoengine/tests/document/instance.py /^ embedded_field = ListField(EmbeddedDocumentField(Embedded))$/;" v class:InstanceTest.test_embedded_document_complex_instance_no_use_db_field.Doc -embedded_field mongoengine/tests/document/json_serialisation.py /^ embedded_field = EmbeddedDocumentField(Embedded)$/;" v class:TestJson.test_json_simple.Doc -embedded_field mongoengine/tests/queryset/queryset.py /^ embedded_field = EmbeddedDocumentField(Embedded)$/;" v class:QuerySetTest.test_json_simple.Doc -employee mongoengine/tests/document/class_methods.py /^ employee = ReferenceField(self.Person)$/;" v class:ClassMethodsTest.test_register_delete_rule.Job -employees mongoengine/tests/document/delta.py /^ employees = ListField(ReferenceField('Person', dbref=dbref))$/;" v class:DeltaTest.circular_reference_deltas_2.Organization -employees mongoengine/tests/queryset/queryset.py /^ employees = ListField(ReferenceField(Person))$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Organization -employees mongoengine/tests/test_dereference.py /^ employees = Employee.objects(boss=bill).select_related()$/;" v class:FieldTest.test_recursive_reference.Employee -employer mongoengine/tests/document/delta.py /^ employer = ReferenceField('Organization', dbref=dbref)$/;" v class:DeltaTest.circular_reference_deltas_2.Person -empty mongoengine/mongoengine/queryset/visitor.py /^ def empty(self):$/;" m class:Q -empty mongoengine/mongoengine/queryset/visitor.py /^ def empty(self):$/;" m class:QCombination -empty mongoengine/mongoengine/queryset/visitor.py /^ def empty(self):$/;" m class:QNode -ensure_index mongoengine/mongoengine/document.py /^ def ensure_index(cls, key_or_list, drop_dups=False, background=False,$/;" m class:Document -ensure_index mongoengine/mongoengine/queryset/base.py /^ def ensure_index(self, **kwargs):$/;" m class:BaseQuerySet -ensure_indexes mongoengine/mongoengine/document.py /^ def ensure_indexes(cls):$/;" m class:Document -error mongoengine/mongoengine/base/fields.py /^ def error(self, message='', errors=None, field_name=None):$/;" m class:BaseField -error_class mongoengine/tests/queryset/queryset.py /^ error_class = ConfigurationError$/;" v class:QuerySetTest.test_read_preference.Bar -error_class mongoengine/tests/queryset/queryset.py /^ error_class = TypeError$/;" v class:QuerySetTest.test_read_preference.Bar -error_dict mongoengine/tests/fields/fields.py /^ error_dict = error.to_dict()$/;" v class:FieldTest.test_recursive_validation.Post -error_dict mongoengine/tests/fields/fields.py /^ error_dict = error.to_dict()$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt -error_dict tests/fields/fields.py /^ error_dict = error.to_dict()$/;" v class:FieldTest.test_recursive_validation.Post -error_dict tests/fields/fields.py /^ error_dict = error.to_dict()$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt -error_msg mongoengine/fields.py /^ error_msg = u'Invalid email address: %s'$/;" v class:EmailField -error_msg mongoengine/mongoengine/fields.py /^ error_msg = u'Invalid email address: %s'$/;" v class:EmailField -errors mongoengine/mongoengine/errors.py /^ errors = {}$/;" v class:ValidationError -evil mongoengine/tests/document/inheritance.py /^ evil = BooleanField(default=True)$/;" v class:InheritanceTest.test_abstract_documents.Human.EvilHuman -exclude mongoengine/mongoengine/base/datastructures.py /^ def exclude(self, **kwargs):$/;" m class:EmbeddedDocumentList -exclude mongoengine/mongoengine/queryset/base.py /^ def exclude(self, *fields):$/;" m class:BaseQuerySet -exclude_trees mongoengine/docs/conf.py /^exclude_trees = ['_build']$/;" v -exec_js mongoengine/mongoengine/queryset/base.py /^ def exec_js(self, code, *fields, **options):$/;" m class:BaseQuerySet -expand mongoengine/tests/document/instance.py /^ def expand(self):$/;" m class:InstanceTest.test_complex_nesting_document_and_embedded_document.Node -expand mongoengine/tests/document/instance.py /^ def expand(self):$/;" m class:InstanceTest.test_complex_nesting_document_and_embedded_document.Parameter -expect_msg mongoengine/tests/document/instance.py /^ expect_msg = "Draft entries may not have a publication date."$/;" v class:InstanceTest.test_document_clean.TestDocument -expected mongoengine/tests/fields/geo.py /^ expected = "Both values (%s) in point must be float or int" % repr(coord)$/;" v class:GeoFieldTest.test_geopoint_validation.Location -expected mongoengine/tests/fields/geo.py /^ expected = "Both values (%s) in point must be float or int" % repr(coord)$/;" v class:GeoFieldTest.test_point_validation.Location -expected mongoengine/tests/fields/geo.py /^ expected = "Both values (%s) in point must be float or int" % repr(coord[0])$/;" v class:GeoFieldTest.test_multipoint_validation.Location -expected mongoengine/tests/fields/geo.py /^ expected = "Invalid LineString:\\nBoth values (%s) in point must be float or int" % repr(coord[0])$/;" v class:GeoFieldTest.test_linestring_validation.Location -expected mongoengine/tests/fields/geo.py /^ expected = "Invalid MultiLineString:\\nBoth values (%s) in point must be float or int" % repr(coord[0][0])$/;" v class:GeoFieldTest.test_multilinestring_validation.Location -expected mongoengine/tests/fields/geo.py /^ expected = "Value (%s) must be a two-dimensional point" % repr(coord)$/;" v class:GeoFieldTest.test_geopoint_validation.Location -expected mongoengine/tests/fields/geo.py /^ expected = "Value (%s) must be a two-dimensional point" % repr(coord)$/;" v class:GeoFieldTest.test_point_validation.Location -expected mongoengine/tests/fields/geo.py /^ expected = "Value (%s) must be a two-dimensional point" % repr(coord[0])$/;" v class:GeoFieldTest.test_multipoint_validation.Location -explain mongoengine/mongoengine/queryset/base.py /^ def explain(self, format=False):$/;" m class:BaseQuerySet -extend mongoengine/mongoengine/base/datastructures.py /^ def extend(self, *args, **kwargs):$/;" m class:BaseList -extensions mongoengine/docs/conf.py /^extensions = ['sphinx.ext.autodoc', 'sphinx.ext.todo']$/;" v -extra mongoengine/tests/document/instance.py /^ extra = DictField()$/;" v class:InstanceTest.test_db_ref_usage.Book -extra mongoengine/tests/queryset/queryset.py /^ extra = EmbeddedDocumentField(Extra)$/;" v class:QuerySetTest.test_item_frequencies_with_null_embedded.Person -extra_opts mongoengine/setup.py /^extra_opts = {$/;" v -extra_text mongoengine/tests/document/class_methods.py /^ extra_text = StringField()$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPostWithTagsAndExtraText -f mongoengine/tests/queryset/field_list.py /^ f = ListField()$/;" v class:OnlyExcludeAllTest.test_slicing.MyDoc -f mongoengine/tests/queryset/field_list.py /^ f = StringField()$/;" v class:OnlyExcludeAllTest.test_mixing_only_exclude.MyDoc -fake_update mongoengine/tests/document/instance.py /^ def fake_update(*args, **kwargs):$/;" m class:InstanceTest.test_do_not_save_unchanged_references.Person -family mongoengine/tests/document/class_methods.py /^ family = StringField(required=True)$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Animal -family mongoengine/tests/fields/file_tests.py /^ family = StringField()$/;" v class:FileTest.test_complex_field_filefield.Animal -family mongoengine/tests/fields/file_tests.py /^ family = StringField()$/;" v class:FileTest.test_file_saving.Animal -family mongoengine/tests/queryset/queryset.py /^ family = ReferenceField(Family)$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person -father mongoengine/tests/document/instance.py /^ father = ReferenceField('Person', reverse_delete_rule=DENY)$/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Parents -father mongoengine/tests/fields/fields.py /^ father = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone -father mongoengine/tests/fields/fields.py /^ father = CachedReferenceField('self', fields=('tp',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person -father mongoengine/tests/fields/fields.py /^ father = CachedReferenceField('self', fields=('tp',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person -father tests/fields/fields.py /^ father = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone -father tests/fields/fields.py /^ father = CachedReferenceField('self', fields=('tp',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person -father tests/fields/fields.py /^ father = CachedReferenceField('self', fields=('tp',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person -feed mongoengine/tests/document/instance.py /^ feed = Feed.objects.first()$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription -feed mongoengine/tests/document/instance.py /^ feed = ReferenceField(Feed)$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription -fetch mongoengine/mongoengine/base/datastructures.py /^ def fetch(self, force=False):$/;" m class:LazyReference -field mongoengine/mongoengine/base/fields.py /^ field = None$/;" v class:ComplexBaseField -field mongoengine/tests/document/instance.py /^ field=ReferenceField($/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Blog -field mongoengine/tests/document/instance.py /^ field = StringField(required=True)$/;" v class:InstanceTest.test_embedded_document_equality.Test -field mongoengine/tests/fields/fields.py /^ field = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.Doc -field mongoengine/tests/fields/fields.py /^ field = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.Doc -field mongoengine/tests/queryset/queryset.py /^ field = IntField()$/;" v class:QuerySetTest.test_save_and_only_on_fields_with_default.Embed -field mongoengine/tests/queryset/queryset.py /^ field = IntField(default=1)$/;" v class:QuerySetTest.test_save_and_only_on_fields_with_default.B -field tests/fields/fields.py /^ field = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.Doc -field tests/fields/fields.py /^ field = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.Doc -field1 mongoengine/tests/document/instance.py /^ field1 = StringField(default='field1')$/;" v class:InstanceTest.test_mutating_documents.B -field2 mongoengine/tests/document/instance.py /^ field2 = EmbeddedDocumentField(C, default=lambda: C())$/;" v class:InstanceTest.test_mutating_documents.B -field_1 mongoengine/tests/fields/fields.py /^ field_1 = StringField(db_field='f')$/;" v class:FieldTest.test_dynamic_fields_class.Doc2 -field_1 mongoengine/tests/fields/fields.py /^ field_1 = StringField(db_field='f')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Embed -field_1 tests/fields/fields.py /^ field_1 = StringField(db_field='f')$/;" v class:FieldTest.test_dynamic_fields_class.Doc2 -field_1 tests/fields/fields.py /^ field_1 = StringField(db_field='f')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Embed -field_name mongoengine/mongoengine/errors.py /^ field_name = None$/;" v class:ValidationError -field_path_sub mongoengine/mongoengine/queryset/base.py /^ def field_path_sub(match):$/;" f function:BaseQuerySet._sub_js_fields -field_sub mongoengine/mongoengine/queryset/base.py /^ def field_sub(match):$/;" f function:BaseQuerySet._sub_js_fields -field_x mongoengine/tests/fields/fields.py /^ field_x = StringField(db_field='x')$/;" v class:FieldTest.test_dynamic_fields_class.Doc -field_x mongoengine/tests/fields/fields.py /^ field_x = StringField(db_field='x')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc -field_x tests/fields/fields.py /^ field_x = StringField(db_field='x')$/;" v class:FieldTest.test_dynamic_fields_class.Doc -field_x tests/fields/fields.py /^ field_x = StringField(db_field='x')$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc -fielda mongoengine/tests/queryset/queryset.py /^ fielda = IntField()$/;" v class:QuerySetTest.test_where.IntPair -fieldb mongoengine/tests/queryset/queryset.py /^ fieldb = IntField()$/;" v class:QuerySetTest.test_where.IntPair -fields mongoengine/mongoengine/queryset/base.py /^ def fields(self, _only_called=False, **kwargs):$/;" m class:BaseQuerySet -fields mongoengine/tests/fields/fields.py /^ fields=('group',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData -fields mongoengine/tests/fields/fields.py /^ fields=('salary',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest -fields mongoengine/tests/queryset/queryset.py /^ fields = DictField()$/;" v class:QuerySetTest.test_no_cache.Noddy -fields tests/fields/fields.py /^ fields=('group',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData -fields tests/fields/fields.py /^ fields=('salary',))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest -filter mongoengine/mongoengine/base/datastructures.py /^ def filter(self, **kwargs):$/;" m class:EmbeddedDocumentList -filter mongoengine/mongoengine/queryset/base.py /^ def filter(self, *q_objs, **query):$/;" m class:BaseQuerySet -finalize_f mongoengine/tests/queryset/queryset.py /^ finalize_f=finalize_f,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -first mongoengine/mongoengine/base/datastructures.py /^ def first(self):$/;" m class:EmbeddedDocumentList -first mongoengine/mongoengine/queryset/base.py /^ def first(self):$/;" m class:BaseQuerySet -first_name mongoengine/docs/code/tumblelog.py /^ first_name = StringField(max_length=50)$/;" v class:User -flip mongoengine/tests/document/instance.py /^ def flip(widget):$/;" f function:InstanceTest.test_save_atomicity_condition -float_field mongoengine/tests/document/instance.py /^ float_field = FloatField(default=1.1)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -float_field mongoengine/tests/document/json_serialisation.py /^ float_field = FloatField(default=1.1)$/;" v class:TestJson.test_json_complex.Doc -float_field mongoengine/tests/queryset/queryset.py /^ float_field = FloatField(default=1.1)$/;" v class:QuerySetTest.test_json_complex.Doc -float_fld mongoengine/tests/fields/fields.py /^ float_fld = FloatField()$/;" v class:FieldTest.test_int_and_float_ne_operator.TestDocument -float_fld tests/fields/fields.py /^ float_fld = FloatField()$/;" v class:FieldTest.test_int_and_float_ne_operator.TestDocument -float_value mongoengine/tests/fields/fields.py /^ float_value = DecimalField(precision=4)$/;" v class:FieldTest.test_decimal_storage.Person -float_value tests/fields/fields.py /^ float_value = DecimalField(precision=4)$/;" v class:FieldTest.test_decimal_storage.Person -flt_fld mongoengine/tests/document/instance.py /^ flt_fld = FloatField(null=True)$/;" v class:InstanceTest.test_null_field.User -flt_fld mongoengine/tests/fields/fields.py /^ flt_fld = FloatField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -flt_fld mongoengine/tests/fields/fields.py /^ flt_fld = FloatField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields -flt_fld tests/fields/fields.py /^ flt_fld = FloatField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -flt_fld tests/fields/fields.py /^ flt_fld = FloatField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields -folded_ears mongoengine/tests/queryset/queryset.py /^ folded_ears = BooleanField()$/;" v class:QuerySetTest.test_subclass_field_query.ScottishCat -foo mongoengine/tests/document/instance.py /^ foo = BooleanField(unique=True)$/;" v class:InstanceTest.subclasses_and_unique_keys_works.B -foo mongoengine/tests/document/instance.py /^ foo = EmbeddedDocumentField(Foo)$/;" v class:InstanceTest.test_shard_key_in_embedded_document.Bar -foo mongoengine/tests/document/instance.py /^ foo = ListField(StringField())$/;" v class:InstanceTest.test_update_list_field.Doc -foo mongoengine/tests/document/instance.py /^ foo = ReferenceField('Foo')$/;" v class:InstanceTest.test_two_way_reverse_delete_rule.Bar -foo mongoengine/tests/document/instance.py /^ foo = StringField()$/;" v class:InstanceTest.test_can_save_false_values.Doc -foo mongoengine/tests/document/instance.py /^ foo = StringField()$/;" v class:InstanceTest.test_can_save_false_values_dynamic.Doc -foo mongoengine/tests/document/instance.py /^ foo = StringField()$/;" v class:InstanceTest.test_shard_key_in_embedded_document.Foo -foo mongoengine/tests/document/instance.py /^ foo = StringField(default=None)$/;" v class:InstanceTest.test_set_unset_one_operation.FooBar -foo mongoengine/tests/fields/fields.py /^ foo = StringField()$/;" v class:FieldTest.test_undefined_field_exception.Doc -foo mongoengine/tests/fields/fields.py /^ foo = StringField()$/;" v class:FieldTest.test_undefined_field_exception_with_strict.Doc -foo mongoengine/tests/queryset/queryset.py /^ foo = ListField(EmbeddedDocumentField(Foo))$/;" v class:QuerySetTest.test_elem_match.Bar -foo mongoengine/tests/queryset/transform.py /^ foo = ListField(StringField())$/;" v class:TransformTest.test_transform_update.LisDoc -foo tests/fields/fields.py /^ foo = StringField()$/;" v class:FieldTest.test_undefined_field_exception.Doc -foo tests/fields/fields.py /^ foo = StringField()$/;" v class:FieldTest.test_undefined_field_exception_with_strict.Doc -food mongoengine/tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_embedded_document_validation.PersonPreferences -food mongoengine/tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_embedded_document.Dish -food mongoengine/tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_embedded_document_choices.Dish -food mongoengine/tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Dish -food tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_embedded_document_validation.PersonPreferences -food tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_embedded_document.Dish -food tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_embedded_document_choices.Dish -food tests/fields/fields.py /^ food = StringField(required=True)$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Dish -foos mongoengine/tests/queryset/queryset.py /^ foos = ListField(GenericEmbeddedDocumentField($/;" v class:QuerySetTest.test_pull_in_genericembedded_field.Bar -format mongoengine/fields.py /^ def format(self):$/;" m class:ImageGridFsProxy -format mongoengine/mongoengine/fields.py /^ def format(self):$/;" m class:ImageGridFsProxy -forms mongoengine/tests/document/instance.py /^ forms = ListField(StringField(), default=list)$/;" v class:InstanceTest.test_invalid_son.Word -friend mongoengine/tests/document/instance.py /^ friend = ReferenceField('self')$/;" v class:InstanceTest.test_save_max_recursion_not_hit.Person -friends mongoengine/tests/fields/fields.py /^ friends = ListField(ReferenceField('self'))$/;" v class:FieldTest.test_recursive_reference.Employee -friends mongoengine/tests/test_dereference.py /^ friends = ListField(ReferenceField('Person'))$/;" v class:FieldTest.test_circular_tree_reference.Other -friends mongoengine/tests/test_dereference.py /^ friends = ListField(ReferenceField('self'))$/;" v class:FieldTest.test_recursive_reference.Employee -friends tests/fields/fields.py /^ friends = ListField(ReferenceField('self'))$/;" v class:FieldTest.test_recursive_reference.Employee -from_json mongoengine/mongoengine/base/document.py /^ def from_json(cls, json_data, created=False):$/;" m class:BaseDocument -from_json mongoengine/mongoengine/queryset/base.py /^ def from_json(self, json_data):$/;" m class:BaseQuerySet -fs mongoengine/fields.py /^ def fs(self):$/;" m class:GridFSProxy -fs mongoengine/mongoengine/fields.py /^ def fs(self):$/;" m class:GridFSProxy -gender mongoengine/tests/queryset/queryset.py /^ gender = StringField()$/;" v class:QuerySetTest.test_mapfield_update.Member -generate mongoengine/fields.py /^ def generate(self):$/;" m class:SequenceField -generate mongoengine/mongoengine/fields.py /^ def generate(self):$/;" m class:SequenceField -generate_key mongoengine/mongoengine/errors.py /^ def generate_key(value, prefix=''):$/;" f function:ValidationError._format_errors -generated mongoengine/tests/document/instance.py /^ generated = DateTimeField(default=datetime.now)$/;" v class:InstanceTest.test_reference_inheritance.CompareStats -generic mongoengine/tests/fields/fields.py /^ generic = ListField(GenericReferenceField())$/;" v class:FieldTest.test_list_validation.BlogPost -generic mongoengine/tests/test_context_managers.py /^ generic = GenericReferenceField()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_dbref.Group -generic mongoengine/tests/test_context_managers.py /^ generic = GenericReferenceField()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_object_id.Group -generic tests/fields/fields.py /^ generic = ListField(GenericReferenceField())$/;" v class:FieldTest.test_list_validation.BlogPost -generic_as_lazy mongoengine/tests/fields/fields.py /^ generic_as_lazy = ListField(GenericLazyReferenceField())$/;" v class:FieldTest.test_list_validation.BlogPost -generic_as_lazy tests/fields/fields.py /^ generic_as_lazy = ListField(GenericLazyReferenceField())$/;" v class:FieldTest.test_list_validation.BlogPost -generic_embedded_document_field mongoengine/tests/document/instance.py /^ generic_embedded_document_field = GenericEmbeddedDocumentField($/;" v class:InstanceTest.test_can_save_if_not_included.Doc -generic_embedded_document_field mongoengine/tests/document/json_serialisation.py /^ generic_embedded_document_field = GenericEmbeddedDocumentField($/;" v class:TestJson.test_json_complex.Doc -generic_embedded_document_field mongoengine/tests/queryset/queryset.py /^ generic_embedded_document_field = GenericEmbeddedDocumentField($/;" v class:QuerySetTest.test_json_complex.Doc -generic_ref mongoengine/tests/fields/fields.py /^ generic_ref = GenericReferenceField()$/;" v class:FieldTest.test_reference_miss.Bar -generic_ref tests/fields/fields.py /^ generic_ref = GenericReferenceField()$/;" v class:FieldTest.test_reference_miss.Bar -generic_reference_field mongoengine/tests/document/instance.py /^ generic_reference_field = GenericReferenceField($/;" v class:InstanceTest.test_can_save_if_not_included.Doc -generic_reference_field mongoengine/tests/document/json_serialisation.py /^ generic_reference_field = GenericReferenceField($/;" v class:TestJson.test_json_complex.Doc -generic_reference_field mongoengine/tests/queryset/queryset.py /^ generic_reference_field = GenericReferenceField($/;" v class:QuerySetTest.test_json_complex.Doc -genus mongoengine/tests/fields/file_tests.py /^ genus = StringField()$/;" v class:FileTest.test_complex_field_filefield.Animal -genus mongoengine/tests/fields/file_tests.py /^ genus = StringField()$/;" v class:FileTest.test_file_saving.Animal -geo_point_field mongoengine/tests/document/instance.py /^ geo_point_field = GeoPointField(default=lambda: [1, 2])$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -geo_point_field mongoengine/tests/document/json_serialisation.py /^ geo_point_field = GeoPointField(default=lambda: [1, 2])$/;" v class:TestJson.test_json_complex.Doc -geo_point_field mongoengine/tests/queryset/queryset.py /^ geo_point_field = GeoPointField(default=lambda: [1, 2])$/;" v class:QuerySetTest.test_json_complex.Doc -get mongoengine/fields.py /^ def get(self, grid_id=None):$/;" m class:GridFSProxy -get mongoengine/mongoengine/base/datastructures.py /^ def get(self, **kwargs):$/;" m class:EmbeddedDocumentList -get mongoengine/mongoengine/base/datastructures.py /^ def get(self, key, default=None):$/;" m class:StrictDict -get mongoengine/mongoengine/fields.py /^ def get(self, grid_id=None):$/;" m class:GridFSProxy -get mongoengine/mongoengine/queryset/base.py /^ def get(self, *q_objs, **query):$/;" m class:BaseQuerySet -get_auto_id_names mongoengine/mongoengine/base/metaclasses.py /^ def get_auto_id_names(cls, new_class):$/;" m class:TopLevelDocumentMetaclass -get_classes mongoengine/mongoengine/document.py /^ def get_classes(cls):$/;" f function:Document.list_indexes -get_connection mongoengine/mongoengine/connection.py /^def get_connection(alias=DEFAULT_CONNECTION_NAME, reconnect=False):$/;" f -get_db mongoengine/mongoengine/connection.py /^def get_db(alias=DEFAULT_CONNECTION_NAME, reconnect=False):$/;" f -get_document mongoengine/mongoengine/base/common.py /^def get_document(name):$/;" f -get_indexes_spec mongoengine/mongoengine/document.py /^ def get_indexes_spec(cls):$/;" f function:Document.list_indexes -get_mongodb_version mongoengine/tests/utils.py /^def get_mongodb_version():$/;" f -get_next_value mongoengine/fields.py /^ def get_next_value(self):$/;" m class:SequenceField -get_next_value mongoengine/mongoengine/fields.py /^ def get_next_value(self):$/;" m class:SequenceField -get_ops mongoengine/tests/queryset/queryset.py /^ def get_ops(self):$/;" m class:db_ops_tracker -get_proxy_obj mongoengine/fields.py /^ def get_proxy_obj(self, key, instance, db_alias=None, collection_name=None):$/;" m class:FileField -get_proxy_obj mongoengine/mongoengine/fields.py /^ def get_proxy_obj(self, key, instance, db_alias=None, collection_name=None):$/;" m class:FileField -get_queryset mongoengine/mongoengine/queryset/manager.py /^ get_queryset = None$/;" v class:QuerySetManager -get_queryset mongoengine/tests/queryset/queryset.py /^ def get_queryset(doc_cls, queryset):$/;" m class:QuerySetTest.test_custom_querysets_managers_directly.CustomQuerySetManager -get_sequence_name mongoengine/fields.py /^ def get_sequence_name(self):$/;" m class:SequenceField -get_sequence_name mongoengine/mongoengine/fields.py /^ def get_sequence_name(self):$/;" m class:SequenceField -get_signal_output mongoengine/tests/test_signals.py /^ def get_signal_output(self, fn, *args, **kwargs):$/;" m class:SignalTests -get_text_score mongoengine/mongoengine/base/document.py /^ def get_text_score(self):$/;" m class:BaseDocument -get_tz_awareness mongoengine/tests/test_connection.py /^def get_tz_awareness(connection):$/;" f -get_version mongoengine/mongoengine/__init__.py /^def get_version():$/;" f -get_version mongoengine/setup.py /^def get_version(version_tuple):$/;" f -group mongoengine/tests/document/instance.py /^ group = Group.objects.first()$/;" v class:InstanceTest.test_switch_db_instance.Group -group mongoengine/tests/fields/fields.py /^ group = ReferenceField(Group)$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Person -group mongoengine/tests/fields/fields.py /^ group = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest -group mongoengine/tests/test_context_managers.py /^ group = Group.objects.first()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_dbref.Group -group mongoengine/tests/test_context_managers.py /^ group = Group.objects.first()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_object_id.Group -group tests/fields/fields.py /^ group = ReferenceField(Group)$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Person -group tests/fields/fields.py /^ group = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_dict_field.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_dict_field_no_field_inheritance.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_generic_reference.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_generic_reference_map_field.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_list_field_complex.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_list_item_dereference.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_list_item_dereference_dref_false.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first()$/;" v class:FieldTest.test_map_field_reference.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_dict_field.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_dict_field_no_field_inheritance.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_generic_reference.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_generic_reference_map_field.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_list_field_complex.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_list_item_dereference.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_list_item_dereference_dref_false.Group -group_obj mongoengine/tests/test_dereference.py /^ group_obj = Group.objects.first().select_related()$/;" v class:FieldTest.test_map_field_reference.Group -group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_dict_field.Group -group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_dict_field_no_field_inheritance.Group -group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_generic_reference.Group -group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_generic_reference_map_field.Group -group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_list_field_complex.Group -group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_list_item_dereference.Group -group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_list_item_dereference_dref_false.Group -group_objs mongoengine/tests/test_dereference.py /^ group_objs = Group.objects.select_related()$/;" v class:FieldTest.test_map_field_reference.Group -groups mongoengine/tests/fields/fields.py /^ groups = ListField(EmbeddedDocumentField(Group))$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Basedoc -groups tests/fields/fields.py /^ groups = ListField(EmbeddedDocumentField(Group))$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Basedoc -height mongoengine/tests/document/instance.py /^ height = FloatField()$/;" v class:InstanceTest.test_falsey_pk.Person -height mongoengine/tests/document/instance.py /^ height = IntField(default=184, null=True)$/;" v class:InstanceTest.test_null_field.User -height mongoengine/tests/document/instance.py /^ height = IntField(default=189)$/;" v class:InstanceTest.test_default_values.Person -height mongoengine/tests/fields/fields.py /^ height = DecimalField(min_value=Decimal('0.1'),$/;" v class:FieldTest.test_decimal_validation.Person -height mongoengine/tests/fields/fields.py /^ height = FloatField()$/;" v class:FieldTest.test_float_validation.BigPerson -height mongoengine/tests/fields/fields.py /^ height = FloatField(min_value=0.1, max_value=3.5)$/;" v class:FieldTest.test_float_validation.Person -height tests/fields/fields.py /^ height = DecimalField(min_value=Decimal('0.1'),$/;" v class:FieldTest.test_decimal_validation.Person -height tests/fields/fields.py /^ height = FloatField()$/;" v class:FieldTest.test_float_validation.BigPerson -height tests/fields/fields.py /^ height = FloatField(min_value=0.1, max_value=3.5)$/;" v class:FieldTest.test_float_validation.Person -helpful mongoengine/tests/queryset/queryset.py /^ helpful = ListField(EmbeddedDocumentField(User))$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Collaborator -high_score mongoengine/tests/queryset/queryset.py /^ high_score = IntField()$/;" v class:QuerySetTest.test_update_min_max.Scores -hint mongoengine/mongoengine/queryset/base.py /^ def hint(self, index=None):$/;" m class:BaseQuerySet -hits mongoengine/tests/queryset/queryset.py /^ hits = IntField()$/;" v class:QuerySetTest.test_exec_js_query.BlogPost -hits mongoengine/tests/queryset/queryset.py /^ hits = IntField()$/;" v class:QuerySetTest.test_item_frequencies.BlogPost -hits mongoengine/tests/queryset/queryset.py /^ hits = IntField()$/;" v class:QuerySetTest.test_update.BlogPost -html_favicon mongoengine/docs/conf.py /^html_favicon = "favicon.ico"$/;" v -html_sidebars mongoengine/docs/conf.py /^html_sidebars = {$/;" v -html_theme mongoengine/docs/conf.py /^html_theme = 'sphinx_rtd_theme'$/;" v -html_theme_options mongoengine/docs/conf.py /^html_theme_options = {$/;" v -html_theme_path mongoengine/docs/conf.py /^html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]$/;" v -html_use_smartypants mongoengine/docs/conf.py /^html_use_smartypants = True$/;" v -htmlhelp_basename mongoengine/docs/conf.py /^htmlhelp_basename = 'MongoEnginedoc'$/;" v -id mongoengine/tests/document/delta.py /^ id = StringField()$/;" v class:DeltaTest.delta_recursive.Embedded -id mongoengine/tests/document/inheritance.py /^ id = IntField()$/;" v class:InheritanceTest.test_auto_id_vs_non_pk_id_field.City -id mongoengine/tests/document/instance.py /^ id = IntField(primary_key=True)$/;" v class:InstanceTest.test_reverse_delete_rule_with_shared_id_among_collections.Book -id mongoengine/tests/document/instance.py /^ id = IntField(primary_key=True)$/;" v class:InstanceTest.test_reverse_delete_rule_with_shared_id_among_collections.User -id mongoengine/tests/document/instance.py /^ id = StringField(required=True)$/;" v class:InstanceTest.test_embedded_document_to_mongo_id.SubDoc -id mongoengine/tests/document/validation.py /^ id = StringField(primary_key=True)$/;" v class:ValidatorErrorTest.test_embedded_db_field_validate.Doc -id mongoengine/tests/fields/fields.py /^ id = BinaryField(primary_key=True)$/;" v class:FieldTest.test_binary_field_primary.Attachment -id mongoengine/tests/fields/fields.py /^ id = BinaryField(primary_key=True)$/;" v class:FieldTest.test_binary_field_primary_filter_by_binary_pk_as_str.Attachment -id mongoengine/tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbed -id mongoengine/tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent -id mongoengine/tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbed -id mongoengine/tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent -id mongoengine/tests/fields/fields.py /^ id = SequenceField()$/;" v class:FieldTest.test_embedded_sequence_field.Comment -id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields.Person -id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Animal -id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Person -id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_sequence_field.Person -id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_sequence_field_get_next_value.Person -id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True, sequence_name='jelly')$/;" v class:FieldTest.test_sequence_field_sequence_name.Person -id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True, value_decorator=str)$/;" v class:FieldTest.test_sequence_field_get_next_value.Person -id mongoengine/tests/fields/fields.py /^ id = SequenceField(primary_key=True, value_decorator=str)$/;" v class:FieldTest.test_sequence_field_value_decorator.Person -id mongoengine/tests/queryset/modify.py /^ id = IntField(primary_key=True)$/;" v class:Doc -id mongoengine/tests/queryset/queryset.py /^ id = IntField($/;" v class:QuerySetTest.test_map_reduce_custom_output.Family -id mongoengine/tests/queryset/queryset.py /^ id = IntField($/;" v class:QuerySetTest.test_map_reduce_custom_output.Person -id mongoengine/tests/queryset/queryset.py /^ id = ObjectIdField('_id')$/;" v class:QuerySetTest.test_as_pymongo.User -id mongoengine/tests/queryset/queryset.py /^ id = StringField(unique=True, primary_key=True)$/;" v class:QuerySetTest.test_filter_chaining.Blog -id mongoengine/tests/queryset/queryset.py /^ id = StringField(unique=True, primary_key=True)$/;" v class:QuerySetTest.test_query_reference_to_custom_pk_doc.A -id mongoengine/tests/test_dereference.py /^ id = IntField(primary_key=True)$/;" v class:FieldTest.test_document_reload_reference_integrity.Message -id mongoengine/tests/test_dereference.py /^ id = IntField(primary_key=True)$/;" v class:FieldTest.test_document_reload_reference_integrity.Topic -id mongoengine/tests/test_dereference.py /^ id = IntField(primary_key=True)$/;" v class:FieldTest.test_document_reload_reference_integrity.User -id mongoengine/tests/test_dereference.py /^ id = IntField(primary_key=True)$/;" v class:FieldTest.test_list_lookup_not_checked_in_map.Comment -id mongoengine/tests/test_dereference.py /^ id = IntField(primary_key=True)$/;" v class:FieldTest.test_list_lookup_not_checked_in_map.Message -id mongoengine/tests/test_signals.py /^ id = IntField(primary_key=True)$/;" v class:SignalTests.setUp.ExplicitId -id mongoengine/tests/test_signals.py /^ id = SequenceField(primary_key=True)$/;" v class:SignalTests.setUp.Author -id tests/fields/fields.py /^ id = BinaryField(primary_key=True)$/;" v class:FieldTest.test_binary_field_primary.Attachment -id tests/fields/fields.py /^ id = BinaryField(primary_key=True)$/;" v class:FieldTest.test_binary_field_primary_filter_by_binary_pk_as_str.Attachment -id tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbed -id tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent -id tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbed -id tests/fields/fields.py /^ id = IntField(primary_key=True, default=1)$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent -id tests/fields/fields.py /^ id = SequenceField()$/;" v class:FieldTest.test_embedded_sequence_field.Comment -id tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields.Person -id tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Animal -id tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Person -id tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_sequence_field.Person -id tests/fields/fields.py /^ id = SequenceField(primary_key=True)$/;" v class:FieldTest.test_sequence_field_get_next_value.Person -id tests/fields/fields.py /^ id = SequenceField(primary_key=True, sequence_name='jelly')$/;" v class:FieldTest.test_sequence_field_sequence_name.Person -id tests/fields/fields.py /^ id = SequenceField(primary_key=True, value_decorator=str)$/;" v class:FieldTest.test_sequence_field_get_next_value.Person -id tests/fields/fields.py /^ id = SequenceField(primary_key=True, value_decorator=str)$/;" v class:FieldTest.test_sequence_field_value_decorator.Person -image mongoengine/tests/fields/file_tests.py /^ image = ImageField()$/;" v class:FileTest.test_image_field.TestImage -image mongoengine/tests/fields/file_tests.py /^ image = ImageField(size=(185, 37))$/;" v class:FileTest.test_image_field_resize.TestImage -image mongoengine/tests/fields/file_tests.py /^ image = ImageField(size=(185, 37, True))$/;" v class:FileTest.test_image_field_resize_force.TestImage -image mongoengine/tests/fields/file_tests.py /^ image = ImageField(thumbnail_size=(92, 18))$/;" v class:FileTest.test_image_field_thumbnail.TestImage -image1 mongoengine/tests/fields/file_tests.py /^ image1 = ImageField()$/;" v class:FileTest.test_get_image_by_grid_id.TestImage -image2 mongoengine/tests/fields/file_tests.py /^ image2 = ImageField()$/;" v class:FileTest.test_get_image_by_grid_id.TestImage -image_path mongoengine/docs/code/tumblelog.py /^ image_path = StringField()$/;" v class:ImagePost -in_bulk mongoengine/mongoengine/queryset/base.py /^ def in_bulk(self, object_ids):$/;" m class:BaseQuerySet -in_embedded mongoengine/tests/fields/fields.py /^ in_embedded = EmbeddedDocumentField(EmbeddedOcurrence)$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence -in_embedded mongoengine/tests/fields/fields.py /^ in_embedded = EmbeddedDocumentField(EmbeddedOcurrence)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence -in_embedded tests/fields/fields.py /^ in_embedded = EmbeddedDocumentField(EmbeddedOcurrence)$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence -in_embedded tests/fields/fields.py /^ in_embedded = EmbeddedDocumentField(EmbeddedOcurrence)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence -in_list mongoengine/tests/fields/fields.py /^ in_list = ListField(GenericLazyReferenceField())$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.EmbeddedOcurrence -in_list mongoengine/tests/fields/fields.py /^ in_list = ListField(GenericLazyReferenceField())$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence -in_list mongoengine/tests/fields/fields.py /^ in_list = ListField(LazyReferenceField(Animal))$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.EmbeddedOcurrence -in_list mongoengine/tests/fields/fields.py /^ in_list = ListField(LazyReferenceField(Animal))$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence -in_list tests/fields/fields.py /^ in_list = ListField(GenericLazyReferenceField())$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.EmbeddedOcurrence -in_list tests/fields/fields.py /^ in_list = ListField(GenericLazyReferenceField())$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Ocurrence -in_list tests/fields/fields.py /^ in_list = ListField(LazyReferenceField(Animal))$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.EmbeddedOcurrence -in_list tests/fields/fields.py /^ in_list = ListField(LazyReferenceField(Animal))$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Ocurrence -includes_cls mongoengine/mongoengine/document.py /^def includes_cls(fields):$/;" f -info mongoengine/tests/document/delta.py /^ info = ReferenceField(UInfoDocument)$/;" v class:DeltaTest.test_delta_for_nested_map_fields.EmbeddedUser -info mongoengine/tests/fields/fields.py /^ info = DictField()$/;" v class:FieldTest.test_dict_field.BlogPost -info mongoengine/tests/fields/fields.py /^ info = ListField()$/;" v class:FieldTest.test_list_assignment.BlogPost -info mongoengine/tests/fields/fields.py /^ info = ListField()$/;" v class:FieldTest.test_list_field.BlogPost -info mongoengine/tests/fields/fields.py /^ info = ListField(StringField())$/;" v class:FieldTest.test_list_field_invalid_operators.BlogPost -info mongoengine/tests/fields/fields.py /^ info = ListField(StringField())$/;" v class:FieldTest.test_list_field_manipulative_operators.BlogPost -info mongoengine/tests/queryset/queryset.py /^ info = DictField()$/;" v class:QuerySetTest.test_find_dict_item.BlogPost -info tests/fields/fields.py /^ info = DictField()$/;" v class:FieldTest.test_dict_field.BlogPost -info tests/fields/fields.py /^ info = ListField()$/;" v class:FieldTest.test_list_assignment.BlogPost -info tests/fields/fields.py /^ info = ListField()$/;" v class:FieldTest.test_list_field.BlogPost -info tests/fields/fields.py /^ info = ListField(StringField())$/;" v class:FieldTest.test_list_field_invalid_operators.BlogPost -info tests/fields/fields.py /^ info = ListField(StringField())$/;" v class:FieldTest.test_list_field_manipulative_operators.BlogPost -info_dict mongoengine/tests/fields/fields.py /^ info_dict = MapField(field=EmbeddedDocumentField(Info))$/;" v class:FieldTest.test_map_field_unicode.BlogPost -info_dict tests/fields/fields.py /^ info_dict = MapField(field=EmbeddedDocumentField(Info))$/;" v class:FieldTest.test_map_field_unicode.BlogPost -init mongoengine/setup.py /^init = os.path.join(os.path.dirname(__file__), 'mongoengine', '__init__.py')$/;" v -insert mongoengine/mongoengine/base/datastructures.py /^ def insert(self, *args, **kwargs):$/;" m class:BaseList -insert mongoengine/mongoengine/queryset/base.py /^ def insert(self, doc_or_docs, load_bulk=True,$/;" m class:BaseQuerySet -int_field mongoengine/tests/document/delta.py /^ int_field = IntField()$/;" v class:DeltaTest.delta.Doc -int_field mongoengine/tests/document/delta.py /^ int_field = IntField()$/;" v class:DeltaTest.delta_recursive.Doc -int_field mongoengine/tests/document/delta.py /^ int_field = IntField()$/;" v class:DeltaTest.delta_recursive.Embedded -int_field mongoengine/tests/document/delta.py /^ int_field = IntField(db_field='db_int_field')$/;" v class:DeltaTest.delta_db_field.Doc -int_field mongoengine/tests/document/delta.py /^ int_field = IntField(db_field='db_int_field')$/;" v class:DeltaTest.delta_recursive_db_field.Doc -int_field mongoengine/tests/document/delta.py /^ int_field = IntField(db_field='db_int_field')$/;" v class:DeltaTest.delta_recursive_db_field.Embedded -int_field mongoengine/tests/document/instance.py /^ int_field = IntField(default=1)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -int_field mongoengine/tests/document/json_serialisation.py /^ int_field = IntField(default=1)$/;" v class:TestJson.test_json_complex.Doc -int_field mongoengine/tests/queryset/queryset.py /^ int_field = IntField(default=1)$/;" v class:QuerySetTest.test_json_complex.Doc -int_fld mongoengine/tests/document/instance.py /^ int_fld = IntField(null=True)$/;" v class:InstanceTest.test_null_field.User -int_fld mongoengine/tests/fields/fields.py /^ int_fld = IntField()$/;" v class:FieldTest.test_int_and_float_ne_operator.TestDocument -int_fld mongoengine/tests/fields/fields.py /^ int_fld = IntField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -int_fld mongoengine/tests/fields/fields.py /^ int_fld = IntField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields -int_fld tests/fields/fields.py /^ int_fld = IntField()$/;" v class:FieldTest.test_int_and_float_ne_operator.TestDocument -int_fld tests/fields/fields.py /^ int_fld = IntField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -int_fld tests/fields/fields.py /^ int_fld = IntField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields -invalid_index mongoengine/tests/document/indexes.py /^ def invalid_index():$/;" m class:IndexesTest.test_hint.BlogPost -invalid_index_2 mongoengine/tests/document/indexes.py /^ def invalid_index_2():$/;" f function:IndexesTest.test_hint -ip mongoengine/tests/queryset/queryset.py /^ ip='104.107.108.116'$/;" v class:QuerySetTest.test_as_pymongo.User -ip mongoengine/tests/queryset/queryset.py /^ ip = StringField()$/;" v class:QuerySetTest.test_as_pymongo.LastLogin -is_active mongoengine/tests/queryset/queryset.py /^ is_active=False).save()$/;" v class:QuerySetTest.test_text_indexes.News -is_active mongoengine/tests/queryset/queryset.py /^ is_active = BooleanField(default=True)$/;" v class:QuerySetTest.test_text_indexes.News -is_mamal mongoengine/tests/queryset/queryset.py /^ is_mamal = BooleanField()$/;" v class:QuerySetTest.test_subclass_field_query.Animal -is_published mongoengine/tests/queryset/queryset.py /^ is_published = BooleanField()$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -is_published mongoengine/tests/queryset/queryset.py /^ is_published = BooleanField(default=False)$/;" v class:QuerySetTest.test_custom_querysets_managers_directly.Post -is_published mongoengine/tests/queryset/queryset.py /^ is_published=True,$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -item mongoengine/tests/queryset/transform.py /^ item = EmbeddedDocumentField(EmbeddedItem)$/;" v class:TransformTest.test_last_field_name_like_operator.Doc -item_frequencies mongoengine/mongoengine/queryset/base.py /^ def item_frequencies(self, field, normalize=False, map_reduce=True):$/;" m class:BaseQuerySet -items mongoengine/mongoengine/base/datastructures.py /^ def items(self):$/;" m class:StrictDict -items mongoengine/tests/document/instance.py /^ items = ListField()$/;" v class:InstanceTest.test_reload_of_non_strict_with_special_field_name.Post -items mongoengine/tests/fields/fields.py /^ items = ListField(EnumField())$/;" v class:FieldTest.test_tuples_as_tuples.TestDoc -items mongoengine/tests/test_dereference.py /^ items = ListField(EmbeddedDocumentField("PlaylistItem"))$/;" v class:FieldTest.test_select_related_follows_embedded_referencefields.Playlist -items tests/fields/fields.py /^ items = ListField(EnumField())$/;" v class:FieldTest.test_tuples_as_tuples.TestDoc -iteritems mongoengine/mongoengine/base/datastructures.py /^ def iteritems(self):$/;" m class:StrictDict -iterkeys mongoengine/mongoengine/base/datastructures.py /^ def iterkeys(self):$/;" m class:StrictDict -job mongoengine/tests/document/instance.py /^ job = EmbeddedDocumentField(Job)$/;" v class:InstanceTest.setUp.Person -job mongoengine/tests/document/instance.py /^ job = ReferenceField(Job)$/;" v class:InstanceTest.test_do_not_save_unchanged_references.Person -john mongoengine/docs/code/tumblelog.py /^john = User(email='jdoe@example.com', first_name='John', last_name='Doe')$/;" v -key mongoengine/tests/document/indexes.py /^ key = DictField(primary_key=True)$/;" v class:IndexesTest.test_compound_key_dictfield.ReportDictField -key mongoengine/tests/document/indexes.py /^ key = EmbeddedDocumentField(CompoundKey, primary_key=True)$/;" v class:IndexesTest.test_compound_key_embedded.ReportEmbedded -key mongoengine/tests/queryset/queryset.py /^ key = StringField(primary_key=True)$/;" v class:QuerySetTest.test_scalar_primary_key.SettingValue -key_has_dot_or_dollar mongoengine/fields.py /^def key_has_dot_or_dollar(d):$/;" f -key_has_dot_or_dollar mongoengine/mongoengine/fields.py /^def key_has_dot_or_dollar(d):$/;" f -key_not_string mongoengine/fields.py /^def key_not_string(d):$/;" f -key_not_string mongoengine/mongoengine/fields.py /^def key_not_string(d):$/;" f -keys mongoengine/mongoengine/base/datastructures.py /^ def keys(self):$/;" m class:StrictDict -keywords mongoengine/tests/document/indexes.py /^ keywords = StringField()$/;" v class:IndexesTest.test_build_index_spec_is_not_destructive.MyDoc -l mongoengine/tests/document/instance.py /^ l = ListField(EmbeddedDocumentField(B))$/;" v class:InstanceTest.test_list_iter.A -last_login mongoengine/tests/queryset/queryset.py /^ last_login = EmbeddedDocumentField(LastLogin)$/;" v class:QuerySetTest.test_as_pymongo.User -last_login mongoengine/tests/queryset/queryset.py /^ last_login=LastLogin($/;" v class:QuerySetTest.test_as_pymongo.User -last_name mongoengine/docs/code/tumblelog.py /^ last_name = StringField(max_length=50)$/;" v class:User -latex_documents mongoengine/docs/conf.py /^latex_documents = [$/;" v -latex_paper_size mongoengine/docs/conf.py /^latex_paper_size = 'a4'$/;" v -like mongoengine/tests/fields/fields.py /^ like = GenericEmbeddedDocumentField()$/;" v class:FieldTest.test_generic_embedded_document.Person -like mongoengine/tests/fields/fields.py /^ like = GenericEmbeddedDocumentField(choices=(Dish,))$/;" v class:FieldTest.test_generic_embedded_document_choices.Person -like tests/fields/fields.py /^ like = GenericEmbeddedDocumentField()$/;" v class:FieldTest.test_generic_embedded_document.Person -like tests/fields/fields.py /^ like = GenericEmbeddedDocumentField(choices=(Dish,))$/;" v class:FieldTest.test_generic_embedded_document_choices.Person -likes mongoengine/tests/fields/fields.py /^ likes = ListField(GenericEmbeddedDocumentField(choices=(Dish,)))$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Person -likes tests/fields/fields.py /^ likes = ListField(GenericEmbeddedDocumentField(choices=(Dish,)))$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Person -limit mongoengine/mongoengine/queryset/base.py /^ def limit(self, n):$/;" m class:BaseQuerySet -line mongoengine/tests/fields/geo.py /^ line = LineStringField()$/;" v class:GeoFieldTest.test_indexes_2dsphere.Event -line mongoengine/tests/fields/geo.py /^ line = LineStringField()$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Venue -line mongoengine/tests/queryset/geo.py /^ line = LineStringField()$/;" v class:GeoQueriesTest.test_2dsphere_linestring_sets_correctly.Location -line mongoengine/tests/queryset/geo.py /^ line = LineStringField()$/;" v class:GeoQueriesTest.test_linestring.Road -line mongoengine/tests/queryset/transform.py /^ line = LineStringField()$/;" v class:TransformTest.test_geojson_LineStringField.Location -link_url mongoengine/docs/code/tumblelog.py /^ link_url = StringField()$/;" v class:LinkPost -list_field mongoengine/tests/document/delta.py /^ list_field = ListField()$/;" v class:DeltaTest.delta.Doc -list_field mongoengine/tests/document/delta.py /^ list_field = ListField()$/;" v class:DeltaTest.delta_recursive.Doc -list_field mongoengine/tests/document/delta.py /^ list_field = ListField()$/;" v class:DeltaTest.delta_recursive.Embedded -list_field mongoengine/tests/document/delta.py /^ list_field = ListField(db_field='db_list_field')$/;" v class:DeltaTest.delta_db_field.Doc -list_field mongoengine/tests/document/delta.py /^ list_field = ListField(db_field='db_list_field')$/;" v class:DeltaTest.delta_recursive_db_field.Doc -list_field mongoengine/tests/document/delta.py /^ list_field = ListField(db_field='db_list_field')$/;" v class:DeltaTest.delta_recursive_db_field.Embedded -list_field mongoengine/tests/document/instance.py /^ list_field = ListField()$/;" v class:InstanceTest.test_reload_referencing.Doc -list_field mongoengine/tests/document/instance.py /^ list_field = ListField()$/;" v class:InstanceTest.test_reload_referencing.Embedded -list_field mongoengine/tests/document/instance.py /^ list_field = ListField(default=lambda: [1, 2, 3])$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -list_field mongoengine/tests/document/json_serialisation.py /^ list_field = ListField(default=lambda: [1, 2, 3])$/;" v class:TestJson.test_json_complex.Doc -list_field mongoengine/tests/queryset/queryset.py /^ list_field = ListField(default=lambda: [1, 2, 3])$/;" v class:QuerySetTest.test_json_complex.Doc -list_indexes mongoengine/mongoengine/document.py /^ def list_indexes(cls):$/;" m class:Document -lists mongoengine/tests/fixtures.py /^ lists = ListField(StringField())$/;" v class:NewDocumentPickleTest -lists mongoengine/tests/fixtures.py /^ lists = ListField(StringField())$/;" v class:PickleSignalsTest -lists mongoengine/tests/fixtures.py /^ lists = ListField(StringField())$/;" v class:PickleTest -live_and_let_die mongoengine/tests/test_signals.py /^ def live_and_let_die():$/;" f function:SignalTests.test_signal_kwargs -living_thing mongoengine/tests/fields/fields.py /^ living_thing = GenericLazyReferenceField(choices=[Animal, Vegetal])$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Ocurrence -living_thing tests/fields/fields.py /^ living_thing = GenericLazyReferenceField(choices=[Animal, Vegetal])$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Ocurrence -load_existing_author mongoengine/tests/test_signals.py /^ def load_existing_author():$/;" f function:SignalTests.test_model_signals -loc mongoengine/tests/fields/geo.py /^ loc = GeoPointField()$/;" v class:GeoFieldTest.test_geopoint_validation.Location -loc mongoengine/tests/fields/geo.py /^ loc = LineStringField()$/;" v class:GeoFieldTest.test_linestring_validation.Location -loc mongoengine/tests/fields/geo.py /^ loc = MultiLineStringField()$/;" v class:GeoFieldTest.test_multilinestring_validation.Location -loc mongoengine/tests/fields/geo.py /^ loc = MultiPointField()$/;" v class:GeoFieldTest.test_multipoint_validation.Location -loc mongoengine/tests/fields/geo.py /^ loc = MultiPolygonField()$/;" v class:GeoFieldTest.test_multipolygon_validation.Location -loc mongoengine/tests/fields/geo.py /^ loc = PointField()$/;" v class:GeoFieldTest.test_point_validation.Location -loc mongoengine/tests/fields/geo.py /^ loc = PolygonField()$/;" v class:GeoFieldTest.test_polygon_validation.Location -loc mongoengine/tests/queryset/geo.py /^ loc = PointField()$/;" v class:GeoQueriesTest.test_2dsphere_point_sets_correctly.Location -loc mongoengine/tests/queryset/transform.py /^ loc = PointField()$/;" v class:TransformTest.test_geojson_PointField.Location -locale mongoengine/tests/queryset/queryset.py /^ locale=Locale(city="Belo Horizonte", country="Brazil")).save()$/;" v class:QuerySetTest.test_scalar_embedded.Person -locale mongoengine/tests/queryset/queryset.py /^ locale=Locale(city="Brasilia", country="Brazil")).save()$/;" v class:QuerySetTest.test_scalar_embedded.Person -locale mongoengine/tests/queryset/queryset.py /^ locale=Locale(city="Corumba-GO", country="Brazil")).save()$/;" v class:QuerySetTest.test_scalar_embedded.Person -locale mongoengine/tests/queryset/queryset.py /^ locale=Locale(city="New York", country="USA")).save()$/;" v class:QuerySetTest.test_scalar_embedded.Person -locale mongoengine/tests/queryset/queryset.py /^ locale = EmbeddedDocumentField(Locale)$/;" v class:QuerySetTest.test_scalar_embedded.Person -location mongoengine/tests/document/indexes.py /^ location = DictField()$/;" v class:IndexesTest.test_create_geohaystack_index.Place -location mongoengine/tests/document/indexes.py /^ location = DictField()$/;" v class:IndexesTest.test_explicit_geo2d_index.Place -location mongoengine/tests/document/indexes.py /^ location = DictField()$/;" v class:IndexesTest.test_explicit_geo2d_index_embedded.EmbeddedLocation -location mongoengine/tests/document/indexes.py /^ location = DictField()$/;" v class:IndexesTest.test_explicit_geohaystack_index.Place -location mongoengine/tests/document/indexes.py /^ location = DictField()$/;" v class:IndexesTest.test_explicit_geosphere_index.Place -location mongoengine/tests/document/instance.py /^ location = ReferenceField('Location', dbref=True)$/;" v class:InstanceTest.test_document_registry_regressions.Area -location mongoengine/tests/fields/geo.py /^ location = GeoPointField()$/;" v class:GeoFieldTest.test_geo_indexes_recursion.Location -location mongoengine/tests/fields/geo.py /^ location = GeoPointField()$/;" v class:GeoFieldTest.test_geopoint_embedded_indexes.Venue -location mongoengine/tests/fields/geo.py /^ location = GeoPointField()$/;" v class:GeoFieldTest.test_indexes_geopoint.Event -location mongoengine/tests/fields/geo.py /^ location = PointField(auto_index=False)$/;" v class:GeoFieldTest.test_geo_indexes_auto_index.Log -location mongoengine/tests/fields/geo.py /^ location = ReferenceField(Location)$/;" v class:GeoFieldTest.test_geo_indexes_recursion.Parent -location mongoengine/tests/queryset/geo.py /^ location = GeoPointField()$/;" v class:GeoQueriesTest.test_spherical_geospatial_operators.Point -location mongoengine/tests/queryset/geo.py /^ location = PointField()$/;" v class:GeoQueriesTest.test_aspymongo_with_only.Place -location mongoengine/tests/queryset/geo.py /^ location = point_field_class()$/;" v class:GeoQueriesTest._create_event_data.Event -location mongoengine/tests/queryset/geo.py /^ location = point_field_class()$/;" v class:GeoQueriesTest._test_embedded.Venue -location mongoengine/tests/queryset/geo.py /^ location=[-122.4194155, 37.7749295])$/;" v class:GeoQueriesTest._create_event_data.Event -location mongoengine/tests/queryset/geo.py /^ location=[-87.677137, 41.909889])$/;" v class:GeoQueriesTest._create_event_data.Event -location mongoengine/tests/queryset/geo.py /^ location=[-87.686638, 41.900474])$/;" v class:GeoQueriesTest._create_event_data.Event -location mongoengine/tests/queryset/queryset.py /^ location='White House',$/;" v class:QuerySetTest.test_as_pymongo.User -location mongoengine/tests/queryset/queryset.py /^ location = StringField()$/;" v class:QuerySetTest.test_as_pymongo.LastLogin -location mongoengine/tests/queryset/transform.py /^ location = GeoPointField()$/;" v class:TransformTest.test_understandable_error_raised.Event -location__max_distance mongoengine/tests/queryset/geo.py /^ location__max_distance=60 \/ earth_radius)$/;" v class:GeoQueriesTest.test_spherical_geospatial_operators.Point -location__min_distance mongoengine/tests/queryset/geo.py /^ location__min_distance=60 \/ earth_radius)$/;" v class:GeoQueriesTest.test_spherical_geospatial_operators.Point -location__within_spherical_distance mongoengine/tests/queryset/geo.py /^ location__within_spherical_distance=[$/;" v class:GeoQueriesTest.test_spherical_geospatial_operators.Point -log mongoengine/tests/document/instance.py /^ log = StringField()$/;" v class:InstanceTest.test_shard_key.LogEntry -log mongoengine/tests/document/instance.py /^ log = StringField()$/;" v class:InstanceTest.test_shard_key_primary.LogEntry -log mongoengine/tests/queryset/queryset.py /^ log = StringField()$/;" v class:QuerySetTest.test_map_reduce_custom_output.Family -log1 mongoengine/tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=d1)$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry -log1 mongoengine/tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=d1.isoformat('T'))$/;" v class:FieldTest.test_datetime_usage.LogEntry -log1 mongoengine/tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=query)$/;" v class:FieldTest.test_datetime_usage.LogEntry -log1 tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=d1)$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry -log1 tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=d1.isoformat('T'))$/;" v class:FieldTest.test_datetime_usage.LogEntry -log1 tests/fields/fields.py /^ log1 = LogEntry.objects.get(date=query)$/;" v class:FieldTest.test_datetime_usage.LogEntry -log_message mongoengine/tests/document/instance.py /^ log_message = StringField(verbose_name="Log message",$/;" v class:InstanceTest.test_embedded_update.Page -log_message mongoengine/tests/document/instance.py /^ log_message = StringField(verbose_name="Log message",$/;" v class:InstanceTest.test_embedded_update_after_save.Page -log_message mongoengine/tests/document/instance.py /^ log_message = StringField(verbose_name="Log message",$/;" v class:InstanceTest.test_embedded_update_db_field.Page -long_fld mongoengine/tests/fields/fields.py /^ long_fld = LongField()$/;" v class:FieldTest.test_long_ne_operator.TestDocument -long_fld tests/fields/fields.py /^ long_fld = LongField()$/;" v class:FieldTest.test_long_ne_operator.TestDocument -lookup mongoengine/mongoengine/queryset/base.py /^ def lookup(obj, name):$/;" f function:BaseQuerySet._get_scalar -lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:CachedReferenceField -lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:DictField -lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:DynamicField -lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:EmbeddedDocumentField -lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:GenericEmbeddedDocumentField -lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:LazyReferenceField -lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:ReferenceField -lookup_member mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:StringField -lookup_member mongoengine/mongoengine/base/fields.py /^ def lookup_member(self, member_name):$/;" m class:ComplexBaseField -lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:CachedReferenceField -lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:DictField -lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:DynamicField -lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:EmbeddedDocumentField -lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:GenericEmbeddedDocumentField -lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:LazyReferenceField -lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:ReferenceField -lookup_member mongoengine/mongoengine/fields.py /^ def lookup_member(self, member_name):$/;" m class:StringField -low_score mongoengine/tests/queryset/queryset.py /^ low_score = IntField()$/;" v class:QuerySetTest.test_update_min_max.Scores -machine mongoengine/tests/document/instance.py /^ machine = StringField()$/;" v class:InstanceTest.test_shard_key.LogEntry -machine mongoengine/tests/document/instance.py /^ machine = StringField(primary_key=True)$/;" v class:InstanceTest.test_shard_key_primary.LogEntry -macros mongoengine/tests/document/instance.py /^ macros = MapField(EmbeddedDocumentField(Macro))$/;" v class:InstanceTest.test_complex_nesting_document_and_embedded_document.Parameter -main mongoengine/benchmark.py /^def main():$/;" f -map_f mongoengine/tests/queryset/queryset.py /^ map_f=map_family,$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person -map_f mongoengine/tests/queryset/queryset.py /^ map_f=map_person,$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person -map_field mongoengine/tests/document/instance.py /^ map_field = MapField(IntField(), default=lambda: {"simple": 1})$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -map_field mongoengine/tests/document/json_serialisation.py /^ map_field = MapField(IntField(), default=lambda: {"simple": 1})$/;" v class:TestJson.test_json_complex.Doc -map_field mongoengine/tests/queryset/queryset.py /^ map_field = MapField(IntField(), default=lambda: {"simple": 1})$/;" v class:QuerySetTest.test_json_complex.Doc -map_reduce mongoengine/mongoengine/queryset/base.py /^ def map_reduce(self, map_f, reduce_f, output, finalize_f=None, limit=None,$/;" m class:BaseQuerySet -mapping mongoengine/tests/fields/fields.py /^ mapping = MapField()$/;" v class:FieldTest.test_mapfield.Simple.NoDeclaredType -mapping mongoengine/tests/fields/fields.py /^ mapping = DictField()$/;" v class:FieldTest.test_complex_field_same_value_not_changed.Simple -mapping mongoengine/tests/fields/fields.py /^ mapping = DictField()$/;" v class:FieldTest.test_dictfield_complex.Simple -mapping mongoengine/tests/fields/fields.py /^ mapping = DictField(field=IntField())$/;" v class:FieldTest.test_dictfield_strict.Simple -mapping mongoengine/tests/fields/fields.py /^ mapping = DictField(field=ListField(IntField(required=True)))$/;" v class:FieldTest.test_atomic_update_dict_field.Simple -mapping mongoengine/tests/fields/fields.py /^ mapping = DictField(required=True)$/;" v class:FieldTest.test_complex_field_required.Simple -mapping mongoengine/tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_complex_field_same_value_not_changed.Simple -mapping mongoengine/tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_list_field_complex.Simple -mapping mongoengine/tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_list_field_rejects_strings.Simple -mapping mongoengine/tests/fields/fields.py /^ mapping = ListField(field=IntField())$/;" v class:FieldTest.test_list_field_strict.Simple -mapping mongoengine/tests/fields/fields.py /^ mapping = ListField(required=True)$/;" v class:FieldTest.test_complex_field_required.Simple -mapping mongoengine/tests/fields/fields.py /^ mapping = MapField(EmbeddedDocumentField(SettingBase))$/;" v class:FieldTest.test_complex_mapfield.Extensible -mapping mongoengine/tests/fields/fields.py /^ mapping = MapField(IntField())$/;" v class:FieldTest.test_mapfield.Simple -mapping tests/fields/fields.py /^ mapping = MapField()$/;" v class:FieldTest.test_mapfield.Simple.NoDeclaredType -mapping tests/fields/fields.py /^ mapping = DictField()$/;" v class:FieldTest.test_complex_field_same_value_not_changed.Simple -mapping tests/fields/fields.py /^ mapping = DictField()$/;" v class:FieldTest.test_dictfield_complex.Simple -mapping tests/fields/fields.py /^ mapping = DictField(field=IntField())$/;" v class:FieldTest.test_dictfield_strict.Simple -mapping tests/fields/fields.py /^ mapping = DictField(field=ListField(IntField(required=True)))$/;" v class:FieldTest.test_atomic_update_dict_field.Simple -mapping tests/fields/fields.py /^ mapping = DictField(required=True)$/;" v class:FieldTest.test_complex_field_required.Simple -mapping tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_complex_field_same_value_not_changed.Simple -mapping tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_list_field_complex.Simple -mapping tests/fields/fields.py /^ mapping = ListField()$/;" v class:FieldTest.test_list_field_rejects_strings.Simple -mapping tests/fields/fields.py /^ mapping = ListField(field=IntField())$/;" v class:FieldTest.test_list_field_strict.Simple -mapping tests/fields/fields.py /^ mapping = ListField(required=True)$/;" v class:FieldTest.test_complex_field_required.Simple -mapping tests/fields/fields.py /^ mapping = MapField(EmbeddedDocumentField(SettingBase))$/;" v class:FieldTest.test_complex_mapfield.Extensible -mapping tests/fields/fields.py /^ mapping = MapField(IntField())$/;" v class:FieldTest.test_mapfield.Simple -master_doc mongoengine/docs/conf.py /^master_doc = 'index'$/;" v -max_time_ms mongoengine/mongoengine/queryset/base.py /^ def max_time_ms(self, ms):$/;" m class:BaseQuerySet -max_value mongoengine/tests/fields/fields.py /^ max_value=Decimal('3.5'))$/;" v class:FieldTest.test_decimal_validation.Person -max_value tests/fields/fields.py /^ max_value=Decimal('3.5'))$/;" v class:FieldTest.test_decimal_validation.Person -member mongoengine/tests/queryset/queryset.py /^ member = EmbeddedDocumentField(Member)$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Organization -members mongoengine/tests/fields/fields.py /^ members = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_item_dereference.Group -members mongoengine/tests/queryset/queryset.py /^ members = DictField()$/;" v class:QuerySetTest.test_dictfield_update.Club -members mongoengine/tests/queryset/queryset.py /^ members = ListField(EmbeddedDocumentField(Member))$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Organization -members mongoengine/tests/queryset/queryset.py /^ members = ListField(ReferenceField(self.Person))$/;" v class:QuerySetTest.test_update_value_conversion.Group -members mongoengine/tests/queryset/queryset.py /^ members = MapField(EmbeddedDocumentField(Member))$/;" v class:QuerySetTest.test_mapfield_update.Club -members mongoengine/tests/test_context_managers.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:ContextManagersTest.test_no_dereference_context_manager_object_id.Group -members mongoengine/tests/test_context_managers.py /^ members = ListField(ReferenceField(User, dbref=True))$/;" v class:ContextManagersTest.test_no_dereference_context_manager_dbref.Group -members mongoengine/tests/test_dereference.py /^ members = DictField()$/;" v class:FieldTest.test_dict_field.Group -members mongoengine/tests/test_dereference.py /^ members = DictField()$/;" v class:FieldTest.test_dict_field_no_field_inheritance.Group -members mongoengine/tests/test_dereference.py /^ members = ListField()$/;" v class:FieldTest.test_list_field_complex.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_item_dereference.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:FieldTest.test_handle_old_style_references.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:FieldTest.test_list_item_dereference_dref_false.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:FieldTest.test_list_item_dereference_dref_false_stores_as_type.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=False))$/;" v class:FieldTest.test_migrate_references.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=True))$/;" v class:FieldTest.test_handle_old_style_references.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=True))$/;" v class:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries.Group -members mongoengine/tests/test_dereference.py /^ members = ListField(ReferenceField(User, dbref=True))$/;" v class:FieldTest.test_migrate_references.Group -members mongoengine/tests/test_dereference.py /^ members = MapField(GenericReferenceField())$/;" v class:FieldTest.test_generic_reference_map_field.Group -members mongoengine/tests/test_dereference.py /^ members = MapField(ReferenceField(User))$/;" v class:FieldTest.test_map_field_reference.Group -members tests/fields/fields.py /^ members = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_item_dereference.Group -merge mongoengine/mongoengine/base/metaclasses.py /^ def merge(self, new_options):$/;" m class:MetaDict -merge_index_specs mongoengine/mongoengine/base/document.py /^ def merge_index_specs(index_specs, indices):$/;" f function:BaseDocument._build_index_specs -message mongoengine/mongoengine/errors.py /^ message = property(_get_message, _set_message)$/;" v class:ValidationError -message mongoengine/tests/fields/fields.py /^ message = StringField()$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.Comments -message mongoengine/tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents.UserComments -message mongoengine/tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments -message mongoengine/tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.ModeratorComments -message mongoengine/tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.UserComments -message mongoengine/tests/queryset/queryset.py /^ message = StringField()$/;" v class:QuerySetTest.test_ensure_index.Comment -message tests/fields/fields.py /^ message = StringField()$/;" v class:EmbeddedDocumentListFieldTestCase.setUp.Comments -message tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents.UserComments -message tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments -message tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.ModeratorComments -message tests/fields/fields.py /^ message = StringField()$/;" v class:FieldTest.test_choices_validation_documents_invalid.UserComments -meta mongoengine/docs/code/tumblelog.py /^ meta = {'allow_inheritance': True}$/;" v class:Post -meta mongoengine/tests/all_warnings/__init__.py /^ meta = {'allow_inheritance': True}$/;" v class:AllWarnings.test_document_collection_syntax_warning.NonAbstractBase -meta mongoengine/tests/all_warnings/__init__.py /^ meta = {'collection': 'fail'}$/;" v class:AllWarnings.test_document_collection_syntax_warning.InheritedDocumentFailTest -meta mongoengine/tests/document/class_methods.py /^ meta = {"allow_inheritance": True, "indexes": ["family"]}$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Animal -meta mongoengine/tests/document/class_methods.py /^ meta = {"allow_inheritance": True}$/;" v class:ClassMethodsTest.setUp.Person -meta mongoengine/tests/document/class_methods.py /^ meta = {"indexes": ["name"]}$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Vaccine -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_collection_naming.BaseDocument -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_collection_naming.BaseMixin -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes.BlogPost -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPost -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPostWithTags -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPost -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPostWithCustomField -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPostWithTags -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPost -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPostWithTags -meta mongoengine/tests/document/class_methods.py /^ meta = {$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPostWithTagsAndExtraText -meta mongoengine/tests/document/class_methods.py /^ meta = {'allow_inheritance': True}$/;" v class:ClassMethodsTest.test_collection_naming.BaseDocument -meta mongoengine/tests/document/class_methods.py /^ meta = {'collection': 'app'}$/;" v class:ClassMethodsTest.test_collection_name_and_primary.Person -meta mongoengine/tests/document/class_methods.py /^ meta = {'collection': 'pimp_my_collection'}$/;" v class:ClassMethodsTest.test_collection_naming.CustomNamingTest -meta mongoengine/tests/document/class_methods.py /^ meta = {'collection': 'wibble'}$/;" v class:ClassMethodsTest.test_collection_naming.InheritedAbstractNamingTest -meta mongoengine/tests/document/class_methods.py /^ meta = {'collection': collection_name}$/;" v class:ClassMethodsTest.test_custom_collection_name_operations.Person -meta mongoengine/tests/document/class_methods.py /^ meta = {'collection': lambda c: "DYNAMO"}$/;" v class:ClassMethodsTest.test_collection_naming.DynamicNamingTest -meta mongoengine/tests/document/delta.py /^ meta = {"allow_inheritance": True}$/;" v class:DeltaTest.setUp.Person -meta mongoengine/tests/document/delta.py /^ meta = {'allow_inheritance': True}$/;" v class:DeltaTest.test_delta_for_dynamic_documents.Person -meta mongoengine/tests/document/dynamic.py /^ meta = {'allow_inheritance': True}$/;" v class:DynamicTest.setUp.Person -meta mongoengine/tests/document/indexes.py /^ meta = {'indexes': [$/;" v class:IndexesTest.test_index_with_pk.Comment.BlogPost -meta mongoengine/tests/document/indexes.py /^ meta = {"allow_inheritance": True}$/;" v class:IndexesTest.setUp.Person -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest._index_test.BlogPost -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest._index_test_inheritance.BlogPost -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_abstract_index_inheritance.Person -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_abstract_index_inheritance.UserBase -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_build_index_spec_is_not_destructive.MyDoc -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_compound_index_underscore_cls_not_overwritten.TestDoc -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_covered_index.Test -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_dictionary_indexes.BlogPost -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_disable_index_creation.User -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_embedded_document_index.BlogPost -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_embedded_document_index_meta.Person -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_explicit_geo2d_index.Place -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_explicit_geo2d_index_embedded.Place -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_explicit_geohaystack_index.Place -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_explicit_geosphere_index.Place -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_hashed_indexes.Book -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_hint.BlogPost -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_index_dont_send_cls_option.TestChildDoc -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_index_dont_send_cls_option.TestDoc -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_index_no_cls.A -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_index_no_cls.B -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_index_on_id.BlogPost -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_inherited_index.A -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_list_embedded_document_index.BlogPost -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_sparse_compound_indexes.MyDoc -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_string_indexes.MyDoc -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_text_indexes.Book -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_ttl_indexes.Log -meta mongoengine/tests/document/indexes.py /^ meta = {$/;" v class:IndexesTest.test_unique_and_indexes.Customer -meta mongoengine/tests/document/indexes.py /^ meta = {'allow_inheritance': True}$/;" v class:IndexesTest.test_recursive_embedded_objects_dont_break_indexes.RecursiveDocument -meta mongoengine/tests/document/indexes.py /^ meta = {'db_alias': 'test_indexes_after_database_drop'}$/;" v class:IndexesTest.test_indexes_after_database_drop.BlogPost -meta mongoengine/tests/document/indexes.py /^ meta = {'indexes': ['title']}$/;" v class:IndexesTest._index_test_inheritance.ExtendedBlogPost -meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True}$/;" v class:InheritanceTest.test_abstract_documents.Human.EvilHuman -meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': False}$/;" v class:InheritanceTest.test_cant_turn_off_inheritance_on_subclass.Animal.Mammal -meta mongoengine/tests/document/inheritance.py /^ meta = {'collection': 'booze'}$/;" v class:InheritanceTest.test_inherited_collections.Drinker.AcloholicDrink -meta mongoengine/tests/document/inheritance.py /^ meta = {'collection': 'booze'}$/;" v class:InheritanceTest.test_inherited_collections.Drinker.AlcoholicDrink -meta mongoengine/tests/document/inheritance.py /^ meta = meta_settings$/;" v class:InheritanceTest.test_abstract_documents.Animal -meta mongoengine/tests/document/inheritance.py /^ meta = {"abstract": True}$/;" v class:InheritanceTest.test_abstract_embedded_documents.A -meta mongoengine/tests/document/inheritance.py /^ meta = {$/;" v class:InheritanceTest.test_document_inheritance.DateCreatedDocument -meta mongoengine/tests/document/inheritance.py /^ meta = {$/;" v class:InheritanceTest.test_document_inheritance.DateUpdatedDocument -meta mongoengine/tests/document/inheritance.py /^ meta = {$/;" v class:InheritanceTest.test_indexes_and_multiple_inheritance.A -meta mongoengine/tests/document/inheritance.py /^ meta = {$/;" v class:InheritanceTest.test_indexes_and_multiple_inheritance.B -meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True,$/;" v class:InheritanceTest.test_abstract_document_creation_does_not_fail.City -meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True,$/;" v class:InheritanceTest.test_abstract_handle_ids_in_metaclass_properly.City -meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True,$/;" v class:InheritanceTest.test_allow_inheritance_abstract_document.FinalDocument -meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True,$/;" v class:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class.City -meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True,$/;" v class:InheritanceTest.test_auto_id_vs_non_pk_id_field.City -meta mongoengine/tests/document/inheritance.py /^ meta = {'abstract': True}$/;" v class:InheritanceTest.test_abstract_documents.Mammal -meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_allow_inheritance_embedded_document.Comment -meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_cant_turn_off_inheritance_on_subclass.Animal -meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_dynamic_declarations.Animal -meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_inheritance_meta_data.Person -meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_inheritance_to_mongo_keys.Person -meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_inherited_collections.Drink -meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_polymorphic_queries.Animal -meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_subclasses.Animal -meta mongoengine/tests/document/inheritance.py /^ meta = {'allow_inheritance': True}$/;" v class:InheritanceTest.test_superclasses.Animal -meta mongoengine/tests/document/instance.py /^ meta = dict(shard_key=["id"])$/;" v class:InstanceTest.test_from_son.MyPerson -meta mongoengine/tests/document/instance.py /^ meta = {"allow_inheritance": True}$/;" v class:InstanceTest.setUp.Person -meta mongoengine/tests/document/instance.py /^ meta = {"allow_inheritance": True}$/;" v class:InstanceTest.test_db_alias_overrides.A -meta mongoengine/tests/document/instance.py /^ meta = {"allow_inheritance": True}$/;" v class:InstanceTest.test_embedded_document_to_mongo.Person -meta mongoengine/tests/document/instance.py /^ meta = {"db_alias": "testdb-1", "allow_inheritance": True}$/;" v class:InstanceTest.test_db_alias_propagates.A -meta mongoengine/tests/document/instance.py /^ meta = {"db_alias": "testdb-1"}$/;" v class:InstanceTest.test_db_alias_tests.User -meta mongoengine/tests/document/instance.py /^ meta = {"db_alias": "testdb-2"}$/;" v class:InstanceTest.test_db_alias_overrides.B -meta mongoengine/tests/document/instance.py /^ meta = {"db_alias": "testdb-2"}$/;" v class:InstanceTest.test_db_alias_tests.Book -meta mongoengine/tests/document/instance.py /^ meta = {"db_alias": "testdb-3"}$/;" v class:InstanceTest.test_db_alias_tests.AuthorBooks -meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_capped_collection.Log -meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_capped_collection_default.Log -meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_capped_collection_no_max_size_problems.Log -meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_db_ref_usage.Book -meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_reload_of_non_strict_with_special_field_name.Post -meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_shard_key.LogEntry -meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_shard_key_in_embedded_document.Bar -meta mongoengine/tests/document/instance.py /^ meta = {$/;" v class:InstanceTest.test_shard_key_primary.LogEntry -meta mongoengine/tests/document/instance.py /^ meta = {'abstract': True}$/;" v class:InstanceTest.test_save_abstract_document.Doc -meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': False,$/;" v class:InstanceTest.test_list_search_by_embedded.Page -meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': False}$/;" v class:InstanceTest.test_document_embedded_clean.TestEmbeddedDocument -meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': False}$/;" v class:InstanceTest.test_list_search_by_embedded.Comment -meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': False}$/;" v class:InstanceTest.test_list_search_by_embedded.User -meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': False}$/;" v class:InstanceTest.test_reference_inheritance.Stats -meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': True}$/;" v class:InstanceTest.test_custom_id_field.User -meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': True}$/;" v class:InstanceTest.test_document_not_registered.Place -meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': True}$/;" v class:InstanceTest.test_document_registry_regressions.Location -meta mongoengine/tests/document/instance.py /^ meta = {'allow_inheritance': True}$/;" v class:InstanceTest.test_polymorphic_references.Animal -meta mongoengine/tests/document/instance.py /^ meta = {'cascade': False}$/;" v class:InstanceTest.test_save_cascade_meta_false.Person -meta mongoengine/tests/document/instance.py /^ meta = {'cascade': False}$/;" v class:InstanceTest.test_save_cascade_meta_true.Person -meta mongoengine/tests/document/instance.py /^ meta = {'collection': 'blogpost_1'}$/;" v class:InstanceTest.test_save_reference.BlogPost -meta mongoengine/tests/document/instance.py /^ meta = {'shard_key': ('superphylum',)}$/;" v class:InstanceTest.test_reload_sharded.Animal -meta mongoengine/tests/document/instance.py /^ meta = {'shard_key': ('superphylum.name',)}$/;" v class:InstanceTest.test_reload_sharded_nested.Animal -meta mongoengine/tests/document/instance.py /^ meta = {'strict': False}$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false.Thing -meta mongoengine/tests/document/instance.py /^ meta = {'strict': False}$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc.User -meta mongoengine/tests/document/instance.py /^ meta = {'strict': False}$/;" v class:InstanceTest.test_load_undefined_fields_with_strict_false.User -meta mongoengine/tests/document/validation.py /^ meta = {'abstract': True}$/;" v class:ValidatorErrorTest.test_fields_rewrite.BasePerson -meta mongoengine/tests/document/validation.py /^ meta = {'allow_inheritance': True}$/;" v class:ValidatorErrorTest.test_parent_reference_in_child_document.Parent -meta mongoengine/tests/document/validation.py /^ meta = {'allow_inheritance': True}$/;" v class:ValidatorErrorTest.test_parent_reference_set_as_attribute_in_child_document.Parent -meta mongoengine/tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_abstract_reference_base_type.Sibling -meta mongoengine/tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_drop_abstract_document.AbstractDoc -meta mongoengine/tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_reference_abstract_class.Sibling -meta mongoengine/tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Sibling -meta mongoengine/tests/fields/fields.py /^ meta = {"allow_inheritance": True}$/;" v class:FieldTest.test_complex_mapfield.SettingBase -meta mongoengine/tests/fields/fields.py /^ meta = {$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments -meta mongoengine/tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Basedoc -meta mongoengine/tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_inherited_sequencefield.Base -meta mongoengine/tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_no_inherited_sequencefield.Base -meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_generic_reference.Link -meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_cls_field.Animal -meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dictfield_complex.SettingBase -meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent -meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent -meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_embedded_document_inheritance.User -meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_list_field_complex.SettingBase -meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal -meta mongoengine/tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal -meta mongoengine/tests/fields/fields.py /^ meta = {'strict': False}$/;" v class:FieldTest.test_undefined_field_exception_with_strict.Doc -meta mongoengine/tests/fields/geo.py /^ meta = {$/;" v class:GeoFieldTest.test_geo_indexes_auto_index.Log -meta mongoengine/tests/fixtures.py /^ meta = {'allow_inheritance': True}$/;" v class:Base -meta mongoengine/tests/queryset/field_list.py /^ meta = {'allow_inheritance': True}$/;" v class:OnlyExcludeAllTest.setUp.Person -meta mongoengine/tests/queryset/field_list.py /^ meta = {'allow_inheritance': True}$/;" v class:OnlyExcludeAllTest.test_exclude_from_subclasses_docs.Base -meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_bool_with_ordering_from_meta_dict.Person -meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_clear_ordering.BlogPost -meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_cls_query_in_subclassed_docs.Animal -meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_no_ordering_for_get.BlogPost -meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_ordering.BlogPost -meta mongoengine/tests/queryset/queryset.py /^ meta = {$/;" v class:QuerySetTest.test_read_preference.Bar -meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True, 'queryset_class': CustomQuerySet}$/;" v class:QuerySetTest.test_custom_querysets_inherited.Base -meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True}$/;" v class:QuerySetTest.test_custom_querysets_inherited_direct.Base -meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True}$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_on_abstract_document.AbstractBlogPost -meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True}$/;" v class:QuerySetTest.test_reverse_delete_rule_deny_on_abstract_document.AbstractBlogPost -meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True}$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify_on_abstract_document.AbstractBlogPost -meta mongoengine/tests/queryset/queryset.py /^ meta = {'abstract': True}$/;" v class:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents.AbstractBlogPost -meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': False}$/;" v class:QuerySetTest.test_elem_match.Bar -meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': False}$/;" v class:QuerySetTest.test_elem_match.Foo -meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.setUp.Person -meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_ensure_index.Comment -meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_inherit_objects.Foo -meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_inherit_objects_override.Foo -meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_no_sub_classes.A -meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_subclass_field_query.Animal -meta mongoengine/tests/queryset/queryset.py /^ meta = {'allow_inheritance': True}$/;" v class:QuerySetTest.test_upsert_includes_cls.Test -meta mongoengine/tests/queryset/queryset.py /^ meta = {'collection': 'b'}$/;" v class:QuerySetTest.test_save_and_only_on_fields_with_default.B -meta mongoengine/tests/queryset/queryset.py /^ meta = {'db_alias': 'testdb'}$/;" v class:QuerySetTest.test_distinct_handles_references_to_alias.Bar -meta mongoengine/tests/queryset/queryset.py /^ meta = {'db_alias': 'testdb'}$/;" v class:QuerySetTest.test_distinct_handles_references_to_alias.Foo -meta mongoengine/tests/queryset/queryset.py /^ meta = {'indexes': [$/;" v class:QuerySetTest.test_text_indexes.News -meta mongoengine/tests/queryset/queryset.py /^ meta = {'queryset_class': CustomQuerySet}$/;" v class:QuerySetTest.test_custom_querysets.Post -meta mongoengine/tests/queryset/transform.py /^ meta = {$/;" v class:TransformTest.test_raw_query_and_Q_objects.Foo -meta mongoengine/tests/queryset/transform.py /^ meta = {'allow_inheritance': False}$/;" v class:TransformTest.test_raw_and_merging.Doc -meta mongoengine/tests/queryset/visitor.py /^ meta = {'allow_inheritance': True}$/;" v class:QTest.setUp.Person -meta mongoengine/tests/test_context_managers.py /^ meta = {'allow_inheritance': True}$/;" v class:ContextManagersTest.test_no_sub_classes.A -meta mongoengine/tests/test_dereference.py /^ meta = {"db_alias": "testdb-1"}$/;" v class:FieldTest.test_objectid_reference_across_databases.User -meta mongoengine/tests/test_dereference.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_dict_field_no_field_inheritance.UserA -meta mongoengine/tests/test_dereference.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_document_reload_no_inheritance.Bar -meta mongoengine/tests/test_dereference.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_document_reload_no_inheritance.Baz -meta mongoengine/tests/test_dereference.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_document_reload_no_inheritance.Foo -meta mongoengine/tests/test_dereference.py /^ meta = {'collection': 'pages'}$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Page -meta mongoengine/tests/test_dereference.py /^ meta = {'collection': 'tags'}$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Tag -meta tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_abstract_reference_base_type.Sibling -meta tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_drop_abstract_document.AbstractDoc -meta tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_reference_abstract_class.Sibling -meta tests/fields/fields.py /^ meta = {"abstract": True}$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Sibling -meta tests/fields/fields.py /^ meta = {"allow_inheritance": True}$/;" v class:FieldTest.test_complex_mapfield.SettingBase -meta tests/fields/fields.py /^ meta = {$/;" v class:FieldTest.test_choices_validation_documents_inheritance.Comments -meta tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Basedoc -meta tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_inherited_sequencefield.Base -meta tests/fields/fields.py /^ meta = {'abstract': True}$/;" v class:FieldTest.test_no_inherited_sequencefield.Base -meta tests/fields/fields.py /^ meta = {'allow_inheritance': False}$/;" v class:FieldTest.test_generic_reference.Link -meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_cls_field.Animal -meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dictfield_complex.SettingBase -meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent -meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent -meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_embedded_document_inheritance.User -meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:FieldTest.test_list_field_complex.SettingBase -meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal -meta tests/fields/fields.py /^ meta = {'allow_inheritance': True}$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal -meta tests/fields/fields.py /^ meta = {'strict': False}$/;" v class:FieldTest.test_undefined_field_exception_with_strict.Doc -modify mongoengine/mongoengine/document.py /^ def modify(self, query=None, **update):$/;" m class:Document -modify mongoengine/mongoengine/queryset/base.py /^ def modify(self, upsert=False, full_response=False, remove=False, new=False, **update):$/;" m class:BaseQuerySet -money mongoengine/tests/fields/fields.py /^ money = DecimalField()$/;" v class:FieldTest.test_decimal_comparison.Person -money tests/fields/fields.py /^ money = DecimalField()$/;" v class:FieldTest.test_decimal_comparison.Person -mother mongoengine/tests/document/instance.py /^ mother = ReferenceField('Person', reverse_delete_rule=DENY)$/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Parents -msg mongoengine/tests/test_dereference.py /^ msg = StringField(required=True, default='Blammo!')$/;" v class:FieldTest.test_document_reload_no_inheritance.Bar -msg mongoengine/tests/test_dereference.py /^ msg = StringField(required=True, default='Kaboom!')$/;" v class:FieldTest.test_document_reload_no_inheritance.Baz -music_posts mongoengine/tests/queryset/queryset.py /^ def music_posts(doc_cls, queryset, deleted=False):$/;" m class:QuerySetTest.test_custom_manager.BlogPost -my_id mongoengine/tests/fields/fields.py /^ my_id = IntField(required=True, unique=True, primary_key=True)$/;" v class:FieldTest.test_dynamic_fields_class.Doc -my_id mongoengine/tests/fields/fields.py /^ my_id = IntField(required=True, unique=True, primary_key=True)$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc -my_id mongoengine/tests/test_dereference.py /^ my_id = IntField(primary_key=True)$/;" v class:FieldTest.test_list_item_dereference_dref_false_stores_as_type.User -my_id tests/fields/fields.py /^ my_id = IntField(required=True, unique=True, primary_key=True)$/;" v class:FieldTest.test_dynamic_fields_class.Doc -my_id tests/fields/fields.py /^ my_id = IntField(required=True, unique=True, primary_key=True)$/;" v class:FieldTest.test_dynamic_fields_embedded_class.Doc -my_list mongoengine/tests/fields/fields.py /^ my_list = ListField(EmbeddedDocumentField(EmbeddedWithSparseUnique))$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.B -my_list mongoengine/tests/fields/fields.py /^ my_list = ListField(EmbeddedDocumentField(EmbeddedWithUnique))$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.A -my_list tests/fields/fields.py /^ my_list = ListField(EmbeddedDocumentField(EmbeddedWithSparseUnique))$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.B -my_list tests/fields/fields.py /^ my_list = ListField(EmbeddedDocumentField(EmbeddedWithUnique))$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.A -my_map mongoengine/tests/fields/fields.py /^ my_map = MapField(EmbeddedDocumentField(Embedded))$/;" v class:FieldTest.test_mapfield_numerical_index.Test -my_map mongoengine/tests/fields/fields.py /^ my_map = MapField(field=EmbeddedDocumentField(Embedded),$/;" v class:FieldTest.test_embedded_mapfield_db_field.Test -my_map tests/fields/fields.py /^ my_map = MapField(EmbeddedDocumentField(Embedded))$/;" v class:FieldTest.test_mapfield_numerical_index.Test -my_map tests/fields/fields.py /^ my_map = MapField(field=EmbeddedDocumentField(Embedded),$/;" v class:FieldTest.test_embedded_mapfield_db_field.Test -my_metaclass mongoengine/mongoengine/document.py /^ my_metaclass = DocumentMetaclass$/;" v class:DynamicEmbeddedDocument -my_metaclass mongoengine/mongoengine/document.py /^ my_metaclass = DocumentMetaclass$/;" v class:EmbeddedDocument -my_metaclass mongoengine/mongoengine/document.py /^ my_metaclass = TopLevelDocumentMetaclass$/;" v class:Document -my_metaclass mongoengine/mongoengine/document.py /^ my_metaclass = TopLevelDocumentMetaclass$/;" v class:DynamicDocument -n mongoengine/tests/queryset/field_list.py /^ n = ListField(IntField())$/;" v class:OnlyExcludeAllTest.test_slicing_fields.Numbers -n mongoengine/tests/queryset/field_list.py /^ n = ListField(IntField())$/;" v class:OnlyExcludeAllTest.test_slicing_nested_fields.EmbeddedNumber -n mongoengine/tests/queryset/queryset.py /^ n = IntField()$/;" v class:QuerySetTest.test_clone.Number -n mongoengine/tests/queryset/queryset.py /^ n = IntField()$/;" v class:QuerySetTest.test_order_then_filter.Number -n mongoengine/tests/queryset/queryset.py /^ n = IntField()$/;" v class:QuerySetTest.test_using.Number2 -n mongoengine/tests/queryset/queryset.py /^ n = IntField(db_field='number')$/;" v class:QuerySetTest.test_order_works_with_custom_db_field_names.Number -n mongoengine/tests/queryset/queryset.py /^ n = IntField(primary_key=True)$/;" v class:QuerySetTest.test_order_works_with_primary.Number -name mongoengine/docs/code/tumblelog.py /^ name = StringField(max_length=120)$/;" v class:Comment -name mongoengine/mongoengine/base/fields.py /^ name = None$/;" v class:BaseField -name mongoengine/tests/document/class_methods.py /^ name = StringField()$/;" v class:ClassMethodsTest.setUp.Person -name mongoengine/tests/document/class_methods.py /^ name = StringField()$/;" v class:ClassMethodsTest.test_custom_collection_name_operations.Person -name mongoengine/tests/document/class_methods.py /^ name = StringField(primary_key=True)$/;" v class:ClassMethodsTest.test_collection_name_and_primary.Person -name mongoengine/tests/document/class_methods.py /^ name = StringField(required=True)$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Cat -name mongoengine/tests/document/class_methods.py /^ name = StringField(required=True)$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Vaccine -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.circular_reference_deltas.Organization -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.circular_reference_deltas.Person -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.circular_reference_deltas_2.Organization -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.circular_reference_deltas_2.Person -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.setUp.Person -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_delta_for_dynamic_documents.Person -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_delta_for_nested_map_fields.EmbeddedUser -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_lower_level_mark_as_changed.EmbeddedDoc -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_nested_nested_fields_mark_as_changed.EmbeddedDoc -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_nested_nested_fields_mark_as_changed.MyDoc -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_referenced_object_changed_attributes.Organization -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_referenced_object_changed_attributes.User -name mongoengine/tests/document/delta.py /^ name = StringField()$/;" v class:DeltaTest.test_upper_level_mark_as_changed.EmbeddedDoc -name mongoengine/tests/document/dynamic.py /^ name = StringField()$/;" v class:DynamicTest.setUp.Person -name mongoengine/tests/document/dynamic.py /^ name = StringField()$/;" v class:DynamicTest.test_complex_dynamic_document_queries.Person -name mongoengine/tests/document/dynamic.py /^ name = StringField()$/;" v class:DynamicTest.test_dynamic_and_embedded.Person -name mongoengine/tests/document/dynamic.py /^ name = StringField()$/;" v class:DynamicTest.test_dynamic_and_embedded_dict_access.Person -name mongoengine/tests/document/indexes.py /^ name = StringField()$/;" v class:IndexesTest.setUp.Person -name mongoengine/tests/document/indexes.py /^ name = StringField()$/;" v class:IndexesTest.test_abstract_index_inheritance.Person -name mongoengine/tests/document/indexes.py /^ name = StringField()$/;" v class:IndexesTest.test_create_geohaystack_index.Place -name mongoengine/tests/document/indexes.py /^ name = StringField()$/;" v class:IndexesTest.test_explicit_geohaystack_index.Place -name mongoengine/tests/document/indexes.py /^ name = StringField(db_field='tag')$/;" v class:IndexesTest.test_list_embedded_document_index.Tag -name mongoengine/tests/document/indexes.py /^ name = StringField(primary_key=True)$/;" v class:IndexesTest.test_unique_and_primary_create.User -name mongoengine/tests/document/indexes.py /^ name = StringField(primary_key=True, unique=True)$/;" v class:IndexesTest.test_unique_and_primary.User -name mongoengine/tests/document/indexes.py /^ name = StringField(required=True)$/;" v class:IndexesTest.test_compound_key_embedded.CompoundKey -name mongoengine/tests/document/indexes.py /^ name = StringField(required=True)$/;" v class:IndexesTest.test_embedded_document_index_meta.Person -name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_abstract_documents.Animal -name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_abstract_handle_ids_in_metaclass_properly.EuropeanCity -name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_allow_inheritance.Animal -name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_allow_inheritance_abstract_document.Animal -name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_auto_id_not_set_if_specific_in_parent_class.EuropeanCity -name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_auto_id_vs_non_pk_id_field.EuropeanCity -name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_cant_turn_off_inheritance_on_subclass.Animal -name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_inheritance_meta_data.Person -name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_inheritance_to_mongo_keys.Person -name mongoengine/tests/document/inheritance.py /^ name = StringField()$/;" v class:InheritanceTest.test_inherited_collections.Drink -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_duplicate_db_fields_raise_invalid_document_error.Foo -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.setUp.Job -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.setUp.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_custom_id_field.User -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_data_contains_id_field.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_alias_overrides.A -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_alias_propagates.A -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_alias_tests.Book -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_alias_tests.User -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_ref_usage.Book -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_db_ref_usage.User -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_dbref_equality.Test -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_dbref_equality.Test2 -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_dbref_equality.Test3 -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_default_values.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_do_not_save_unchanged_references.Job -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_do_not_save_unchanged_references.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_document_not_registered.Place -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_document_registry_regressions.Location -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_embedded_document_to_mongo.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_kwargs_complex.Embedded -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_kwargs_simple.Embedded -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields.User -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document.Thing -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document.User -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false.Thing -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false.User -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc.Thing -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc.User -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_load_undefined_fields_with_strict_false.User -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_mixed_creation_dynamic.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_null_field.User -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_object_mixins.NameMixin -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_query_count_when_saving.Feed -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_query_count_when_saving.Organization -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_query_count_when_saving.User -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_reload_sharded_nested.SuperPhylum -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_pull.Record -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_abstract_document.Doc -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_cascade_kwargs.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_cascade_meta_false.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_cascade_meta_true.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_cascades.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_cascades_generically.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_max_recursion_not_hit.Person -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_save_max_recursion_not_hit_with_file_field.Foo -name mongoengine/tests/document/instance.py /^ name = StringField()$/;" v class:InstanceTest.test_switch_db_instance.Group -name mongoengine/tests/document/instance.py /^ name = StringField(primary_key=True)$/;" v class:InstanceTest.test_reverse_delete_rule_with_custom_id_field.User -name mongoengine/tests/document/instance.py /^ name = StringField(required=True)$/;" v class:InstanceTest.test_complex_nesting_document_and_embedded_document.NodesSystem -name mongoengine/tests/document/instance.py /^ name = StringField(required=True)$/;" v class:InstanceTest.test_db_embedded_doc_field_load.Person -name mongoengine/tests/document/instance.py /^ name = StringField(required=True)$/;" v class:InstanceTest.test_db_field_load.Person -name mongoengine/tests/document/instance.py /^ name = StringField(unique=True)$/;" v class:InstanceTest.test_update_unique_field.Doc -name mongoengine/tests/document/validation.py /^ name = StringField()$/;" v class:ValidatorErrorTest.test_fields_rewrite.BasePerson -name mongoengine/tests/document/validation.py /^ name = StringField(required=True)$/;" v class:ValidatorErrorTest.test_fields_rewrite.Person -name mongoengine/tests/document/validation.py /^ name = StringField(required=True)$/;" v class:ValidatorErrorTest.test_model_validation.User -name mongoengine/tests/fields/fields.py /^ name="Wilson Júnior")$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields_on_embedded_documents.Test -name mongoengine/tests/fields/fields.py /^ name = StringField(db_field='$name')$/;" v class:FieldTest.test_db_field_validation.User -name mongoengine/tests/fields/fields.py /^ name = StringField(db_field='name\\0')$/;" v class:FieldTest.test_db_field_validation.User -name mongoengine/tests/fields/fields.py /^ name = StringField(db_field='user.name')$/;" v class:FieldTest.test_db_field_validation.User -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Owner -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.PersonAuto -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields.Product -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Group -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_abstract_reference_base_type.Mother -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_abstract_reference_base_type.Sibling -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_dbref_reference_fields.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_dbref_to_mongo.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_nothing_set.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_set_to_None.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_when_deleting_value.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_drop_abstract_document.AbstractDoc -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance.User -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Group -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_validation.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document.Car -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Car -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Car -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_is_none.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_inherited_sequencefield.Base -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference.User -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_map_field_lookup.Log -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_mapfield_numerical_index.Embedded -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Base -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_object_id_validation.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_objectid_reference_fields.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_embedding.Tree -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_embedding.TreeNode -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_reference.Employee -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_abstract_class.Sibling -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Sibling -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_validation.User -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reverse_list_sorting.Category -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reverse_list_sorting.CategoryList -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_get_next_value.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_sequence_name.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_value_decorator.Person -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_fields_reload.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_undefined_reference.Company -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_undefined_reference.Product -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Mineral -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Vegetal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_equality.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Animal -name mongoengine/tests/fields/fields.py /^ name = StringField(max_length=20)$/;" v class:FieldTest.test_string_validation.Person -name mongoengine/tests/fields/fields.py /^ name = StringField(required=False, unique=True, sparse=True)$/;" v class:FieldTest.test_sparse_field.Doc -name mongoengine/tests/fields/fields.py /^ name = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Author -name mongoengine/tests/fields/fields.py /^ name = StringField(required=True)$/;" v class:FieldTest.test_required_values.Person -name mongoengine/tests/fields/fields.py /^ name='Steve',$/;" v class:FieldTest.test_dbref_to_mongo.Person -name mongoengine/tests/fields/file_tests.py /^ name="hello.txt")$/;" v class:FileTest.test_file_multidb.TestFile -name mongoengine/tests/fields/file_tests.py /^ name = StringField()$/;" v class:FileTest.test_copyable.TestFile -name mongoengine/tests/fields/file_tests.py /^ name = StringField()$/;" v class:FileTest.test_file_multidb.TestFile -name mongoengine/tests/fields/file_tests.py /^ name = StringField()$/;" v class:FileTest.test_file_uniqueness.TestFile -name mongoengine/tests/fields/geo.py /^ name = StringField()$/;" v class:GeoFieldTest.test_geo_indexes_recursion.Location -name mongoengine/tests/fields/geo.py /^ name = StringField()$/;" v class:GeoFieldTest.test_geo_indexes_recursion.Parent -name mongoengine/tests/fields/geo.py /^ name = StringField()$/;" v class:GeoFieldTest.test_geopoint_embedded_indexes.Venue -name mongoengine/tests/fields/geo.py /^ name = StringField()$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Venue -name mongoengine/tests/fixtures.py /^ name = StringField()$/;" v class:Mixin -name mongoengine/tests/queryset/field_list.py /^ name = StringField()$/;" v class:OnlyExcludeAllTest.setUp.Person -name mongoengine/tests/queryset/field_list.py /^ name = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude.User -name mongoengine/tests/queryset/field_list.py /^ name = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Attachment -name mongoengine/tests/queryset/field_list.py /^ name = StringField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.User -name mongoengine/tests/queryset/geo.py /^ name = StringField()$/;" v class:GeoQueriesTest._test_embedded.Venue -name mongoengine/tests/queryset/geo.py /^ name = StringField()$/;" v class:GeoQueriesTest.test_linestring.Road -name mongoengine/tests/queryset/geo.py /^ name = StringField()$/;" v class:GeoQueriesTest.test_polygon.Road -name mongoengine/tests/queryset/pickable.py /^ name = StringField()$/;" v class:Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_update_related_models.TestOrganization -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_update_related_models.TestPerson -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.setUp.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_as_pymongo.User -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_bool_performance.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_bool_with_ordering.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_bool_with_ordering_from_meta_dict.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_bulk_insert.Comment -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_cache_not_cloned.User -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_cached_queryset.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_can_have_field_same_name_as_query_operator.Size -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_cls_query_in_subclassed_docs.Animal -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField.Author -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Author -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_embedded_array_average.Doc -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_embedded_array_sum.Doc -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_embedded_average.Doc -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_embedded_sum.Doc -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_find_array_position.Comment -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_find_embedded.User -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_find_empty_embedded.User -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_generic_reference_field_with_only_and_as_pymongo.TestActivity -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_generic_reference_field_with_only_and_as_pymongo.TestPerson -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Organization -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Project -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_in_operator_on_non_iterable.User -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_item_frequencies_null_values.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_item_frequencies_on_embedded.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_item_frequencies_with_null_embedded.Data -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_loop_over_invalid_id_does_not_crash.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_nested_queryset_iterator.User -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_cached_queryset.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_dereference.Organization -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_dereference.User -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Member -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Organization -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.User -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_pull_from_nested_embedded.User -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_pull_in_genericembedded_field.Foo -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_queryset_aggregation_framework.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_complex_cycle.Category -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_reverse_delete_rule_nullify.Category -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar.Organization -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar.User -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_decimal.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_embedded.Profile -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_generic_reference_field.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_generic_reference_field.State -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_reference_field.Person -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_reference_field.State -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_scalar_simple.UserDoc -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_set_generic_embedded_documents.Bar -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_set_list_embedded_documents.Author -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_update.BlogPost -name mongoengine/tests/queryset/queryset.py /^ name = StringField()$/;" v class:QuerySetTest.test_update_array_position.Comment -name mongoengine/tests/queryset/queryset.py /^ name = StringField(db_field='doc-name')$/;" v class:QuerySetTest.test_exec_js_field_sub.BlogPost -name mongoengine/tests/queryset/queryset.py /^ name = StringField(max_length=120)$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Comment -name mongoengine/tests/queryset/queryset.py /^ name = StringField(max_length=75, unique=True, required=True)$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Site -name mongoengine/tests/queryset/queryset.py /^ name = StringField(max_length=75, unique=True, required=True)$/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Site -name mongoengine/tests/queryset/queryset.py /^ name = StringField(max_length=75, unique=True, required=True)$/;" v class:QuerySetTest.test_pull_nested.Site -name mongoengine/tests/queryset/queryset.py /^ name = StringField(required=True)$/;" v class:QuerySetTest.test_add_to_set_each.Item -name mongoengine/tests/queryset/queryset.py /^ name = StringField(required=True)$/;" v class:QuerySetTest.test_editting_embedded_objects.BlogTag -name mongoengine/tests/queryset/queryset.py /^ name = StringField(required=True)$/;" v class:QuerySetTest.test_update_one_pop_generic_reference.BlogTag -name mongoengine/tests/queryset/queryset.py /^ name="Barack Obama",$/;" v class:QuerySetTest.test_as_pymongo.User -name mongoengine/tests/queryset/transform.py /^ name = StringField()$/;" v class:TransformTest.test_last_field_name_like_operator.EmbeddedItem -name mongoengine/tests/queryset/transform.py /^ name = StringField()$/;" v class:TransformTest.test_raw_query_and_Q_objects.Foo -name mongoengine/tests/queryset/visitor.py /^ name = StringField()$/;" v class:QTest.setUp.Person -name mongoengine/tests/queryset/visitor.py /^ name = StringField()$/;" v class:QTest.test_empty_q.Person -name mongoengine/tests/queryset/visitor.py /^ name = StringField()$/;" v class:QTest.test_q_merge_queries_edge_case.User -name mongoengine/tests/queryset/visitor.py /^ name = StringField(max_length=40)$/;" v class:QTest.test_multiple_occurence_in_field.Test -name mongoengine/tests/queryset/visitor.py /^ name = StringField(required=True)$/;" v class:QTest.test_chained_q_or_filtering.Post -name mongoengine/tests/test_context_managers.py /^ name = StringField()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_dbref.User -name mongoengine/tests/test_context_managers.py /^ name = StringField()$/;" v class:ContextManagersTest.test_no_dereference_context_manager_object_id.User -name mongoengine/tests/test_context_managers.py /^ name = StringField()$/;" v class:ContextManagersTest.test_switch_collection_context_manager.Group -name mongoengine/tests/test_context_managers.py /^ name = StringField()$/;" v class:ContextManagersTest.test_switch_db_context_manager.Group -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_circular_reference.Person -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_circular_reference.Relation -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_circular_reference_on_self.Person -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_circular_tree_reference.Other -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_circular_tree_reference.Person -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Tag -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_dict_field.UserA -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_dict_field.UserB -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_dict_field.UserC -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_dict_field_no_field_inheritance.UserA -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_document_reload_reference_integrity.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference.UserA -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference.UserB -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference.UserC -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_map_field.UserA -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_map_field.UserB -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_map_field.UserC -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.Group -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.UserA -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.UserB -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_save_doesnt_cause_extra_queries.UserC -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_handle_old_style_references.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_field_complex.UserA -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_field_complex.UserB -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_field_complex.UserC -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_false.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries.Group -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_false_stores_as_type.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries.Group -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_list_of_lists_of_references.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_map_field_reference.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_migrate_references.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_objectid_reference_across_databases.Book -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_objectid_reference_across_databases.User -name mongoengine/tests/test_dereference.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_reference.Employee -name mongoengine/tests/test_dereference.py /^ name = StringField(max_length=250, required=True)$/;" v class:FieldTest.test_dict_in_dbref_instance.Person -name mongoengine/tests/test_dereference.py /^ name = StringField(max_length=250, required=True)$/;" v class:FieldTest.test_multidirectional_lists.Asset -name mongoengine/tests/test_signals.py /^ name = StringField()$/;" v class:SignalTests.setUp.Another -name mongoengine/tests/test_signals.py /^ name = StringField()$/;" v class:SignalTests.setUp.Author -name tests/fields/fields.py /^ name="Wilson Júnior")$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields_on_embedded_documents.Test -name tests/fields/fields.py /^ name = StringField(db_field='$name')$/;" v class:FieldTest.test_db_field_validation.User -name tests/fields/fields.py /^ name = StringField(db_field='name\\0')$/;" v class:FieldTest.test_db_field_validation.User -name tests/fields/fields.py /^ name = StringField(db_field='user.name')$/;" v class:FieldTest.test_db_field_validation.User -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Owner -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.PersonAuto -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields.Product -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Group -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_abstract_reference_base_type.Mother -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_abstract_reference_base_type.Sibling -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_dbref_reference_fields.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_dbref_to_mongo.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_nothing_set.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_set_to_None.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_when_deleting_value.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_drop_abstract_document.AbstractDoc -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance.User -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_inheritance_with_list.Group -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_embedded_document_validation.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document.Car -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Car -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Car -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_generic_reference_is_none.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_inherited_sequencefield.Base -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_list_item_dereference.User -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_map_field_lookup.Log -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_mapfield_numerical_index.Embedded -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_multiple_sequence_fields_on_docs.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_no_inherited_sequencefield.Base -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_object_id_validation.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_objectid_reference_fields.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_embedding.Tree -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_embedding.TreeNode -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_recursive_reference.Employee -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_abstract_class.Sibling -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Sibling -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reference_validation.User -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reverse_list_sorting.Category -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_reverse_list_sorting.CategoryList -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_get_next_value.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_sequence_name.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_field_value_decorator.Person -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_sequence_fields_reload.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_undefined_reference.Company -name tests/fields/fields.py /^ name = StringField()$/;" v class:FieldTest.test_undefined_reference.Product -name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Mineral -name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Vegetal -name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_equality.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal -name tests/fields/fields.py /^ name = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Animal -name tests/fields/fields.py /^ name = StringField(max_length=20)$/;" v class:FieldTest.test_string_validation.Person -name tests/fields/fields.py /^ name = StringField(required=False, unique=True, sparse=True)$/;" v class:FieldTest.test_sparse_field.Doc -name tests/fields/fields.py /^ name = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Author -name tests/fields/fields.py /^ name = StringField(required=True)$/;" v class:FieldTest.test_required_values.Person -name tests/fields/fields.py /^ name='Steve',$/;" v class:FieldTest.test_dbref_to_mongo.Person -name2 mongoengine/tests/document/instance.py /^ name2 = StringField(db_field='name')$/;" v class:InstanceTest.test_duplicate_db_fields_raise_invalid_document_error.Foo -needs_mongodb_v26 mongoengine/tests/utils.py /^def needs_mongodb_v26(func):$/;" f -needs_mongodb_v3 mongoengine/tests/utils.py /^def needs_mongodb_v3(func):$/;" f -new mongoengine/tests/queryset/modify.py /^ new=True)$/;" v class:FindAndModifyTest.test_modify_with_push.BlogPost -new_field mongoengine/tests/fixtures.py /^ new_field = StringField()$/;" v class:NewDocumentPickleTest -new_file mongoengine/fields.py /^ def new_file(self, **kwargs):$/;" m class:GridFSProxy -new_file mongoengine/mongoengine/fields.py /^ def new_file(self, **kwargs):$/;" m class:GridFSProxy -next mongoengine/mongoengine/queryset/base.py /^ def next(self):$/;" m class:BaseQuerySet -next_log mongoengine/tests/fields/fields.py /^ next_log = logs[next_idx]$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -next_log tests/fields/fields.py /^ next_log = logs[next_idx]$/;" v class:FieldTest.test_complexdatetime_usage.LogEntry -nick mongoengine/tests/fields/fields.py /^ nick = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.SubAnimal -nick mongoengine/tests/fields/fields.py /^ nick = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.SubAnimal -nick tests/fields/fields.py /^ nick = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.SubAnimal -nick tests/fields/fields.py /^ nick = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.SubAnimal -no_cache mongoengine/mongoengine/queryset/queryset.py /^ def no_cache(self):$/;" m class:QuerySet -no_dereference mongoengine/mongoengine/context_managers.py /^class no_dereference(object):$/;" c -no_dereference mongoengine/mongoengine/queryset/base.py /^ def no_dereference(self):$/;" m class:BaseQuerySet -no_sub_classes mongoengine/mongoengine/context_managers.py /^class no_sub_classes(object):$/;" c -no_sub_classes mongoengine/mongoengine/queryset/base.py /^ def no_sub_classes(self):$/;" m class:BaseQuerySet -noddy mongoengine/tests/queryset/queryset.py /^ noddy = Noddy()$/;" v class:QuerySetTest.test_no_cache.Noddy -nodes mongoengine/tests/document/instance.py /^ nodes = MapField(ReferenceField(Node, dbref=False))$/;" v class:InstanceTest.test_complex_nesting_document_and_embedded_document.NodesSystem -non_field mongoengine/tests/document/class_methods.py /^ non_field = True$/;" v class:ClassMethodsTest.setUp.Person -non_field mongoengine/tests/document/delta.py /^ non_field = True$/;" v class:DeltaTest.setUp.Person -non_field mongoengine/tests/document/indexes.py /^ non_field = True$/;" v class:IndexesTest.setUp.Person -non_field mongoengine/tests/document/instance.py /^ non_field = True$/;" v class:InstanceTest.setUp.Person -none mongoengine/mongoengine/queryset/base.py /^ def none(self):$/;" m class:BaseQuerySet -not_empty mongoengine/tests/queryset/queryset.py /^ def not_empty(self):$/;" m class:QuerySetTest.test_custom_querysets.CustomQuerySet -not_empty mongoengine/tests/queryset/queryset.py /^ def not_empty(self):$/;" m class:QuerySetTest.test_custom_querysets_inherited.CustomQuerySet -not_empty mongoengine/tests/queryset/queryset.py /^ def not_empty(self):$/;" m class:QuerySetTest.test_custom_querysets_inherited_direct.CustomQuerySet -not_empty mongoengine/tests/queryset/queryset.py /^ def not_empty(self):$/;" m class:QuerySetTest.test_custom_querysets_set_manager_directly.CustomQuerySet -num mongoengine/tests/document/delta.py /^ num = IntField(default=-1)$/;" v class:DeltaTest.test_delta_for_nested_map_fields.Doc -num_posts mongoengine/docs/code/tumblelog.py /^num_posts = Post.objects(tags='mongodb').count()$/;" v -num_visits mongoengine/tests/queryset/queryset.py /^ num_visits = IntField(db_field='visits')$/;" v class:QuerySetTest.test_average_over_db_field.UserVisit -num_visits mongoengine/tests/queryset/queryset.py /^ num_visits = IntField(db_field='visits')$/;" v class:QuerySetTest.test_sum_over_db_field.UserVisit -number mongoengine/tests/document/instance.py /^ number = IntField()$/;" v class:InstanceTest.test_invalid_son.Occurrence -number mongoengine/tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_embedded_document_validation.PersonPreferences -number mongoengine/tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_embedded_document.Dish -number mongoengine/tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Dish -number mongoengine/tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Dish -number mongoengine/tests/fields/fields.py /^ number = IntField(default=0, db_field='i')$/;" v class:FieldTest.test_embedded_db_field.Embedded -number mongoengine/tests/fields/fields.py /^ number = IntField(default=0, db_field='i')$/;" v class:FieldTest.test_embedded_mapfield_db_field.Embedded -number mongoengine/tests/fields/fields.py /^ number = IntField(unique=True)$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.EmbeddedWithUnique -number mongoengine/tests/fields/fields.py /^ number = IntField(unique=True, sparse=True)$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.EmbeddedWithSparseUnique -number mongoengine/tests/fixtures.py /^ number = IntField()$/;" v class:NewDocumentPickleTest -number mongoengine/tests/fixtures.py /^ number = IntField()$/;" v class:PickleDynamicTest -number mongoengine/tests/fixtures.py /^ number = IntField()$/;" v class:PickleSignalsTest -number mongoengine/tests/fixtures.py /^ number = IntField()$/;" v class:PickleTest -number mongoengine/tests/queryset/queryset.py /^ number = IntField()$/;" v class:QuerySetTest.test_repr.Doc -number mongoengine/tests/queryset/queryset.py /^ number = StringField()$/;" v class:QuerySetTest.test_item_frequencies_on_embedded.Phone -number mongoengine/tests/test_dereference.py /^ number = StringField(max_length=250, required=True)$/;" v class:FieldTest.test_dict_in_dbref_instance.Room -number tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_embedded_document_validation.PersonPreferences -number tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_embedded_document.Dish -number tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_embedded_document_choices.Dish -number tests/fields/fields.py /^ number = IntField()$/;" v class:FieldTest.test_generic_list_embedded_document_choices.Dish -number tests/fields/fields.py /^ number = IntField(default=0, db_field='i')$/;" v class:FieldTest.test_embedded_db_field.Embedded -number tests/fields/fields.py /^ number = IntField(default=0, db_field='i')$/;" v class:FieldTest.test_embedded_mapfield_db_field.Embedded -number tests/fields/fields.py /^ number = IntField(unique=True)$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.EmbeddedWithUnique -number tests/fields/fields.py /^ number = IntField(unique=True, sparse=True)$/;" v class:EmbeddedDocumentListFieldTestCase.test_empty_list_embedded_documents_with_unique_field.EmbeddedWithSparseUnique -obj mongoengine/tests/document/indexes.py /^ obj = EmbeddedDocumentField('self')$/;" v class:IndexesTest.test_recursive_embedded_objects_dont_break_indexes.RecursiveObject -object mongoengine/mongoengine/document.py /^ def object(self):$/;" m class:MapReduceDocument -object mongoengine/tests/fields/fields.py /^ object = StringField()$/;" v class:FieldTest.test_map_field_lookup.Action -object tests/fields/fields.py /^ object = StringField()$/;" v class:FieldTest.test_map_field_lookup.Action -objectid_field mongoengine/tests/document/instance.py /^ objectid_field = ObjectIdField(default=bson.ObjectId)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -objectid_field mongoengine/tests/document/json_serialisation.py /^ objectid_field = ObjectIdField(default=ObjectId)$/;" v class:TestJson.test_json_complex.Doc -objectid_field mongoengine/tests/queryset/queryset.py /^ objectid_field = ObjectIdField(default=ObjectId)$/;" v class:QuerySetTest.test_json_complex.Doc -objects mongoengine/tests/queryset/queryset.py /^ def objects(cls, qryset):$/;" m class:QuerySetTest.test_custom_manager.BlogPost -objects mongoengine/tests/queryset/queryset.py /^ def objects(doc_cls, queryset):$/;" m class:QuerySetTest.test_custom_manager_overriding_objects_works.Foo -objects mongoengine/tests/queryset/queryset.py /^ def objects(klass, queryset):$/;" m class:QuerySetTest.test_inherit_objects.Foo -objects mongoengine/tests/queryset/queryset.py /^ def objects(klass, queryset):$/;" m class:QuerySetTest.test_inherit_objects_override.Bar -objects mongoengine/tests/queryset/queryset.py /^ def objects(klass, queryset):$/;" m class:QuerySetTest.test_inherit_objects_override.Foo -objects mongoengine/tests/queryset/queryset.py /^ objects = CustomQuerySetManager()$/;" v class:QuerySetTest.test_custom_querysets_inherited_direct.Base -objects mongoengine/tests/queryset/queryset.py /^ objects = CustomQuerySetManager()$/;" v class:QuerySetTest.test_custom_querysets_set_manager_directly.Post -obs mongoengine/tests/fields/fields.py /^ obs = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData -obs tests/fields/fields.py /^ obs = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData -occurs mongoengine/tests/document/instance.py /^ occurs = ListField(EmbeddedDocumentField(Occurrence), default=list)$/;" v class:InstanceTest.test_invalid_son.Word -oid_info mongoengine/tests/fields/fields.py /^ oid_info = ListField(ObjectIdField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost -oid_info tests/fields/fields.py /^ oid_info = ListField(ObjectIdField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost -on_document_pre_save mongoengine/fields.py /^ def on_document_pre_save(self, sender, document, created, **kwargs):$/;" m class:CachedReferenceField -on_document_pre_save mongoengine/mongoengine/fields.py /^ def on_document_pre_save(self, sender, document, created, **kwargs):$/;" m class:CachedReferenceField -only mongoengine/mongoengine/queryset/base.py /^ def only(self, *fields):$/;" m class:BaseQuerySet -op mongoengine/tests/queryset/queryset.py /^ op = ops[0]$/;" v class:QuerySetTest.test_comment.User -op mongoengine/tests/queryset/queryset.py /^ op = p.db.system.profile.find({"ns":$/;" v class:QuerySetTest.test_bool_with_ordering.Person -op mongoengine/tests/queryset/queryset.py /^ op = q.db.system.profile.find({"ns":$/;" v class:QuerySetTest.test_bool_performance.Person -op mongoengine/tests/queryset/queryset.py /^ op = q.db.system.profile.find({"ns":$/;" v class:QuerySetTest.test_bool_with_ordering.Person -op mongoengine/tests/queryset/queryset.py /^ op = q.db.system.profile.find({"ns":$/;" v class:QuerySetTest.test_bool_with_ordering_from_meta_dict.Person -operation mongoengine/tests/fields/fields.py /^ operation = StringField()$/;" v class:FieldTest.test_map_field_lookup.Action -operation tests/fields/fields.py /^ operation = StringField()$/;" v class:FieldTest.test_map_field_lookup.Action -ops mongoengine/tests/queryset/queryset.py /^ ops = q.get_ops()$/;" v class:QuerySetTest.test_comment.User -order mongoengine/tests/fields/fields.py /^ order = IntField()$/;" v class:FieldTest.test_sorted_list_sorting.Comment -order tests/fields/fields.py /^ order = IntField()$/;" v class:FieldTest.test_sorted_list_sorting.Comment -order_by mongoengine/mongoengine/queryset/base.py /^ def order_by(self, *keys):$/;" m class:BaseQuerySet -ordering mongoengine/tests/fields/fields.py /^ ordering='order')$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost -ordering tests/fields/fields.py /^ ordering='order')$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost -org mongoengine/tests/document/delta.py /^ org = ReferenceField('Organization', required=True)$/;" v class:DeltaTest.test_referenced_object_changed_attributes.User -org mongoengine/tests/queryset/queryset.py /^ org = Organization.objects.get(id=o1.id)$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Project -organization mongoengine/tests/queryset/queryset.py /^ organization = ObjectIdField()$/;" v class:QuerySetTest.test_scalar.User -organization mongoengine/tests/queryset/queryset.py /^ organization = ReferenceField(Organization)$/;" v class:QuerySetTest.test_no_dereference.User -orgs mongoengine/tests/document/instance.py /^ orgs = ListField(ReferenceField('Organization'))$/;" v class:InstanceTest.test_query_count_when_saving.User -other mongoengine/tests/test_dereference.py /^ other = EmbeddedDocumentField(Other, default=lambda: Other())$/;" v class:FieldTest.test_circular_tree_reference.Person -other_field mongoengine/tests/fields/fields.py /^ other_field = StringField()$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Bookmark -other_field tests/fields/fields.py /^ other_field = StringField()$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Bookmark -output mongoengine/tests/queryset/queryset.py /^ output={'reduce': 'family_map', 'db_alias': 'test2'})$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person -output mongoengine/tests/queryset/queryset.py /^ output={'replace': 'family_map', 'db_alias': 'test2'})$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person -owner mongoengine/tests/document/delta.py /^ owner = ReferenceField('Person')$/;" v class:DeltaTest.circular_reference_deltas.Organization -owner mongoengine/tests/document/delta.py /^ owner = ReferenceField('Person', dbref=dbref)$/;" v class:DeltaTest.circular_reference_deltas_2.Organization -owner mongoengine/tests/fields/fields.py /^ owner=Owner(tags=['cool', 'funny'],$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -owner mongoengine/tests/fields/fields.py /^ owner=Owner(tp='u', name="Wilson Júnior")$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence -owner mongoengine/tests/fields/fields.py /^ owner = EmbeddedDocumentField(Owner)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal -owner mongoengine/tests/fields/fields.py /^ owner = EmbeddedDocumentField(Owner)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal -owner mongoengine/tests/queryset/queryset.py /^ owner = ReferenceField(TestPerson)$/;" v class:QuerySetTest.test_update_related_models.TestOrganization -owner mongoengine/tests/queryset/queryset.py /^ owner = GenericReferenceField()$/;" v class:QuerySetTest.test_generic_reference_field_with_only_and_as_pymongo.TestActivity -owner mongoengine/tests/queryset/queryset.py /^ owner = ReferenceField(Person)$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Organization -owner tests/fields/fields.py /^ owner=Owner(tags=['cool', 'funny'],$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -owner tests/fields/fields.py /^ owner=Owner(tp='u', name="Wilson Júnior")$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence -owner tests/fields/fields.py /^ owner = EmbeddedDocumentField(Owner)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal -owner tests/fields/fields.py /^ owner = EmbeddedDocumentField(Owner)$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal -owner_document mongoengine/mongoengine/base/fields.py /^ def owner_document(self):$/;" m class:BaseField -owner_document mongoengine/mongoengine/base/fields.py /^ def owner_document(self, owner_document):$/;" m class:BaseField -owns mongoengine/tests/document/delta.py /^ owns = ListField(ReferenceField('Organization'))$/;" v class:DeltaTest.circular_reference_deltas.Person -owns mongoengine/tests/document/delta.py /^ owns = ListField(ReferenceField('Organization', dbref=dbref))$/;" v class:DeltaTest.circular_reference_deltas_2.Person -owns mongoengine/tests/queryset/queryset.py /^ owns = ListField(ReferenceField('Organization'))$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Person -p mongoengine/tests/fields/fields.py /^ p = Ocurrence(person="test", animal=bad).save()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.BadDoc -p mongoengine/tests/fields/fields.py /^ p = Ocurrence(person="test", animal=bad).save()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.BadDoc -p mongoengine/tests/fields/fields.py /^ p = Ocurrence(person="test", animal=ref).save()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.SubAnimal -p mongoengine/tests/fields/fields.py /^ p = Ocurrence(person="test", animal=ref).save()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.SubAnimal -p mongoengine/tests/fields/fields.py /^ p = Person(name="Person %s" % x)$/;" v class:FieldTest.test_sequence_field_value_decorator.Person -p tests/fields/fields.py /^ p = Ocurrence(person="test", animal=bad).save()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.BadDoc -p tests/fields/fields.py /^ p = Ocurrence(person="test", animal=bad).save()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.BadDoc -p tests/fields/fields.py /^ p = Ocurrence(person="test", animal=ref).save()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.SubAnimal -p tests/fields/fields.py /^ p = Ocurrence(person="test", animal=ref).save()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.SubAnimal -p tests/fields/fields.py /^ p = Person(name="Person %s" % x)$/;" v class:FieldTest.test_sequence_field_value_decorator.Person -page mongoengine/tests/document/instance.py /^ page = EmbeddedDocumentField(Page)$/;" v class:InstanceTest.test_embedded_update.Site -page mongoengine/tests/document/instance.py /^ page = EmbeddedDocumentField(Page)$/;" v class:InstanceTest.test_embedded_update_after_save.Site -page mongoengine/tests/document/instance.py /^ page = EmbeddedDocumentField(Page)$/;" v class:InstanceTest.test_embedded_update_db_field.Site -parameters mongoengine/tests/document/instance.py /^ parameters = MapField(EmbeddedDocumentField(Parameter))$/;" v class:InstanceTest.test_complex_nesting_document_and_embedded_document.Node -parent mongoengine/tests/document/instance.py /^ parent = GenericReferenceField()$/;" v class:InstanceTest.test_save_cascades_generically.Person -parent mongoengine/tests/document/instance.py /^ parent = ReferenceField('self')$/;" v class:InstanceTest.test_save_cascade_kwargs.Person -parent mongoengine/tests/document/instance.py /^ parent = ReferenceField('self')$/;" v class:InstanceTest.test_save_cascade_meta_false.Person -parent mongoengine/tests/document/instance.py /^ parent = ReferenceField('self')$/;" v class:InstanceTest.test_save_cascade_meta_true.Person -parent mongoengine/tests/document/instance.py /^ parent = ReferenceField('self')$/;" v class:InstanceTest.test_save_cascades.Person -parent mongoengine/tests/document/instance.py /^ parent = ReferenceField('self')$/;" v class:InstanceTest.test_save_max_recursion_not_hit.Person -parent mongoengine/tests/fields/fields.py /^ parent = ReferenceField('self')$/;" v class:FieldTest.test_objectid_reference_fields.Person -parent mongoengine/tests/fields/fields.py /^ parent = ReferenceField('self', dbref=False)$/;" v class:FieldTest.test_dbref_to_mongo.Person -parent mongoengine/tests/fields/fields.py /^ parent = ReferenceField('self', dbref=False)$/;" v class:FieldTest.test_objectid_reference_fields.Person -parent mongoengine/tests/fields/fields.py /^ parent = ReferenceField('self', dbref=True)$/;" v class:FieldTest.test_dbref_reference_fields.Person -parent mongoengine/tests/fields/fields.py /^ parent=DBRef('person', 'abcdefghijklmnop')$/;" v class:FieldTest.test_dbref_to_mongo.Person -parent mongoengine/tests/queryset/queryset.py /^ parent = ReferenceField('self', reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_self_referencing.Category -parent mongoengine/tests/test_dereference.py /^ parent = GenericReferenceField(default=None)$/;" v class:FieldTest.test_multidirectional_lists.Asset -parent tests/fields/fields.py /^ parent = ReferenceField('self')$/;" v class:FieldTest.test_objectid_reference_fields.Person -parent tests/fields/fields.py /^ parent = ReferenceField('self', dbref=False)$/;" v class:FieldTest.test_dbref_to_mongo.Person -parent tests/fields/fields.py /^ parent = ReferenceField('self', dbref=False)$/;" v class:FieldTest.test_objectid_reference_fields.Person -parent tests/fields/fields.py /^ parent = ReferenceField('self', dbref=True)$/;" v class:FieldTest.test_dbref_reference_fields.Person -parent tests/fields/fields.py /^ parent=DBRef('person', 'abcdefghijklmnop')$/;" v class:FieldTest.test_dbref_to_mongo.Person -parents mongoengine/tests/queryset/queryset.py /^ parents = ListField(ReferenceField('self'))$/;" v class:QuerySetTest.test_add_to_set_each.Item -parents mongoengine/tests/test_dereference.py /^ parents = ListField(GenericReferenceField())$/;" v class:FieldTest.test_multidirectional_lists.Asset -password mongoengine/tests/document/indexes.py /^ password = StringField()$/;" v class:IndexesTest.test_unique_and_primary.User -password mongoengine/tests/document/indexes.py /^ password = StringField()$/;" v class:IndexesTest.test_unique_and_primary_create.User -password mongoengine/tests/queryset/field_list.py /^ password = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_from_subclasses_docs.User -password_hash mongoengine/tests/queryset/queryset.py /^ password_hash="SomeHash").save()$/;" v class:QuerySetTest.test_as_pymongo_json_limit_fields.User -password_hash mongoengine/tests/queryset/queryset.py /^ password_hash = StringField($/;" v class:QuerySetTest.test_as_pymongo_json_limit_fields.User -password_salt mongoengine/tests/queryset/queryset.py /^ password_salt = StringField($/;" v class:QuerySetTest.test_as_pymongo_json_limit_fields.User -path mongoengine/tests/test_dereference.py /^ path = StringField()$/;" v class:FieldTest.test_multidirectional_lists.Asset -pay mongoengine/tests/queryset/queryset.py /^ pay = EmbeddedDocumentField($/;" v class:QuerySetTest.test_embedded_average.Doc -pay mongoengine/tests/queryset/queryset.py /^ pay = EmbeddedDocumentField(Pay)$/;" v class:QuerySetTest.test_embedded_array_average.Doc -pay mongoengine/tests/queryset/queryset.py /^ pay = EmbeddedDocumentField(Pay)$/;" v class:QuerySetTest.test_embedded_array_sum.Doc -pay mongoengine/tests/queryset/queryset.py /^ pay = EmbeddedDocumentField(Pay)$/;" v class:QuerySetTest.test_embedded_sum.Doc -people mongoengine/tests/queryset/queryset.py /^ people = Person.objects$/;" v class:QuerySetTest.test_cached_queryset.Person -people mongoengine/tests/queryset/queryset.py /^ people = Person.objects.no_cache()$/;" v class:QuerySetTest.test_no_cached_queryset.Person -person mongoengine/tests/fields/fields.py /^ person = Person.objects.create()$/;" v class:FieldTest.test_decimal_storage.Person -person mongoengine/tests/fields/fields.py /^ person = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest -person mongoengine/tests/fields/fields.py /^ person = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Ocorrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Ocurrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Ocurrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Ocurrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Ocurrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Ocurrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Ocurrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Ocurrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Ocurrence -person mongoengine/tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Ocurrence -person mongoengine/tests/test_dereference.py /^ person = ReferenceField('Person')$/;" v class:FieldTest.test_circular_reference.Relation -person tests/fields/fields.py /^ person = Person.objects.create()$/;" v class:FieldTest.test_decimal_storage.Person -person tests/fields/fields.py /^ person = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.SocialTest -person tests/fields/fields.py /^ person = CachedReferenceField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData -person tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Ocorrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Ocorrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Ocorrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Ocorrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Ocurrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Ocurrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Ocurrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Ocurrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Ocurrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Ocurrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Ocurrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Ocurrence -person tests/fields/fields.py /^ person = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Ocurrence -person_meta mongoengine/tests/queryset/queryset.py /^ person_meta = EmbeddedDocumentField(PersonMeta)$/;" v class:QuerySetTest.setUp.Person -peter mongoengine/tests/test_dereference.py /^ peter = Employee.objects.with_id(peter.id)$/;" v class:FieldTest.test_recursive_reference.Employee -peter mongoengine/tests/test_dereference.py /^ peter = Employee.objects.with_id(peter.id).select_related()$/;" v class:FieldTest.test_recursive_reference.Employee -phone mongoengine/tests/document/delta.py /^ phone = StringField()$/;" v class:DeltaTest.test_delta_for_nested_map_fields.UInfoDocument -phone mongoengine/tests/queryset/queryset.py /^ phone = EmbeddedDocumentField(Phone)$/;" v class:QuerySetTest.test_item_frequencies_on_embedded.Person -photo mongoengine/tests/fields/file_tests.py /^ photo = FileField()$/;" v class:FileTest.test_file_saving.Animal -photo mongoengine/tests/fixtures.py /^ photo = FileField()$/;" v class:NewDocumentPickleTest -photo mongoengine/tests/fixtures.py /^ photo = FileField()$/;" v class:PickleTest -photos mongoengine/tests/fields/file_tests.py /^ photos = ListField(FileField())$/;" v class:FileTest.test_complex_field_filefield.Animal -picture mongoengine/tests/document/instance.py /^ picture = FileField()$/;" v class:InstanceTest.test_save_max_recursion_not_hit_with_file_field.Foo -pk mongoengine/mongoengine/base/datastructures.py /^ def pk(self):$/;" m class:LazyReference -pk mongoengine/mongoengine/document.py /^ def pk(self):$/;" m class:Document -pk mongoengine/mongoengine/document.py /^ def pk(self, value):$/;" m class:Document -playlist mongoengine/tests/test_dereference.py /^ playlist = Playlist.objects.first().select_related()$/;" v class:FieldTest.test_select_related_follows_embedded_referencefields.Playlist -point mongoengine/tests/fields/geo.py /^ point = PointField()$/;" v class:GeoFieldTest.test_indexes_2dsphere.Event -point mongoengine/tests/fields/geo.py /^ point = PointField()$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Venue -poly mongoengine/tests/queryset/geo.py /^ poly = PolygonField()$/;" v class:GeoQueriesTest.test_geojson_PolygonField.Location -poly mongoengine/tests/queryset/geo.py /^ poly = PolygonField()$/;" v class:GeoQueriesTest.test_polygon.Road -poly mongoengine/tests/queryset/transform.py /^ poly = PolygonField()$/;" v class:TransformTest.test_geojson_PolygonField.Location -polygon mongoengine/tests/fields/geo.py /^ polygon = PolygonField()$/;" v class:GeoFieldTest.test_indexes_2dsphere.Event -polygon mongoengine/tests/fields/geo.py /^ polygon = PolygonField()$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Venue -pop mongoengine/mongoengine/base/datastructures.py /^ def pop(self, *args, **kwargs):$/;" m class:BaseDict -pop mongoengine/mongoengine/base/datastructures.py /^ def pop(self, *args, **kwargs):$/;" m class:BaseList -pop mongoengine/mongoengine/base/datastructures.py /^ def pop(self, key, default=None):$/;" m class:StrictDict -popitem mongoengine/mongoengine/base/datastructures.py /^ def popitem(self, *args, **kwargs):$/;" m class:BaseDict -position mongoengine/tests/document/instance.py /^ position = StringField()$/;" v class:InstanceTest.test_save_embedded_document.EmployeeDetails -position mongoengine/tests/document/instance.py /^ position = StringField()$/;" v class:InstanceTest.test_updating_an_embedded_document.EmployeeDetails -post mongoengine/tests/document/instance.py /^ post = ReferenceField(BlogPost, reverse_delete_rule=CASCADE)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_recurs.Comment -post1 mongoengine/docs/code/tumblelog.py /^post1 = TextPost(title='Fun with MongoEngine', author=john)$/;" v -post1 mongoengine/tests/document/indexes.py /^ post1 = BlogPost(title='test1', slug='test')$/;" v class:IndexesTest.test_indexes_after_database_drop.BlogPost -post1 mongoengine/tests/queryset/queryset.py /^ post1 = Post(comments=[comment1, comment2])$/;" v class:QuerySetTest.test_bulk_insert.Blog -post2 mongoengine/docs/code/tumblelog.py /^post2 = LinkPost(title='MongoEngine Documentation', author=john)$/;" v -post2 mongoengine/tests/document/indexes.py /^ post2 = BlogPost(title='test2', slug='test')$/;" v class:IndexesTest.test_indexes_after_database_drop.BlogPost -post2 mongoengine/tests/queryset/queryset.py /^ post2 = Post(comments=[comment2, comment2])$/;" v class:QuerySetTest.test_bulk_insert.Blog -post_bulk_insert mongoengine/mongoengine/signals.py /^post_bulk_insert = _signals.signal('post_bulk_insert')$/;" v -post_bulk_insert mongoengine/tests/test_signals.py /^ def post_bulk_insert(cls, sender, documents, **kwargs):$/;" m class:SignalTests.setUp.Author -post_bulk_insert mongoengine/tests/test_signals.py /^ def post_bulk_insert(cls, sender, documents, **kwargs):$/;" m class:SignalTests.setUp.Post -post_delete mongoengine/mongoengine/signals.py /^post_delete = _signals.signal('post_delete')$/;" v -post_delete mongoengine/tests/fixtures.py /^ def post_delete(self, sender, document, **kwargs):$/;" m class:PickleSignalsTest -post_delete mongoengine/tests/test_signals.py /^ def post_delete(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Another -post_delete mongoengine/tests/test_signals.py /^ def post_delete(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author -post_init mongoengine/mongoengine/signals.py /^post_init = _signals.signal('post_init')$/;" v -post_init mongoengine/tests/test_signals.py /^ def post_init(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author -post_save mongoengine/mongoengine/signals.py /^post_save = _signals.signal('post_save')$/;" v -post_save mongoengine/tests/fixtures.py /^ def post_save(self, sender, document, created, **kwargs):$/;" m class:PickleSignalsTest -post_save mongoengine/tests/test_signals.py /^ def post_save(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author -post_save mongoengine/tests/test_signals.py /^ def post_save(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.ExplicitId -postables mongoengine/tests/queryset/visitor.py /^ postables = ListField(EmbeddedDocumentField(Post))$/;" v class:QTest.test_chained_q_or_filtering.Item -posts mongoengine/tests/queryset/queryset.py /^ posts = ListField(EmbeddedDocumentField(Post))$/;" v class:QuerySetTest.test_bulk_insert.Blog -posts mongoengine/tests/queryset/queryset.py /^ posts = ListField(EmbeddedDocumentField(Post))$/;" v class:QuerySetTest.test_find_array_position.Blog -posts mongoengine/tests/queryset/queryset.py /^ posts = ListField(EmbeddedDocumentField(Post))$/;" v class:QuerySetTest.test_update_array_position.Blog -posts mongoengine/tests/test_dereference.py /^ posts = ListField(EmbeddedDocumentField(Post))$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Page -power mongoengine/tests/fields/fields.py /^ power = IntField()$/;" v class:FieldTest.test_embedded_document_inheritance.PowerUser -power tests/fields/fields.py /^ power = IntField()$/;" v class:FieldTest.test_embedded_document_inheritance.PowerUser -pre_bulk_insert mongoengine/mongoengine/signals.py /^pre_bulk_insert = _signals.signal('pre_bulk_insert')$/;" v -pre_bulk_insert mongoengine/tests/test_signals.py /^ def pre_bulk_insert(cls, sender, documents, **kwargs):$/;" m class:SignalTests.setUp.Author -pre_bulk_insert mongoengine/tests/test_signals.py /^ def pre_bulk_insert(cls, sender, documents, **kwargs):$/;" m class:SignalTests.setUp.Post -pre_delete mongoengine/mongoengine/signals.py /^pre_delete = _signals.signal('pre_delete')$/;" v -pre_delete mongoengine/tests/document/instance.py /^ def pre_delete(cls, sender, document, **kwargs):$/;" m class:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal.BlogPost -pre_delete mongoengine/tests/test_signals.py /^ def pre_delete(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Another -pre_delete mongoengine/tests/test_signals.py /^ def pre_delete(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author -pre_init mongoengine/mongoengine/signals.py /^pre_init = _signals.signal('pre_init')$/;" v -pre_init mongoengine/tests/test_signals.py /^ def pre_init(cls, sender, document, *args, **kwargs):$/;" m class:SignalTests.setUp.Author -pre_save mongoengine/mongoengine/signals.py /^pre_save = _signals.signal('pre_save')$/;" v -pre_save mongoengine/tests/test_signals.py /^ def pre_save(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author -pre_save_post_validation mongoengine/mongoengine/signals.py /^pre_save_post_validation = _signals.signal('pre_save_post_validation')$/;" v -pre_save_post_validation mongoengine/tests/test_signals.py /^ def pre_save_post_validation(cls, sender, document, **kwargs):$/;" m class:SignalTests.setUp.Author -preferences mongoengine/tests/fields/fields.py /^ preferences = EmbeddedDocumentField(PersonPreferences)$/;" v class:FieldTest.test_embedded_document_validation.Person -preferences tests/fields/fields.py /^ preferences = EmbeddedDocumentField(PersonPreferences)$/;" v class:FieldTest.test_embedded_document_validation.Person -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:CachedReferenceField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ComplexDateTimeField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DateTimeField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DecimalField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DictField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DynamicField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:EmbeddedDocumentField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:FloatField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:GenericEmbeddedDocumentField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:GenericReferenceField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:IntField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:LazyReferenceField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ListField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:LongField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ReferenceField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:SequenceField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:StringField -prepare_query_value mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:UUIDField -prepare_query_value mongoengine/mongoengine/base/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:BaseField -prepare_query_value mongoengine/mongoengine/base/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ComplexBaseField -prepare_query_value mongoengine/mongoengine/base/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ObjectIdField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:CachedReferenceField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ComplexDateTimeField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DateTimeField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DecimalField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DictField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:DynamicField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:EmbeddedDocumentField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:FloatField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:GenericEmbeddedDocumentField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:GenericReferenceField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:IntField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:LazyReferenceField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ListField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:LongField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:ReferenceField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:SequenceField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:StringField -prepare_query_value mongoengine/mongoengine/fields.py /^ def prepare_query_value(self, op, value):$/;" m class:UUIDField -price mongoengine/tests/queryset/queryset.py /^ price = DecimalField()$/;" v class:QuerySetTest.test_as_pymongo.User -price mongoengine/tests/queryset/queryset.py /^ price=Decimal('2.22'),$/;" v class:QuerySetTest.test_as_pymongo.User -primary_key mongoengine/tests/queryset/queryset.py /^ primary_key=True)$/;" v class:QuerySetTest.test_map_reduce_custom_output.Family -primary_key mongoengine/tests/queryset/queryset.py /^ primary_key=True)$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person -product_id mongoengine/tests/queryset/queryset.py /^ product_id = IntField(db_field='pid')$/;" v class:QuerySetTest.test_distinct_handles_db_field.Product -products mongoengine/tests/fields/fields.py /^ products = ListField(CachedReferenceField(Product, fields=['name']))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields.Basket -products tests/fields/fields.py /^ products = ListField(CachedReferenceField(Product, fields=['name']))$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_push_with_fields.Basket -profile mongoengine/tests/queryset/queryset.py /^ profile = EmbeddedDocumentField(Profile)$/;" v class:QuerySetTest.test_scalar_embedded.Person -project mongoengine/docs/conf.py /^project = u'MongoEngine'$/;" v -projects mongoengine/tests/queryset/queryset.py /^ projects = ListField(ReferenceField('Project'))$/;" v class:QuerySetTest.test_get_changed_fields_query_count.Person -provider_ids mongoengine/tests/document/indexes.py /^ provider_ids = DictField()$/;" v class:IndexesTest.test_sparse_compound_indexes.MyDoc -provider_ids mongoengine/tests/document/indexes.py /^ provider_ids = DictField()$/;" v class:IndexesTest.test_string_indexes.MyDoc -proxy_class mongoengine/fields.py /^ proxy_class = GridFSProxy$/;" v class:FileField -proxy_class mongoengine/fields.py /^ proxy_class = ImageGridFsProxy$/;" v class:ImageField -proxy_class mongoengine/mongoengine/fields.py /^ proxy_class = GridFSProxy$/;" v class:FileField -proxy_class mongoengine/mongoengine/fields.py /^ proxy_class = ImageGridFsProxy$/;" v class:ImageField -pub_date mongoengine/tests/document/instance.py /^ pub_date = DateTimeField()$/;" v class:InstanceTest.test_document_clean.TestDocument -publish_date mongoengine/tests/queryset/visitor.py /^ publish_date = DateTimeField()$/;" v class:QTest.test_q.BlogPost -published mongoengine/tests/document/instance.py /^ published = BooleanField(default=True)$/;" v class:InstanceTest.test_save_only_changed_fields_recursive.Comment -published mongoengine/tests/queryset/queryset.py /^ def published(doc_cls, queryset):$/;" m class:QuerySetTest.test_filter_chaining.BlogPost -published mongoengine/tests/queryset/queryset.py /^ published = BooleanField()$/;" v class:QuerySetTest.test_exec_js_query.BlogPost -published mongoengine/tests/queryset/queryset.py /^ published = CustomQuerySetManager()$/;" v class:QuerySetTest.test_custom_querysets_managers_directly.Post -published mongoengine/tests/queryset/visitor.py /^ published = BooleanField()$/;" v class:QTest.test_q.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField()$/;" v class:QuerySetTest.test_clear_ordering.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField()$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField()$/;" v class:QuerySetTest.test_no_ordering_for_get.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField()$/;" v class:QuerySetTest.test_ordering.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField(required=False)$/;" v class:QuerySetTest.test_order_by_list.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date = DateTimeField(required=False)$/;" v class:QuerySetTest.test_order_by_optional.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=None$/;" v class:QuerySetTest.test_order_by_optional.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 5, 0, 0, 0)$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 5, 0, 0, 0)$/;" v class:QuerySetTest.test_order_by_optional.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 5, 0, 0, 0)$/;" v class:QuerySetTest.test_ordering.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 6, 0, 0, 0)$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 6, 0, 0, 0)$/;" v class:QuerySetTest.test_order_by_list.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 6, 0, 0, 0)$/;" v class:QuerySetTest.test_order_by_optional.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 6, 0, 0, 0)$/;" v class:QuerySetTest.test_ordering.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 7, 0, 0, 0)$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 7, 0, 0, 0)$/;" v class:QuerySetTest.test_order_by_list.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 7, 0, 0, 0)$/;" v class:QuerySetTest.test_order_by_optional.BlogPost -published_date mongoengine/tests/queryset/queryset.py /^ published_date=datetime.datetime(2010, 1, 7, 0, 0, 0)$/;" v class:QuerySetTest.test_ordering.BlogPost -published_date__lt mongoengine/tests/queryset/queryset.py /^ published_date__lt=datetime.datetime(2010, 1, 7, 0, 0, 0))$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -pull__collaborators__helpful__user mongoengine/tests/queryset/queryset.py /^ pull__collaborators__helpful__user='Esteban')$/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Site -pull__collaborators__unhelpful mongoengine/tests/queryset/queryset.py /^ pull__collaborators__unhelpful={'name': 'Frank'})$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Site -pull__collaborators__unhelpful mongoengine/tests/queryset/queryset.py /^ pull__collaborators__unhelpful={'user': 'Frank'})$/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Site -pull_all__collaborators__helpful__name mongoengine/tests/queryset/queryset.py /^ pull_all__collaborators__helpful__name=['Ross'])$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Site -pull_all__collaborators__helpful__user mongoengine/tests/queryset/queryset.py /^ pull_all__collaborators__helpful__user=['Ross'])$/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Site -pull_all__collaborators__user mongoengine/tests/queryset/queryset.py /^ pull_all__collaborators__user=['Ross'])$/;" v class:QuerySetTest.test_pull_nested.Site -pull_all__tags mongoengine/tests/queryset/queryset.py /^ pull_all__tags=["mongodb", "code"])$/;" v class:QuerySetTest.test_update_push_and_pull_add_to_set.BlogPost -push__tags__0 mongoengine/tests/queryset/modify.py /^ push__tags__0='python',$/;" v class:FindAndModifyTest.test_modify_with_push.BlogPost -push__tags__1 mongoengine/tests/queryset/modify.py /^ push__tags__1=['go', 'rust'],$/;" v class:FindAndModifyTest.test_modify_with_push.BlogPost -push_all__tags mongoengine/tests/queryset/queryset.py /^ push_all__tags=["mongodb", "code"])$/;" v class:QuerySetTest.test_update_push_and_pull_add_to_set.BlogPost -put mongoengine/fields.py /^ def put(self, file_obj, **kwargs):$/;" m class:GridFSProxy -put mongoengine/fields.py /^ def put(self, file_obj, **kwargs):$/;" m class:ImageGridFsProxy -put mongoengine/mongoengine/fields.py /^ def put(self, file_obj, **kwargs):$/;" m class:GridFSProxy -put mongoengine/mongoengine/fields.py /^ def put(self, file_obj, **kwargs):$/;" m class:ImageGridFsProxy -pygments_style mongoengine/docs/conf.py /^pygments_style = 'sphinx'$/;" v -qs mongoengine/tests/queryset/queryset.py /^ qs = BlogPost.objects.filter(title='whatever').order_by('published_date')$/;" v class:QuerySetTest.test_clear_ordering.BlogPost -quantity mongoengine/tests/document/instance.py /^ quantity = IntField()$/;" v class:InstanceTest.test_object_mixins.Foo -query mongoengine/mongoengine/queryset/transform.py /^def query(_doc_cls=None, **kwargs):$/;" f -query_counter mongoengine/mongoengine/context_managers.py /^class query_counter(object):$/;" c -queryset_class mongoengine/tests/queryset/queryset.py /^ queryset_class = CustomQuerySet$/;" v class:QuerySetTest.test_custom_querysets_inherited_direct.CustomQuerySetManager -queryset_class mongoengine/tests/queryset/queryset.py /^ queryset_class = CustomQuerySet$/;" v class:QuerySetTest.test_custom_querysets_set_manager_directly.CustomQuerySetManager -queryset_manager mongoengine/mongoengine/queryset/manager.py /^def queryset_manager(func):$/;" f -rank mongoengine/tests/document/indexes.py /^ rank = EmbeddedDocumentField(Rank, required=False)$/;" v class:IndexesTest.test_embedded_document_index_meta.Person -rank mongoengine/tests/document/instance.py /^ def rank(self):$/;" m class:InstanceTest.test_db_embedded_doc_field_load.Person -rank mongoengine/tests/document/instance.py /^ def rank(self):$/;" m class:InstanceTest.test_db_field_load.Person -rank_ mongoengine/tests/document/instance.py /^ rank_ = EmbeddedDocumentField(Rank,$/;" v class:InstanceTest.test_db_embedded_doc_field_load.Person -rating mongoengine/tests/queryset/queryset.py /^ rating = DecimalField()$/;" v class:QuerySetTest.test_scalar_decimal.Person -read mongoengine/fields.py /^ def read(self, size=-1):$/;" m class:GridFSProxy -read mongoengine/mongoengine/fields.py /^ def read(self, size=-1):$/;" m class:GridFSProxy -read_preference mongoengine/mongoengine/queryset/base.py /^ def read_preference(self, read_preference):$/;" m class:BaseQuerySet -recursive mongoengine/tests/fields/fields.py /^ recursive = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbed -recursive mongoengine/tests/fields/fields.py /^ recursive = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent -recursive mongoengine/tests/fields/fields.py /^ recursive = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbed -recursive mongoengine/tests/fields/fields.py /^ recursive = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent -recursive tests/fields/fields.py /^ recursive = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbed -recursive tests/fields/fields.py /^ recursive = DictField()$/;" v class:FieldTest.test_dictfield_dump_document.ToEmbedParent -recursive tests/fields/fields.py /^ recursive = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbed -recursive tests/fields/fields.py /^ recursive = DynamicField()$/;" v class:FieldTest.test_dynamicfield_dump_document.ToEmbedParent -recursive_obj mongoengine/tests/document/indexes.py /^ recursive_obj = EmbeddedDocumentField(RecursiveObject)$/;" v class:IndexesTest.test_recursive_embedded_objects_dont_break_indexes.RecursiveDocument -reduce_f mongoengine/tests/queryset/queryset.py /^ reduce_f=reduce_f,$/;" v class:QuerySetTest.test_map_reduce_custom_output.Person -ref mongoengine/tests/document/instance.py /^ ref = ReferenceField(Test)$/;" v class:InstanceTest.test_embedded_document_equality.Embedded -ref mongoengine/tests/fields/fields.py /^ ref = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_filter_by_dbref.Doc -ref mongoengine/tests/fields/fields.py /^ ref = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_filter_by_objectid.Doc -ref mongoengine/tests/fields/fields.py /^ ref = ReferenceField(Foo)$/;" v class:FieldTest.test_reference_miss.Bar -ref mongoengine/tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_invalid_operators.BlogPost -ref mongoengine/tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost -ref mongoengine/tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_manipulative_operators.BlogPost -ref mongoengine/tests/queryset/queryset.py /^ ref = ReferenceField(A)$/;" v class:QuerySetTest.test_chaining.B -ref mongoengine/tests/test_context_managers.py /^ ref = ReferenceField(User, dbref=False)$/;" v class:ContextManagersTest.test_no_dereference_context_manager_object_id.Group -ref mongoengine/tests/test_context_managers.py /^ ref = ReferenceField(User, dbref=True)$/;" v class:ContextManagersTest.test_no_dereference_context_manager_dbref.Group -ref tests/fields/fields.py /^ ref = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_filter_by_dbref.Doc -ref tests/fields/fields.py /^ ref = GenericReferenceField()$/;" v class:FieldTest.test_generic_reference_filter_by_objectid.Doc -ref tests/fields/fields.py /^ ref = ReferenceField(Foo)$/;" v class:FieldTest.test_reference_miss.Bar -ref tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_invalid_operators.BlogPost -ref tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost -ref tests/fields/fields.py /^ ref = StringField()$/;" v class:FieldTest.test_list_field_manipulative_operators.BlogPost -ref_id mongoengine/tests/document/indexes.py /^ ref_id = StringField()$/;" v class:IndexesTest.test_hashed_indexes.Book -reference mongoengine/tests/document/validation.py /^ reference = ReferenceField('self')$/;" v class:ValidatorErrorTest.test_parent_reference_in_child_document.Parent -reference mongoengine/tests/document/validation.py /^ reference = ReferenceField('self')$/;" v class:ValidatorErrorTest.test_parent_reference_set_as_attribute_in_child_document.Parent -reference mongoengine/tests/queryset/queryset.py /^ reference = ReferenceField('self', reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_complex_cycle.Dummy -reference mongoengine/tests/queryset/queryset.py /^ reference = ReferenceField('self', reverse_delete_rule=CASCADE)$/;" v class:QuerySetTest.test_reverse_delete_rule_cascade_cycle.Dummy -reference_field mongoengine/tests/document/instance.py /^ reference_field = ReferenceField(Simple, default=lambda:$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -reference_field mongoengine/tests/document/json_serialisation.py /^ reference_field = ReferenceField(Simple, default=lambda:$/;" v class:TestJson.test_json_complex.Doc -reference_field mongoengine/tests/queryset/queryset.py /^ reference_field = ReferenceField($/;" v class:QuerySetTest.test_json_complex.Doc -register_connection mongoengine/mongoengine/connection.py /^def register_connection(alias, db=None, name=None, host=None, port=None,$/;" f -register_delete_rule mongoengine/mongoengine/document.py /^ def register_delete_rule(cls, document_cls, field_name, rule):$/;" m class:Document -relations mongoengine/tests/test_dereference.py /^ relations = ListField(EmbeddedDocumentField('Relation'))$/;" v class:FieldTest.test_circular_reference.Person -relations mongoengine/tests/test_dereference.py /^ relations = ListField(ReferenceField('self'))$/;" v class:FieldTest.test_circular_reference_on_self.Person -release mongoengine/docs/conf.py /^release = mongoengine.get_version()$/;" v -reload mongoengine/mongoengine/document.py /^ def reload(self, *args, **kwargs):$/;" m class:EmbeddedDocument -reload mongoengine/mongoengine/document.py /^ def reload(self, *fields, **kwargs):$/;" m class:Document -remove mongoengine/mongoengine/base/datastructures.py /^ def remove(self, *args, **kwargs):$/;" m class:BaseList -replace mongoengine/fields.py /^ def replace(self, file_obj, **kwargs):$/;" m class:GridFSProxy -replace mongoengine/mongoengine/fields.py /^ def replace(self, file_obj, **kwargs):$/;" m class:GridFSProxy -required mongoengine/tests/document/instance.py /^ required=False,$/;" v class:InstanceTest.test_db_embedded_doc_field_load.Person -required mongoengine/tests/document/instance.py /^ required=True)$/;" v class:InstanceTest.test_embedded_update.Page -required mongoengine/tests/document/instance.py /^ required=True)$/;" v class:InstanceTest.test_embedded_update_after_save.Page -required mongoengine/tests/document/instance.py /^ required=True)$/;" v class:InstanceTest.test_embedded_update_db_field.Page -required mongoengine/tests/document/instance.py /^ required=True)$/;" v class:InstanceTest.test_list_search_by_embedded.Comment -reset mongoengine/mongoengine/queryset/field_list.py /^ def reset(self):$/;" m class:QueryFieldList -reset_post mongoengine/tests/fields/fields.py /^ def reset_post():$/;" f function:FieldTest.test_list_field_manipulative_operators -reset_post tests/fields/fields.py /^ def reset_post():$/;" f function:FieldTest.test_list_field_manipulative_operators -reverse mongoengine/mongoengine/base/datastructures.py /^ def reverse(self, *args, **kwargs):$/;" m class:BaseList -reverse_delete_rule mongoengine/tests/document/instance.py /^ reverse_delete_rule=NULLIFY))$/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Blog -reverse_delete_rule mongoengine/tests/queryset/queryset.py /^ reverse_delete_rule=PULL))$/;" v class:QuerySetTest.test_reverse_delete_rule_pull.BlogPost -reverse_delete_rule mongoengine/tests/queryset/queryset.py /^ reverse_delete_rule=PULL))$/;" v class:QuerySetTest.test_reverse_delete_rule_pull_on_abstract_documents.AbstractBlogPost -review_queue mongoengine/tests/document/instance.py /^ review_queue = IntField(default=0)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_triggers_pre_delete_signal.Editor -reviewer mongoengine/tests/document/instance.py /^ reviewer = ReferenceField(User, reverse_delete_rule=NULLIFY)$/;" v class:InstanceTest.test_reverse_delete_rule_with_custom_id_field.Book -reviewer mongoengine/tests/document/instance.py /^ reviewer = ReferenceField(self.Person, reverse_delete_rule=NULLIFY)$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify.BlogPost -reviewer mongoengine/tests/document/instance.py /^ reviewer = ReferenceField(self.Person, reverse_delete_rule=NULLIFY)$/;" v class:InstanceTest.test_reverse_delete_rule_with_document_inheritance.BlogPost -reviewers mongoengine/tests/document/instance.py /^ reviewers = DictField($/;" v class:InstanceTest.test_invalid_reverse_delete_rule_raise_errors.Blog -reviewers mongoengine/tests/document/instance.py /^ reviewers = ListField(ReferenceField($/;" v class:InstanceTest.test_reverse_delete_rule_cascade_and_nullify_complex_field.BlogPost -rewind mongoengine/mongoengine/queryset/base.py /^ def rewind(self):$/;" m class:BaseQuerySet -roles mongoengine/tests/document/delta.py /^ roles = MapField(field=EmbeddedDocumentField(EmbeddedRole))$/;" v class:DeltaTest.test_delta_for_nested_map_fields.EmbeddedUser -rolist mongoengine/tests/document/delta.py /^ rolist = ListField(field=EmbeddedDocumentField(EmbeddedRole))$/;" v class:DeltaTest.test_delta_for_nested_map_fields.EmbeddedUser -s mongoengine/tests/document/instance.py /^ s = Stats()$/;" v class:InstanceTest.test_reference_inheritance.CompareStats -s mongoengine/tests/queryset/queryset.py /^ s = StringField()$/;" v class:QuerySetTest.test_batch_size.A -s mongoengine/tests/queryset/queryset.py /^ s = StringField()$/;" v class:QuerySetTest.test_chaining.A -s mongoengine/tests/queryset/queryset.py /^ s = StringField()$/;" v class:QuerySetTest.test_none.A -salary mongoengine/tests/document/dynamic.py /^ salary = IntField()$/;" v class:DynamicTest.test_inheritance.Employee -salary mongoengine/tests/document/inheritance.py /^ salary = IntField()$/;" v class:InheritanceTest.test_inheritance_meta_data.Employee -salary mongoengine/tests/document/inheritance.py /^ salary = IntField()$/;" v class:InheritanceTest.test_inheritance_to_mongo_keys.Employee -salary mongoengine/tests/document/instance.py /^ salary = IntField()$/;" v class:InstanceTest.test_embedded_document_to_mongo.Employee -salary mongoengine/tests/document/instance.py /^ salary = IntField()$/;" v class:InstanceTest.test_save_embedded_document.Employee -salary mongoengine/tests/document/instance.py /^ salary = IntField()$/;" v class:InstanceTest.test_updating_an_embedded_document.Employee -salary mongoengine/tests/fields/fields.py /^ salary = DecimalField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.PersonAuto -salary mongoengine/tests/queryset/field_list.py /^ salary = IntField(db_field='wage')$/;" v class:OnlyExcludeAllTest.test_only.Employee -salary tests/fields/fields.py /^ salary = DecimalField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_decimal.PersonAuto -save mongoengine/mongoengine/base/datastructures.py /^ def save(self, *args, **kwargs):$/;" m class:EmbeddedDocumentList -save mongoengine/mongoengine/document.py /^ def save(self, *args, **kwargs):$/;" m class:EmbeddedDocument -save mongoengine/mongoengine/document.py /^ def save(self, force_insert=False, validate=True, clean=True,$/;" m class:Document -save mongoengine/tests/document/instance.py /^ def save(self, *args, **kwargs):$/;" m class:InstanceTest.test_complex_nesting_document_and_embedded_document.NodesSystem -save_id mongoengine/tests/document/instance.py /^ save_id = UUIDField()$/;" v class:InstanceTest.test_save_atomicity_condition.Widget -scalar mongoengine/mongoengine/queryset/base.py /^ def scalar(self, *fields):$/;" m class:BaseQuerySet -scope mongoengine/tests/queryset/queryset.py /^ scope=scope)$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -score mongoengine/tests/queryset/queryset.py /^ score = IntField()$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.Vote -search_text mongoengine/mongoengine/queryset/base.py /^ def search_text(self, text, language=None):$/;" m class:BaseQuerySet -select_related mongoengine/mongoengine/document.py /^ def select_related(self, max_depth=1):$/;" m class:Document -select_related mongoengine/mongoengine/queryset/base.py /^ def select_related(self, max_depth=1):$/;" m class:BaseQuerySet -send mongoengine/mongoengine/signals.py /^ send = lambda *a, **kw: None # noqa$/;" v class:_FakeSignal -sender mongoengine/tests/queryset/field_list.py /^ sender = StringField()$/;" v class:OnlyExcludeAllTest.test_all_fields.Email -sender mongoengine/tests/queryset/field_list.py /^ sender = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email -sequence_field mongoengine/tests/document/instance.py /^ sequence_field = SequenceField()$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -sequence_field mongoengine/tests/document/json_serialisation.py /^ sequence_field = SequenceField()$/;" v class:TestJson.test_json_complex.Doc -sequence_field mongoengine/tests/queryset/queryset.py /^ sequence_field = SequenceField()$/;" v class:QuerySetTest.test_json_complex.Doc -setUp mongoengine/tests/all_warnings/__init__.py /^ def setUp(self):$/;" m class:AllWarnings -setUp mongoengine/tests/document/class_methods.py /^ def setUp(self):$/;" m class:ClassMethodsTest -setUp mongoengine/tests/document/delta.py /^ def setUp(self):$/;" m class:DeltaTest -setUp mongoengine/tests/document/dynamic.py /^ def setUp(self):$/;" m class:DynamicTest -setUp mongoengine/tests/document/indexes.py /^ def setUp(self):$/;" m class:IndexesTest -setUp mongoengine/tests/document/inheritance.py /^ def setUp(self):$/;" m class:InheritanceTest -setUp mongoengine/tests/document/instance.py /^ def setUp(self):$/;" m class:InstanceTest -setUp mongoengine/tests/document/json_serialisation.py /^ def setUp(self):$/;" m class:TestJson -setUp mongoengine/tests/document/validation.py /^ def setUp(self):$/;" m class:ValidatorErrorTest -setUp mongoengine/tests/fields/fields.py /^ def setUp(self):$/;" m class:EmbeddedDocumentListFieldTestCase -setUp mongoengine/tests/fields/geo.py /^ def setUp(self):$/;" m class:GeoFieldTest -setUp mongoengine/tests/queryset/field_list.py /^ def setUp(self):$/;" m class:OnlyExcludeAllTest -setUp mongoengine/tests/queryset/modify.py /^ def setUp(self):$/;" m class:FindAndModifyTest -setUp mongoengine/tests/queryset/pickable.py /^ def setUp(self):$/;" m class:TestQuerysetPickable -setUp mongoengine/tests/queryset/queryset.py /^ def setUp(self):$/;" m class:QuerySetTest -setUp mongoengine/tests/queryset/transform.py /^ def setUp(self):$/;" m class:TransformTest -setUp mongoengine/tests/queryset/visitor.py /^ def setUp(self):$/;" m class:QTest -setUp mongoengine/tests/test_datastructures.py /^ def setUp(self):$/;" m class:TestStrictDict -setUp mongoengine/tests/test_replicaset_connection.py /^ def setUp(self):$/;" m class:ConnectionTest -setUp mongoengine/tests/test_signals.py /^ def setUp(self):$/;" m class:SignalTests -setUp tests/fields/fields.py /^ def setUp(self):$/;" m class:EmbeddedDocumentListFieldTestCase -setUpClass mongoengine/tests/test_dereference.py /^ def setUpClass(cls):$/;" m class:FieldTest -setUpClass mongoengine/tests/utils.py /^ def setUpClass(cls):$/;" m class:MongoDBTestCase -set__authors mongoengine/tests/queryset/queryset.py /^ set__authors=[Author(name="Harry"),$/;" v class:QuerySetTest.test_set_list_embedded_documents.Message -set__authors__S mongoengine/tests/queryset/queryset.py /^ set__authors__S=Author(name="Ross"))$/;" v class:QuerySetTest.test_set_list_embedded_documents.Message -set__bar mongoengine/tests/queryset/queryset.py /^ set__bar=Bar(name='test'), upsert=True)$/;" v class:QuerySetTest.test_set_generic_embedded_documents.User -set__comments__S__votes mongoengine/tests/queryset/queryset.py /^ set__comments__S__votes=Vote(score=4))$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.BlogPost -set__comp_dt_fld mongoengine/tests/fields/fields.py /^ set__comp_dt_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -set__comp_dt_fld tests/fields/fields.py /^ set__comp_dt_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -set__flt_fld mongoengine/tests/fields/fields.py /^ set__flt_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -set__flt_fld tests/fields/fields.py /^ set__flt_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -set__int_fld mongoengine/tests/fields/fields.py /^ set__int_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -set__int_fld tests/fields/fields.py /^ set__int_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -set__mapping mongoengine/tests/fields/fields.py /^ set__mapping={"someint": IntegerSetting(value=10)})$/;" v class:FieldTest.test_dictfield_complex.Simple -set__mapping tests/fields/fields.py /^ set__mapping={"someint": IntegerSetting(value=10)})$/;" v class:FieldTest.test_dictfield_complex.Simple -set__mapping__2__list__1 mongoengine/tests/fields/fields.py /^ set__mapping__2__list__1=StringSetting(value='Boo'))$/;" v class:FieldTest.test_list_field_complex.Simple -set__mapping__2__list__1 tests/fields/fields.py /^ set__mapping__2__list__1=StringSetting(value='Boo'))$/;" v class:FieldTest.test_list_field_complex.Simple -set__mapping__nested_dict__list__1 mongoengine/tests/fields/fields.py /^ set__mapping__nested_dict__list__1=StringSetting(value='Boo'))$/;" v class:FieldTest.test_dictfield_complex.Simple -set__mapping__nested_dict__list__1 tests/fields/fields.py /^ set__mapping__nested_dict__list__1=StringSetting(value='Boo'))$/;" v class:FieldTest.test_dictfield_complex.Simple -set__members mongoengine/tests/queryset/queryset.py /^ set__members={"John": Member(gender="F", age=14)})$/;" v class:QuerySetTest.test_mapfield_update.Club -set__members mongoengine/tests/queryset/queryset.py /^ set__members={"John": {'gender': 'F', 'age': 14}})$/;" v class:QuerySetTest.test_dictfield_update.Club -set__posts__1__comments__1__name mongoengine/tests/queryset/queryset.py /^ set__posts__1__comments__1__name='testc')$/;" v class:QuerySetTest.test_update_array_position.Blog -set__str_fld mongoengine/tests/fields/fields.py /^ set__str_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -set__str_fld tests/fields/fields.py /^ set__str_fld=None,$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -set_next_value mongoengine/fields.py /^ def set_next_value(self, value):$/;" m class:SequenceField -set_next_value mongoengine/mongoengine/fields.py /^ def set_next_value(self, value):$/;" m class:SequenceField -setdefault mongoengine/mongoengine/base/datastructures.py /^ def setdefault(self, *args, **kwargs):$/;" m class:BaseDict -shape mongoengine/tests/queryset/queryset.py /^ shape = StringField()$/;" v class:QuerySetTest.test_elem_match.Foo -shard_1 mongoengine/tests/document/indexes.py /^ shard_1 = StringField()$/;" v class:IndexesTest.test_compound_index_underscore_cls_not_overwritten.TestDoc -sibling mongoengine/tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_abstract_reference_base_type.Brother -sibling mongoengine/tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_reference_abstract_class.Brother -sibling mongoengine/tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Brother -sibling tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_abstract_reference_base_type.Brother -sibling tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_reference_abstract_class.Brother -sibling tests/fields/fields.py /^ sibling = ReferenceField(Sibling)$/;" v class:FieldTest.test_reference_class_with_abstract_parent.Brother -signal mongoengine/mongoengine/signals.py /^ def signal(self, name, doc=None):$/;" m class:Namespace -signal_output mongoengine/tests/test_signals.py /^signal_output = []$/;" v -signals_available mongoengine/mongoengine/signals.py /^ signals_available = True$/;" v -signals_available mongoengine/mongoengine/signals.py /^signals_available = False$/;" v -size mongoengine/fields.py /^ def size(self):$/;" m class:ImageGridFsProxy -size mongoengine/mongoengine/fields.py /^ def size(self):$/;" m class:ImageGridFsProxy -size mongoengine/tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_accept_possible_value.Shirt -size mongoengine/tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_allow_no_value.Shirt -size mongoengine/tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_reject_unknown_value.Shirt -size mongoengine/tests/fields/fields.py /^ size = StringField(choices={'M', 'L'})$/;" v class:FieldTest.test_choices_allow_using_sets_as_choices.Shirt -size mongoengine/tests/fields/fields.py /^ size = StringField(max_length=3, choices=($/;" v class:FieldTest.test_choices_get_field_display.Shirt -size mongoengine/tests/fields/fields.py /^ size = StringField(max_length=3, choices=SIZES)$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt -size mongoengine/tests/fields/fields.py /^ size = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt -size mongoengine/tests/fields/fields.py /^ size = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_validation.Shirt -size mongoengine/tests/queryset/queryset.py /^ size = ReferenceField(Size)$/;" v class:QuerySetTest.test_can_have_field_same_name_as_query_operator.Example -size tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_accept_possible_value.Shirt -size tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_allow_no_value.Shirt -size tests/fields/fields.py /^ size = StringField(choices=('S', 'M'))$/;" v class:FieldTest.test_choices_validation_reject_unknown_value.Shirt -size tests/fields/fields.py /^ size = StringField(choices={'M', 'L'})$/;" v class:FieldTest.test_choices_allow_using_sets_as_choices.Shirt -size tests/fields/fields.py /^ size = StringField(max_length=3, choices=($/;" v class:FieldTest.test_choices_get_field_display.Shirt -size tests/fields/fields.py /^ size = StringField(max_length=3, choices=SIZES)$/;" v class:FieldTest.test_simple_choices_validation_invalid_value.Shirt -size tests/fields/fields.py /^ size = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt -size tests/fields/fields.py /^ size = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_validation.Shirt -skip mongoengine/mongoengine/queryset/base.py /^ def skip(self, n):$/;" m class:BaseQuerySet -skip_pymongo3 mongoengine/tests/utils.py /^def skip_pymongo3(f):$/;" f -slave_okay mongoengine/mongoengine/queryset/base.py /^ def slave_okay(self, enabled):$/;" m class:BaseQuerySet -slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique=True)$/;" v class:IndexesTest.test_indexes_after_database_drop.BlogPost -slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique=True)$/;" v class:IndexesTest.test_unique.BlogPost -slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique=True)$/;" v class:IndexesTest.test_unique_embedded_document.SubDocument -slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique=True)$/;" v class:IndexesTest.test_unique_embedded_document_in_list.SubDocument -slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique=True)$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.SubDocument -slug mongoengine/tests/document/indexes.py /^ slug = StringField(unique_with='date.year')$/;" v class:IndexesTest.test_unique_with.BlogPost -slug mongoengine/tests/document/instance.py /^ slug = StringField()$/;" v class:InstanceTest.test_push_nested_list.BlogPost -slug mongoengine/tests/document/instance.py /^ slug = StringField()$/;" v class:InstanceTest.test_push_with_position.BlogPost -slug mongoengine/tests/queryset/queryset.py /^ slug = StringField()$/;" v class:QuerySetTest.test_editting_embedded_objects.BlogPost -slug mongoengine/tests/queryset/queryset.py /^ slug = StringField()$/;" v class:QuerySetTest.test_update_one_pop_generic_reference.BlogPost -slug mongoengine/tests/queryset/queryset.py /^ slug = StringField()$/;" v class:QuerySetTest.test_update_push_and_pull_add_to_set.BlogPost -slug mongoengine/tests/queryset/queryset.py /^ slug = StringField()$/;" v class:QuerySetTest.test_update_push_list_of_list.BlogPost -slug mongoengine/tests/queryset/queryset.py /^ slug = StringField()$/;" v class:QuerySetTest.test_update_push_with_position.BlogPost -snapshot mongoengine/mongoengine/queryset/base.py /^ def snapshot(self, enabled):$/;" m class:BaseQuerySet -some mongoengine/tests/queryset/field_list.py /^ some = BooleanField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.VariousData -some_long mongoengine/tests/fields/fields.py /^ some_long = LongField()$/;" v class:FieldTest.test_long_field_is_considered_as_int64.TestLongFieldConsideredAsInt64 -some_long tests/fields/fields.py /^ some_long = LongField()$/;" v class:FieldTest.test_long_field_is_considered_as_int64.TestLongFieldConsideredAsInt64 -song mongoengine/tests/test_dereference.py /^ song = ReferenceField("Song")$/;" v class:FieldTest.test_select_related_follows_embedded_referencefields.PlaylistItem -songs mongoengine/tests/test_dereference.py /^ songs = [item.song for item in playlist.items]$/;" v class:FieldTest.test_select_related_follows_embedded_referencefields.Playlist -sort mongoengine/mongoengine/base/datastructures.py /^ def sort(self, *args, **kwargs):$/;" m class:BaseList -sorted_list_field mongoengine/tests/document/instance.py /^ sorted_list_field = SortedListField(IntField(),$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -sorted_list_field mongoengine/tests/document/json_serialisation.py /^ sorted_list_field = SortedListField(IntField(),$/;" v class:TestJson.test_json_complex.Doc -sorted_list_field mongoengine/tests/queryset/queryset.py /^ sorted_list_field = SortedListField(IntField(),$/;" v class:QuerySetTest.test_json_complex.Doc -source_suffix mongoengine/docs/conf.py /^source_suffix = '.rst'$/;" v -staffs_with_position mongoengine/tests/test_dereference.py /^ staffs_with_position = ListField(DictField())$/;" v class:FieldTest.test_dict_in_dbref_instance.Room -start_listener mongoengine/fields.py /^ def start_listener(self):$/;" m class:CachedReferenceField -start_listener mongoengine/mongoengine/fields.py /^ def start_listener(self):$/;" m class:CachedReferenceField -state mongoengine/tests/queryset/queryset.py /^ state = GenericReferenceField()$/;" v class:QuerySetTest.test_scalar_generic_reference_field.Person -state mongoengine/tests/queryset/queryset.py /^ state = ReferenceField(State)$/;" v class:QuerySetTest.test_scalar_reference_field.Person -stats mongoengine/tests/document/instance.py /^ stats = ListField(ReferenceField(Stats))$/;" v class:InstanceTest.test_reference_inheritance.CompareStats -status mongoengine/tests/document/instance.py /^ status = StringField()$/;" v class:InstanceTest.test_document_clean.TestDocument -status mongoengine/tests/document/instance.py /^ status = StringField()$/;" v class:InstanceTest.test_document_embedded_clean.TestDocument -stem mongoengine/tests/document/instance.py /^ stem = StringField()$/;" v class:InstanceTest.test_invalid_son.Word -stored mongoengine/tests/fields/fields.py /^ stored = LogEntry(date=datetime.datetime(*values)).to_mongo()['date']$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry -stored tests/fields/fields.py /^ stored = LogEntry(date=datetime.datetime(*values)).to_mongo()['date']$/;" v class:FieldTest.test_complexdatetime_storage.LogEntry -str_f mongoengine/tests/queryset/queryset.py /^ str_f = StringField()$/;" v class:QuerySetTest.test_update_validate.Doc -str_f mongoengine/tests/queryset/queryset.py /^ str_f = StringField()$/;" v class:QuerySetTest.test_update_validate.EmDoc -str_fld mongoengine/tests/document/instance.py /^ str_fld = StringField(null=True)$/;" v class:InstanceTest.test_null_field.User -str_fld mongoengine/tests/fields/fields.py /^ str_fld = StringField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -str_fld mongoengine/tests/fields/fields.py /^ str_fld = StringField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields -str_fld tests/fields/fields.py /^ str_fld = StringField()$/;" v class:FieldTest.test_not_required_handles_none_in_update.HandleNoneFields -str_fld tests/fields/fields.py /^ str_fld = StringField(required=True)$/;" v class:FieldTest.test_not_required_handles_none_from_database.HandleNoneFields -strict_dict_class mongoengine/tests/test_datastructures.py /^ def strict_dict_class(self, *args, **kwargs):$/;" m class:TestStrictDict -string mongoengine/tests/document/instance.py /^ string = StringField()$/;" v class:InstanceTest.test_embedded_document_complex_instance.Embedded -string mongoengine/tests/document/instance.py /^ string = StringField()$/;" v class:InstanceTest.test_embedded_document_instance.Embedded -string mongoengine/tests/document/instance.py /^ string = StringField(db_field='s')$/;" v class:InstanceTest.test_embedded_document_complex_instance_no_use_db_field.Embedded -string mongoengine/tests/document/json_serialisation.py /^ string = StringField()$/;" v class:TestJson.test_json_simple.Doc -string mongoengine/tests/document/json_serialisation.py /^ string = StringField()$/;" v class:TestJson.test_json_simple.Embedded -string mongoengine/tests/document/json_serialisation.py /^ string = StringField(db_field='s')$/;" v class:TestJson.test_json_names.Doc -string mongoengine/tests/document/json_serialisation.py /^ string = StringField(db_field='s')$/;" v class:TestJson.test_json_names.Embedded -string mongoengine/tests/fixtures.py /^ string = StringField(choices=(('One', '1'), ('Two', '2')))$/;" v class:NewDocumentPickleTest -string mongoengine/tests/fixtures.py /^ string = StringField(choices=(('One', '1'), ('Two', '2')))$/;" v class:PickleSignalsTest -string mongoengine/tests/fixtures.py /^ string = StringField(choices=(('One', '1'), ('Two', '2')))$/;" v class:PickleTest -string mongoengine/tests/queryset/queryset.py /^ string = StringField()$/;" v class:QuerySetTest.test_json_simple.Doc -string mongoengine/tests/queryset/queryset.py /^ string = StringField()$/;" v class:QuerySetTest.test_json_simple.Embedded -string_field mongoengine/tests/document/delta.py /^ string_field = StringField()$/;" v class:DeltaTest.delta.Doc -string_field mongoengine/tests/document/delta.py /^ string_field = StringField()$/;" v class:DeltaTest.delta_recursive.Doc -string_field mongoengine/tests/document/delta.py /^ string_field = StringField()$/;" v class:DeltaTest.delta_recursive.Embedded -string_field mongoengine/tests/document/delta.py /^ string_field = StringField(db_field='db_string_field')$/;" v class:DeltaTest.delta_db_field.Doc -string_field mongoengine/tests/document/delta.py /^ string_field = StringField(db_field='db_string_field')$/;" v class:DeltaTest.delta_recursive_db_field.Doc -string_field mongoengine/tests/document/delta.py /^ string_field = StringField(db_field='db_string_field')$/;" v class:DeltaTest.delta_recursive_db_field.Embedded -string_field mongoengine/tests/document/instance.py /^ string_field = StringField(default='1')$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -string_field mongoengine/tests/document/json_serialisation.py /^ string_field = StringField(default='1')$/;" v class:TestJson.test_json_complex.Doc -string_field mongoengine/tests/queryset/queryset.py /^ string_field = StringField(default='1')$/;" v class:QuerySetTest.test_json_complex.Doc -string_value mongoengine/tests/fields/fields.py /^ string_value = DecimalField(precision=4, force_string=True)$/;" v class:FieldTest.test_decimal_storage.Person -string_value tests/fields/fields.py /^ string_value = DecimalField(precision=4, force_string=True)$/;" v class:FieldTest.test_decimal_storage.Person -style mongoengine/tests/fields/fields.py /^ style = StringField(max_length=3, choices=($/;" v class:FieldTest.test_choices_get_field_display.Shirt -style mongoengine/tests/fields/fields.py /^ style = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt -style tests/fields/fields.py /^ style = StringField(max_length=3, choices=($/;" v class:FieldTest.test_choices_get_field_display.Shirt -style tests/fields/fields.py /^ style = StringField(max_length=3,$/;" v class:FieldTest.test_simple_choices_get_field_display.Shirt -sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2009, slug="test"))$/;" v class:IndexesTest.test_unique_embedded_document.BlogPost -sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2009, slug="test"))$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost -sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2009, slug='test-1'))$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost -sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2010, slug='another-slug'))$/;" v class:IndexesTest.test_unique_embedded_document.BlogPost -sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2010, slug='another-slug'))$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost -sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2010, slug='test'))$/;" v class:IndexesTest.test_unique_embedded_document.BlogPost -sub mongoengine/tests/document/indexes.py /^ sub=SubDocument(year=2010, slug='test'))$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost -sub mongoengine/tests/document/indexes.py /^ sub = EmbeddedDocumentField(SubDocument)$/;" v class:IndexesTest.test_unique_embedded_document.BlogPost -sub mongoengine/tests/document/indexes.py /^ sub = EmbeddedDocumentField(SubDocument)$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost -sub mongoengine/tests/document/instance.py /^ sub = UserSubscription(user=u1.pk, feed=f1.pk)$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription -sub mongoengine/tests/document/instance.py /^ sub = UserSubscription(user=user, feed=feed)$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription -sub mongoengine/tests/document/instance.py /^ sub = UserSubscription.objects.first()$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription -subclasses_and_unique_keys_works mongoengine/tests/document/instance.py /^ def subclasses_and_unique_keys_works(self):$/;" m class:InstanceTest -subject mongoengine/tests/queryset/field_list.py /^ subject = StringField()$/;" v class:OnlyExcludeAllTest.test_all_fields.Email -subject mongoengine/tests/queryset/field_list.py /^ subject = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email -submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=10)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=13)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=2)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=4)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=5)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -submitted mongoengine/tests/queryset/queryset.py /^ submitted=now - datetime.timedelta(hours=6)).save()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -submitted mongoengine/tests/queryset/queryset.py /^ submitted = DateTimeField(db_field='sTime')$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -subs mongoengine/tests/document/delta.py /^ subs = MapField(EmbeddedDocumentField(EmbeddedDoc))$/;" v class:DeltaTest.test_lower_level_mark_as_changed.MyDoc -subs mongoengine/tests/document/delta.py /^ subs = MapField(EmbeddedDocumentField(EmbeddedDoc))$/;" v class:DeltaTest.test_upper_level_mark_as_changed.MyDoc -subs mongoengine/tests/document/delta.py /^ subs = MapField(MapField(EmbeddedDocumentField(EmbeddedDoc)))$/;" v class:DeltaTest.test_nested_nested_fields_mark_as_changed.MyDoc -subs mongoengine/tests/document/indexes.py /^ subs = ListField(EmbeddedDocumentField(SubDocument))$/;" v class:IndexesTest.test_unique_embedded_document_in_list.BlogPost -sum mongoengine/mongoengine/queryset/base.py /^ def sum(self, field):$/;" m class:BaseQuerySet -superphylum mongoengine/tests/document/instance.py /^ superphylum = EmbeddedDocumentField(SuperPhylum)$/;" v class:InstanceTest.test_reload_sharded_nested.Animal -superphylum mongoengine/tests/document/instance.py /^ superphylum = StringField()$/;" v class:InstanceTest.test_reload_sharded.Animal -switch_collection mongoengine/mongoengine/context_managers.py /^class switch_collection(object):$/;" c -switch_collection mongoengine/mongoengine/document.py /^ def switch_collection(self, collection_name, keep_created=True):$/;" m class:Document -switch_db mongoengine/mongoengine/context_managers.py /^class switch_db(object):$/;" c -switch_db mongoengine/mongoengine/document.py /^ def switch_db(self, db_alias, keep_created=True):$/;" m class:Document -sync_all mongoengine/fields.py /^ def sync_all(self):$/;" m class:CachedReferenceField -sync_all mongoengine/mongoengine/fields.py /^ def sync_all(self):$/;" m class:CachedReferenceField -t mongoengine/benchmark.py /^ t = timeit.Timer(stmt=stmt, setup=setup)$/;" v -t mongoengine/tests/fields/file_tests.py /^ t = TestImage()$/;" v class:FileTest.test_image_field.TestImage -t mongoengine/tests/queryset/queryset.py /^ t = Number(n=i)$/;" v class:QuerySetTest.test_clone.Number -t mongoengine/tests/queryset/queryset.py /^ t = Number2(n=i)$/;" v class:QuerySetTest.test_using.Number2 -t mongoengine/tests/queryset/visitor.py /^ t = TestDoc(x=i)$/;" v class:QTest.test_q_clone.TestDoc -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_equality.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal -tag mongoengine/tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Animal -tag mongoengine/tests/queryset/queryset.py /^ tag = StringField()$/;" v class:QuerySetTest.test_item_frequencies_with_null_embedded.Extra -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_field_get_and_save.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:CachedReferenceFieldTest.test_cached_reference_fields.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_bad_set.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_embedded.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_not_set.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_set.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_simple.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_bad_set.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_embedded.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_equality.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_fetch_invalid_ref.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_not_set.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_passthrough.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_set.Animal -tag tests/fields/fields.py /^ tag = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_simple.Animal -tag_list mongoengine/tests/document/class_methods.py /^ tag_list = ListField(StringField())$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPostWithTags -tag_list mongoengine/tests/document/class_methods.py /^ tag_list = ListField(StringField())$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPostWithTags -tags mongoengine/docs/code/tumblelog.py /^ tags = ListField(StringField(max_length=30))$/;" v class:Post -tags mongoengine/tests/document/class_methods.py /^ tags = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes.BlogPost -tags mongoengine/tests/document/class_methods.py /^ tags = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPostWithTags -tags mongoengine/tests/document/class_methods.py /^ tags = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPostWithTags -tags mongoengine/tests/document/class_methods.py /^ tags = StringField()$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPostWithTags -tags mongoengine/tests/document/indexes.py /^ tags=[Tag(name="about"), Tag(name="time")])$/;" v class:IndexesTest.test_list_embedded_document_index.BlogPost -tags mongoengine/tests/document/indexes.py /^ tags = ListField(EmbeddedDocumentField(Tag))$/;" v class:IndexesTest.test_list_embedded_document_index.BlogPost -tags mongoengine/tests/document/indexes.py /^ tags = ListField(StringField())$/;" v class:IndexesTest._index_test.BlogPost -tags mongoengine/tests/document/indexes.py /^ tags = ListField(StringField())$/;" v class:IndexesTest._index_test_inheritance.BlogPost -tags mongoengine/tests/document/indexes.py /^ tags = ListField(StringField())$/;" v class:IndexesTest.test_dictionary_indexes.BlogPost -tags mongoengine/tests/document/indexes.py /^ tags = ListField(StringField())$/;" v class:IndexesTest.test_hint.BlogPost -tags mongoengine/tests/document/indexes.py /^ tags = [("tag %i" % n) for n in range(0, i % 2)]$/;" v class:IndexesTest.test_hint.BlogPost -tags mongoengine/tests/document/instance.py /^ tags = ListField()$/;" v class:InstanceTest.test_push_nested_list.BlogPost -tags mongoengine/tests/document/instance.py /^ tags = ListField(StringField())$/;" v class:InstanceTest.test_modify_with_positional_push.BlogPost -tags mongoengine/tests/document/instance.py /^ tags = ListField(StringField())$/;" v class:InstanceTest.test_push_with_position.BlogPost -tags mongoengine/tests/document/instance.py /^ tags = ListField(StringField())$/;" v class:InstanceTest.test_save_list.BlogPost -tags mongoengine/tests/fields/fields.py /^ tags = ListField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData -tags mongoengine/tests/fields/fields.py /^ tags = ListField(StringField())$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Owner -tags mongoengine/tests/fields/fields.py /^ tags = ListField(StringField())$/;" v class:FieldTest.test_list_validation.BlogPost -tags mongoengine/tests/fields/fields.py /^ tags = SortedListField(StringField())$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost -tags mongoengine/tests/queryset/modify.py /^ tags = ListField(StringField())$/;" v class:FindAndModifyTest.test_modify_with_push.BlogPost -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField()$/;" v class:QuerySetTest.test_update_push_list_of_list.BlogPost -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(EmbeddedDocumentField(BlogTag), required=True)$/;" v class:QuerySetTest.test_editting_embedded_objects.BlogPost -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(ReferenceField(BlogTag), required=True)$/;" v class:QuerySetTest.test_update_one_pop_generic_reference.BlogPost -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_bulk_insert.Blog -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_custom_manager.BlogPost -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_find_array_position.Blog -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_map_reduce_with_custom_object_ids.BlogPost -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_update.BlogPost -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_update_array_position.Blog -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_update_push_and_pull_add_to_set.BlogPost -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_update_push_with_position.BlogPost -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField())$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Post -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField(), db_field='blogTags')$/;" v class:QuerySetTest.test_item_frequencies.BlogPost -tags mongoengine/tests/queryset/queryset.py /^ tags = ListField(StringField(), db_field='post-tag-list')$/;" v class:QuerySetTest.test_map_reduce.BlogPost -tags mongoengine/tests/queryset/visitor.py /^ tags = ListField(StringField())$/;" v class:QTest.test_q_lists.BlogPost -tags mongoengine/tests/test_dereference.py /^ tags = ListField(ReferenceField("Tag", dbref=True))$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Page -tags mongoengine/tests/test_dereference.py /^ tags = ListField(ReferenceField("Tag", dbref=True))$/;" v class:FieldTest.test_dereferencing_embedded_listfield_referencefield.Post -tags tests/fields/fields.py /^ tags = ListField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_reference.SocialData -tags tests/fields/fields.py /^ tags = ListField(StringField())$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_list_fields.Owner -tags tests/fields/fields.py /^ tags = ListField(StringField())$/;" v class:FieldTest.test_list_validation.BlogPost -tags tests/fields/fields.py /^ tags = SortedListField(StringField())$/;" v class:FieldTest.test_sorted_list_sorting.BlogPost -tearDown mongoengine/tests/all_warnings/__init__.py /^ def tearDown(self):$/;" m class:AllWarnings -tearDown mongoengine/tests/document/class_methods.py /^ def tearDown(self):$/;" m class:ClassMethodsTest -tearDown mongoengine/tests/document/delta.py /^ def tearDown(self):$/;" m class:DeltaTest -tearDown mongoengine/tests/document/indexes.py /^ def tearDown(self):$/;" m class:IndexesTest -tearDown mongoengine/tests/document/inheritance.py /^ def tearDown(self):$/;" m class:InheritanceTest -tearDown mongoengine/tests/document/instance.py /^ def tearDown(self):$/;" m class:InstanceTest -tearDown mongoengine/tests/fields/file_tests.py /^ def tearDown(self):$/;" m class:FileTest -tearDown mongoengine/tests/queryset/queryset.py /^ def tearDown(self):$/;" m class:QuerySetTest -tearDown mongoengine/tests/test_connection.py /^ def tearDown(self):$/;" m class:ConnectionTest -tearDown mongoengine/tests/test_replicaset_connection.py /^ def tearDown(self):$/;" m class:ConnectionTest -tearDown mongoengine/tests/test_signals.py /^ def tearDown(self):$/;" m class:SignalTests -tearDownClass mongoengine/tests/test_dereference.py /^ def tearDownClass(cls):$/;" m class:FieldTest -tearDownClass mongoengine/tests/utils.py /^ def tearDownClass(cls):$/;" m class:MongoDBTestCase -templates_path mongoengine/docs/conf.py /^templates_path = ['_templates']$/;" v -term mongoengine/tests/document/indexes.py /^ term = StringField(required=True)$/;" v class:IndexesTest.test_compound_key_embedded.CompoundKey -test mongoengine/tests/queryset/queryset.py /^ test = DictField()$/;" v class:QuerySetTest.test_dictfield_key_looks_like_a_digit.MyDoc -test mongoengine/tests/queryset/queryset.py /^ test = StringField()$/;" v class:QuerySetTest.test_upsert_includes_cls.Test -test2 mongoengine/tests/document/instance.py /^ test2 = ReferenceField('Test2')$/;" v class:InstanceTest.test_dbref_equality.Test -test3 mongoengine/tests/document/instance.py /^ test3 = ReferenceField('Test3')$/;" v class:InstanceTest.test_dbref_equality.Test -test_2dsphere_geo_within_box mongoengine/tests/queryset/geo.py /^ def test_2dsphere_geo_within_box(self):$/;" m class:GeoQueriesTest -test_2dsphere_geo_within_center mongoengine/tests/queryset/geo.py /^ def test_2dsphere_geo_within_center(self):$/;" m class:GeoQueriesTest -test_2dsphere_geo_within_polygon mongoengine/tests/queryset/geo.py /^ def test_2dsphere_geo_within_polygon(self):$/;" m class:GeoQueriesTest -test_2dsphere_linestring_sets_correctly mongoengine/tests/queryset/geo.py /^ def test_2dsphere_linestring_sets_correctly(self):$/;" m class:GeoQueriesTest -test_2dsphere_near mongoengine/tests/queryset/geo.py /^ def test_2dsphere_near(self):$/;" m class:GeoQueriesTest -test_2dsphere_near_and_max_distance mongoengine/tests/queryset/geo.py /^ def test_2dsphere_near_and_max_distance(self):$/;" m class:GeoQueriesTest -test_2dsphere_near_and_min_max_distance mongoengine/tests/queryset/geo.py /^ def test_2dsphere_near_and_min_max_distance(self):$/;" m class:GeoQueriesTest -test_2dsphere_point_embedded mongoengine/tests/queryset/geo.py /^ def test_2dsphere_point_embedded(self):$/;" m class:GeoQueriesTest -test_2dsphere_point_sets_correctly mongoengine/tests/queryset/geo.py /^ def test_2dsphere_point_sets_correctly(self):$/;" m class:GeoQueriesTest -test_abstract_document_creation_does_not_fail mongoengine/tests/document/inheritance.py /^ def test_abstract_document_creation_does_not_fail(self):$/;" m class:InheritanceTest -test_abstract_documents mongoengine/tests/document/inheritance.py /^ def test_abstract_documents(self):$/;" m class:InheritanceTest -test_abstract_embedded_documents mongoengine/tests/document/inheritance.py /^ def test_abstract_embedded_documents(self):$/;" m class:InheritanceTest -test_abstract_handle_ids_in_metaclass_properly mongoengine/tests/document/inheritance.py /^ def test_abstract_handle_ids_in_metaclass_properly(self):$/;" m class:InheritanceTest -test_abstract_index_inheritance mongoengine/tests/document/indexes.py /^ def test_abstract_index_inheritance(self):$/;" m class:IndexesTest -test_abstract_reference_base_type mongoengine/tests/fields/fields.py /^ def test_abstract_reference_base_type(self):$/;" m class:FieldTest -test_abstract_reference_base_type tests/fields/fields.py /^ def test_abstract_reference_base_type(self):$/;" m class:FieldTest -test_add_to_set_each mongoengine/tests/queryset/queryset.py /^ def test_add_to_set_each(self):$/;" m class:QuerySetTest -test_all_fields mongoengine/tests/queryset/field_list.py /^ def test_all_fields(self):$/;" m class:OnlyExcludeAllTest -test_allow_inheritance mongoengine/tests/document/inheritance.py /^ def test_allow_inheritance(self):$/;" m class:InheritanceTest -test_allow_inheritance_abstract_document mongoengine/tests/document/inheritance.py /^ def test_allow_inheritance_abstract_document(self):$/;" m class:InheritanceTest -test_allow_inheritance_embedded_document mongoengine/tests/document/inheritance.py /^ def test_allow_inheritance_embedded_document(self):$/;" m class:InheritanceTest -test_always_include mongoengine/tests/queryset/field_list.py /^ def test_always_include(self):$/;" m class:QueryFieldListTest -test_and_combination mongoengine/tests/queryset/visitor.py /^ def test_and_combination(self):$/;" m class:QTest -test_and_or_combination mongoengine/tests/queryset/visitor.py /^ def test_and_or_combination(self):$/;" m class:QTest -test_array_average mongoengine/tests/queryset/queryset.py /^ def test_array_average(self):$/;" m class:QuerySetTest -test_array_sum mongoengine/tests/queryset/queryset.py /^ def test_array_sum(self):$/;" m class:QuerySetTest -test_as_pymongo mongoengine/tests/queryset/queryset.py /^ def test_as_pymongo(self):$/;" m class:QuerySetTest -test_as_pymongo_json_limit_fields mongoengine/tests/queryset/queryset.py /^ def test_as_pymongo_json_limit_fields(self):$/;" m class:QuerySetTest -test_aspymongo_with_only mongoengine/tests/queryset/geo.py /^ def test_aspymongo_with_only(self):$/;" m class:GeoQueriesTest -test_assertions mongoengine/tests/queryset/queryset.py /^ def test_assertions(f):$/;" f function:QuerySetTest.test_item_frequencies -test_assertions mongoengine/tests/queryset/queryset.py /^ def test_assertions(f):$/;" f function:QuerySetTest.test_item_frequencies_on_embedded -test_atomic_update_dict_field mongoengine/tests/fields/fields.py /^ def test_atomic_update_dict_field(self):$/;" m class:FieldTest -test_atomic_update_dict_field tests/fields/fields.py /^ def test_atomic_update_dict_field(self):$/;" m class:FieldTest -test_auto_id_not_set_if_specific_in_parent_class mongoengine/tests/document/inheritance.py /^ def test_auto_id_not_set_if_specific_in_parent_class(self):$/;" m class:InheritanceTest -test_auto_id_vs_non_pk_id_field mongoengine/tests/document/inheritance.py /^ def test_auto_id_vs_non_pk_id_field(self):$/;" m class:InheritanceTest -test_average mongoengine/tests/queryset/queryset.py /^ def test_average(self):$/;" m class:QuerySetTest -test_average_over_db_field mongoengine/tests/queryset/queryset.py /^ def test_average_over_db_field(self):$/;" m class:QuerySetTest -test_bad_mixed_creation mongoengine/tests/document/instance.py /^ def test_bad_mixed_creation(self):$/;" m class:InstanceTest -test_batch_size mongoengine/tests/queryset/queryset.py /^ def test_batch_size(self):$/;" m class:QuerySetTest -test_binary_field_primary mongoengine/tests/fields/fields.py /^ def test_binary_field_primary(self):$/;" m class:FieldTest -test_binary_field_primary tests/fields/fields.py /^ def test_binary_field_primary(self):$/;" m class:FieldTest -test_binary_field_primary_filter_by_binary_pk_as_str mongoengine/tests/fields/fields.py /^ def test_binary_field_primary_filter_by_binary_pk_as_str(self):$/;" m class:FieldTest -test_binary_field_primary_filter_by_binary_pk_as_str tests/fields/fields.py /^ def test_binary_field_primary_filter_by_binary_pk_as_str(self):$/;" m class:FieldTest -test_binary_fields mongoengine/tests/fields/fields.py /^ def test_binary_fields(self):$/;" m class:FieldTest -test_binary_fields tests/fields/fields.py /^ def test_binary_fields(self):$/;" m class:FieldTest -test_binary_validation mongoengine/tests/fields/fields.py /^ def test_binary_validation(self):$/;" m class:FieldTest -test_binary_validation tests/fields/fields.py /^ def test_binary_validation(self):$/;" m class:FieldTest -test_bool_performance mongoengine/tests/queryset/queryset.py /^ def test_bool_performance(self):$/;" m class:QuerySetTest -test_bool_with_ordering mongoengine/tests/queryset/queryset.py /^ def test_bool_with_ordering(self):$/;" m class:QuerySetTest -test_bool_with_ordering_from_meta_dict mongoengine/tests/queryset/queryset.py /^ def test_bool_with_ordering_from_meta_dict(self):$/;" m class:QuerySetTest -test_boolean_validation mongoengine/tests/fields/fields.py /^ def test_boolean_validation(self):$/;" m class:FieldTest -test_boolean_validation tests/fields/fields.py /^ def test_boolean_validation(self):$/;" m class:FieldTest -test_build_index_spec_is_not_destructive mongoengine/tests/document/indexes.py /^ def test_build_index_spec_is_not_destructive(self):$/;" m class:IndexesTest -test_bulk mongoengine/tests/queryset/queryset.py /^ def test_bulk(self):$/;" m class:QuerySetTest -test_bulk_insert mongoengine/tests/queryset/queryset.py /^ def test_bulk_insert(self):$/;" m class:QuerySetTest -test_cache_not_cloned mongoengine/tests/queryset/queryset.py /^ def test_cache_not_cloned(self):$/;" m class:QuerySetTest -test_cached_queryset mongoengine/tests/queryset/queryset.py /^ def test_cached_queryset(self):$/;" m class:QuerySetTest -test_cached_reference_auto_sync mongoengine/tests/fields/fields.py /^ def test_cached_reference_auto_sync(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_auto_sync tests/fields/fields.py /^ def test_cached_reference_auto_sync(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_auto_sync_disabled mongoengine/tests/fields/fields.py /^ def test_cached_reference_auto_sync_disabled(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_auto_sync_disabled tests/fields/fields.py /^ def test_cached_reference_auto_sync_disabled(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_embedded_fields mongoengine/tests/fields/fields.py /^ def test_cached_reference_embedded_fields(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_embedded_fields tests/fields/fields.py /^ def test_cached_reference_embedded_fields(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_embedded_list_fields mongoengine/tests/fields/fields.py /^ def test_cached_reference_embedded_list_fields(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_embedded_list_fields tests/fields/fields.py /^ def test_cached_reference_embedded_list_fields(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_field_decimal mongoengine/tests/fields/fields.py /^ def test_cached_reference_field_decimal(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_field_decimal tests/fields/fields.py /^ def test_cached_reference_field_decimal(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_field_get_and_save mongoengine/tests/fields/fields.py /^ def test_cached_reference_field_get_and_save(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_field_get_and_save tests/fields/fields.py /^ def test_cached_reference_field_get_and_save(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_field_push_with_fields mongoengine/tests/fields/fields.py /^ def test_cached_reference_field_push_with_fields(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_field_push_with_fields tests/fields/fields.py /^ def test_cached_reference_field_push_with_fields(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_field_reference mongoengine/tests/fields/fields.py /^ def test_cached_reference_field_reference(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_field_reference tests/fields/fields.py /^ def test_cached_reference_field_reference(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_field_update_all mongoengine/tests/fields/fields.py /^ def test_cached_reference_field_update_all(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_field_update_all tests/fields/fields.py /^ def test_cached_reference_field_update_all(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_fields mongoengine/tests/fields/fields.py /^ def test_cached_reference_fields(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_fields tests/fields/fields.py /^ def test_cached_reference_fields(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_fields_on_embedded_documents mongoengine/tests/fields/fields.py /^ def test_cached_reference_fields_on_embedded_documents(self):$/;" m class:CachedReferenceFieldTest -test_cached_reference_fields_on_embedded_documents tests/fields/fields.py /^ def test_cached_reference_fields_on_embedded_documents(self):$/;" m class:CachedReferenceFieldTest -test_call_after_limits_set mongoengine/tests/queryset/queryset.py /^ def test_call_after_limits_set(self):$/;" m class:QuerySetTest -test_can_have_field_same_name_as_query_operator mongoengine/tests/queryset/queryset.py /^ def test_can_have_field_same_name_as_query_operator(self):$/;" m class:QuerySetTest -test_can_save_false_values mongoengine/tests/document/instance.py /^ def test_can_save_false_values(self):$/;" m class:InstanceTest -test_can_save_false_values_dynamic mongoengine/tests/document/instance.py /^ def test_can_save_false_values_dynamic(self):$/;" m class:InstanceTest -test_can_save_if_not_included mongoengine/tests/document/instance.py /^ def test_can_save_if_not_included(self):$/;" m class:InstanceTest -test_cannot_perform_joins_references mongoengine/tests/queryset/queryset.py /^ def test_cannot_perform_joins_references(self):$/;" m class:QuerySetTest -test_cant_turn_off_inheritance_on_subclass mongoengine/tests/document/inheritance.py /^ def test_cant_turn_off_inheritance_on_subclass(self):$/;" m class:InheritanceTest -test_capped_collection mongoengine/tests/document/instance.py /^ def test_capped_collection(self):$/;" m class:InstanceTest -test_capped_collection_default mongoengine/tests/document/instance.py /^ def test_capped_collection_default(self):$/;" m class:InstanceTest -test_capped_collection_no_max_size_problems mongoengine/tests/document/instance.py /^ def test_capped_collection_no_max_size_problems(self):$/;" m class:InstanceTest -test_chained_filter mongoengine/tests/fields/fields.py /^ def test_chained_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_chained_filter tests/fields/fields.py /^ def test_chained_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_chained_filter_exclude mongoengine/tests/fields/fields.py /^ def test_chained_filter_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_chained_filter_exclude tests/fields/fields.py /^ def test_chained_filter_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_chained_q_or_filtering mongoengine/tests/queryset/visitor.py /^ def test_chained_q_or_filtering(self):$/;" m class:QTest -test_chaining mongoengine/tests/queryset/queryset.py /^ def test_chaining(self):$/;" m class:QuerySetTest -test_chaining mongoengine/tests/queryset/transform.py /^ def test_chaining(self):$/;" m class:TransformTest -test_change_scope_of_variable mongoengine/tests/document/dynamic.py /^ def test_change_scope_of_variable(self):$/;" m class:DynamicTest -test_choices_allow_using_sets_as_choices mongoengine/tests/fields/fields.py /^ def test_choices_allow_using_sets_as_choices(self):$/;" m class:FieldTest -test_choices_allow_using_sets_as_choices tests/fields/fields.py /^ def test_choices_allow_using_sets_as_choices(self):$/;" m class:FieldTest -test_choices_get_field_display mongoengine/tests/fields/fields.py /^ def test_choices_get_field_display(self):$/;" m class:FieldTest -test_choices_get_field_display tests/fields/fields.py /^ def test_choices_get_field_display(self):$/;" m class:FieldTest -test_choices_validation_accept_possible_value mongoengine/tests/fields/fields.py /^ def test_choices_validation_accept_possible_value(self):$/;" m class:FieldTest -test_choices_validation_accept_possible_value tests/fields/fields.py /^ def test_choices_validation_accept_possible_value(self):$/;" m class:FieldTest -test_choices_validation_allow_no_value mongoengine/tests/fields/fields.py /^ def test_choices_validation_allow_no_value(self):$/;" m class:FieldTest -test_choices_validation_allow_no_value tests/fields/fields.py /^ def test_choices_validation_allow_no_value(self):$/;" m class:FieldTest -test_choices_validation_documents mongoengine/tests/fields/fields.py /^ def test_choices_validation_documents(self):$/;" m class:FieldTest -test_choices_validation_documents tests/fields/fields.py /^ def test_choices_validation_documents(self):$/;" m class:FieldTest -test_choices_validation_documents_inheritance mongoengine/tests/fields/fields.py /^ def test_choices_validation_documents_inheritance(self):$/;" m class:FieldTest -test_choices_validation_documents_inheritance tests/fields/fields.py /^ def test_choices_validation_documents_inheritance(self):$/;" m class:FieldTest -test_choices_validation_documents_invalid mongoengine/tests/fields/fields.py /^ def test_choices_validation_documents_invalid(self):$/;" m class:FieldTest -test_choices_validation_documents_invalid tests/fields/fields.py /^ def test_choices_validation_documents_invalid(self):$/;" m class:FieldTest -test_choices_validation_reject_unknown_value mongoengine/tests/fields/fields.py /^ def test_choices_validation_reject_unknown_value(self):$/;" m class:FieldTest -test_choices_validation_reject_unknown_value tests/fields/fields.py /^ def test_choices_validation_reject_unknown_value(self):$/;" m class:FieldTest -test_circular_reference mongoengine/tests/test_dereference.py /^ def test_circular_reference(self):$/;" m class:FieldTest -test_circular_reference_deltas mongoengine/tests/document/delta.py /^ def test_circular_reference_deltas(self):$/;" m class:DeltaTest -test_circular_reference_deltas_2 mongoengine/tests/document/delta.py /^ def test_circular_reference_deltas_2(self):$/;" m class:DeltaTest -test_circular_reference_on_self mongoengine/tests/test_dereference.py /^ def test_circular_reference_on_self(self):$/;" m class:FieldTest -test_circular_tree_reference mongoengine/tests/test_dereference.py /^ def test_circular_tree_reference(self):$/;" m class:FieldTest -test_clear_ordering mongoengine/tests/queryset/queryset.py /^ def test_clear_ordering(self):$/;" m class:QuerySetTest -test_clone mongoengine/tests/queryset/queryset.py /^ def test_clone(self):$/;" m class:QuerySetTest -test_cls_field mongoengine/tests/fields/fields.py /^ def test_cls_field(self):$/;" m class:FieldTest -test_cls_field tests/fields/fields.py /^ def test_cls_field(self):$/;" m class:FieldTest -test_cls_query_in_subclassed_docs mongoengine/tests/queryset/queryset.py /^ def test_cls_query_in_subclassed_docs(self):$/;" m class:QuerySetTest -test_collection_name_and_primary mongoengine/tests/document/class_methods.py /^ def test_collection_name_and_primary(self):$/;" m class:ClassMethodsTest -test_collection_naming mongoengine/tests/document/class_methods.py /^ def test_collection_naming(self):$/;" m class:ClassMethodsTest -test_comment mongoengine/tests/queryset/queryset.py /^ def test_comment(self):$/;" m class:QuerySetTest -test_compare_indexes mongoengine/tests/document/class_methods.py /^ def test_compare_indexes(self):$/;" m class:ClassMethodsTest -test_compare_indexes_inheritance mongoengine/tests/document/class_methods.py /^ def test_compare_indexes_inheritance(self):$/;" m class:ClassMethodsTest -test_compare_indexes_multiple_subclasses mongoengine/tests/document/class_methods.py /^ def test_compare_indexes_multiple_subclasses(self):$/;" m class:ClassMethodsTest -test_complex_data_lookups mongoengine/tests/document/dynamic.py /^ def test_complex_data_lookups(self):$/;" m class:DynamicTest -test_complex_dynamic_document_queries mongoengine/tests/document/dynamic.py /^ def test_complex_dynamic_document_queries(self):$/;" m class:DynamicTest -test_complex_embedded_document_validation mongoengine/tests/document/dynamic.py /^ def test_complex_embedded_document_validation(self):$/;" m class:DynamicTest -test_complex_embedded_documents mongoengine/tests/document/dynamic.py /^ def test_complex_embedded_documents(self):$/;" m class:DynamicTest -test_complex_field_filefield mongoengine/tests/fields/file_tests.py /^ def test_complex_field_filefield(self):$/;" m class:FileTest -test_complex_field_required mongoengine/tests/fields/fields.py /^ def test_complex_field_required(self):$/;" m class:FieldTest -test_complex_field_required tests/fields/fields.py /^ def test_complex_field_required(self):$/;" m class:FieldTest -test_complex_field_same_value_not_changed mongoengine/tests/fields/fields.py /^ def test_complex_field_same_value_not_changed(self):$/;" m class:FieldTest -test_complex_field_same_value_not_changed tests/fields/fields.py /^ def test_complex_field_same_value_not_changed(self):$/;" m class:FieldTest -test_complex_mapfield mongoengine/tests/fields/fields.py /^ def test_complex_mapfield(self):$/;" m class:FieldTest -test_complex_mapfield tests/fields/fields.py /^ def test_complex_mapfield(self):$/;" m class:FieldTest -test_complex_nesting_document_and_embedded_document mongoengine/tests/document/instance.py /^ def test_complex_nesting_document_and_embedded_document(self):$/;" m class:InstanceTest -test_complexdatetime_storage mongoengine/tests/fields/fields.py /^ def test_complexdatetime_storage(self):$/;" m class:FieldTest -test_complexdatetime_storage tests/fields/fields.py /^ def test_complexdatetime_storage(self):$/;" m class:FieldTest -test_complexdatetime_usage mongoengine/tests/fields/fields.py /^ def test_complexdatetime_usage(self):$/;" m class:FieldTest -test_complexdatetime_usage tests/fields/fields.py /^ def test_complexdatetime_usage(self):$/;" m class:FieldTest -test_compound_index_underscore_cls_not_overwritten mongoengine/tests/document/indexes.py /^ def test_compound_index_underscore_cls_not_overwritten(self):$/;" m class:IndexesTest -test_compound_key_dictfield mongoengine/tests/document/indexes.py /^ def test_compound_key_dictfield(self):$/;" m class:IndexesTest -test_compound_key_embedded mongoengine/tests/document/indexes.py /^ def test_compound_key_embedded(self):$/;" m class:IndexesTest -test_confirm_order_by_reference_wont_work mongoengine/tests/queryset/queryset.py /^ def test_confirm_order_by_reference_wont_work(self):$/;" m class:QuerySetTest -test_connect mongoengine/tests/test_connection.py /^ def test_connect(self):$/;" m class:ConnectionTest -test_connect_in_mocking mongoengine/tests/test_connection.py /^ def test_connect_in_mocking(self):$/;" m class:ConnectionTest -test_connect_uri mongoengine/tests/test_connection.py /^ def test_connect_uri(self):$/;" m class:ConnectionTest -test_connect_uri_default_db mongoengine/tests/test_connection.py /^ def test_connect_uri_default_db(self):$/;" m class:ConnectionTest -test_connect_uri_with_authsource mongoengine/tests/test_connection.py /^ def test_connect_uri_with_authsource(self):$/;" m class:ConnectionTest -test_connect_uri_without_db mongoengine/tests/test_connection.py /^ def test_connect_uri_without_db(self):$/;" m class:ConnectionTest -test_connect_with_host_list mongoengine/tests/test_connection.py /^ def test_connect_with_host_list(self):$/;" m class:ConnectionTest -test_connect_with_replicaset_via_kwargs mongoengine/tests/test_connection.py /^ def test_connect_with_replicaset_via_kwargs(self):$/;" m class:ConnectionTest -test_connect_with_replicaset_via_uri mongoengine/tests/test_connection.py /^ def test_connect_with_replicaset_via_uri(self):$/;" m class:ConnectionTest -test_connection_kwargs mongoengine/tests/test_connection.py /^ def test_connection_kwargs(self):$/;" m class:ConnectionTest -test_connection_pool_via_kwarg mongoengine/tests/test_connection.py /^ def test_connection_pool_via_kwarg(self):$/;" m class:ConnectionTest -test_connection_pool_via_uri mongoengine/tests/test_connection.py /^ def test_connection_pool_via_uri(self):$/;" m class:ConnectionTest -test_copyable mongoengine/tests/fields/file_tests.py /^ def test_copyable(self):$/;" m class:FileTest -test_count mongoengine/tests/fields/fields.py /^ def test_count(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_count tests/fields/fields.py /^ def test_count(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_count_and_none mongoengine/tests/queryset/queryset.py /^ def test_count_and_none(self):$/;" m class:QuerySetTest -test_count_limit_and_skip mongoengine/tests/queryset/queryset.py /^ def test_count_limit_and_skip(self):$/;" m class:QuerySetTest -test_count_list_embedded mongoengine/tests/queryset/queryset.py /^ def test_count_list_embedded(self):$/;" m class:QuerySetTest -test_covered_index mongoengine/tests/document/indexes.py /^ def test_covered_index(self):$/;" m class:IndexesTest -test_create mongoengine/tests/fields/fields.py /^ def test_create(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_create tests/fields/fields.py /^ def test_create(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_create_geohaystack_index mongoengine/tests/document/indexes.py /^ def test_create_geohaystack_index(self):$/;" m class:IndexesTest -test_creation mongoengine/tests/document/instance.py /^ def test_creation(self):$/;" m class:InstanceTest -test_cursor_args mongoengine/tests/queryset/queryset.py /^ def test_cursor_args(self):$/;" m class:QuerySetTest -test_cursor_in_an_if_stmt mongoengine/tests/queryset/queryset.py /^ def test_cursor_in_an_if_stmt(self):$/;" m class:QuerySetTest -test_custom_collection_name_operations mongoengine/tests/document/class_methods.py /^ def test_custom_collection_name_operations(self):$/;" m class:ClassMethodsTest -test_custom_data mongoengine/tests/fields/fields.py /^ def test_custom_data(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_custom_data tests/fields/fields.py /^ def test_custom_data(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_custom_id_field mongoengine/tests/document/instance.py /^ def test_custom_id_field(self):$/;" m class:InstanceTest -test_custom_manager mongoengine/tests/queryset/queryset.py /^ def test_custom_manager(self):$/;" m class:QuerySetTest -test_custom_manager_overriding_objects_works mongoengine/tests/queryset/queryset.py /^ def test_custom_manager_overriding_objects_works(self):$/;" m class:QuerySetTest -test_custom_querysets mongoengine/tests/queryset/queryset.py /^ def test_custom_querysets(self):$/;" m class:QuerySetTest -test_custom_querysets_inherited mongoengine/tests/queryset/queryset.py /^ def test_custom_querysets_inherited(self):$/;" m class:QuerySetTest -test_custom_querysets_inherited_direct mongoengine/tests/queryset/queryset.py /^ def test_custom_querysets_inherited_direct(self):$/;" m class:QuerySetTest -test_custom_querysets_managers_directly mongoengine/tests/queryset/queryset.py /^ def test_custom_querysets_managers_directly(self):$/;" m class:QuerySetTest -test_custom_querysets_set_manager_directly mongoengine/tests/queryset/queryset.py /^ def test_custom_querysets_set_manager_directly(self):$/;" m class:QuerySetTest -test_data_contains_id_field mongoengine/tests/document/instance.py /^ def test_data_contains_id_field(self):$/;" m class:InstanceTest -test_datetime mongoengine/tests/fields/fields.py /^ def test_datetime(self):$/;" m class:FieldTest -test_datetime mongoengine/tests/test_connection.py /^ def test_datetime(self):$/;" m class:ConnectionTest -test_datetime tests/fields/fields.py /^ def test_datetime(self):$/;" m class:FieldTest -test_datetime_from_empty_string mongoengine/tests/fields/fields.py /^ def test_datetime_from_empty_string(self):$/;" m class:FieldTest -test_datetime_from_empty_string tests/fields/fields.py /^ def test_datetime_from_empty_string(self):$/;" m class:FieldTest -test_datetime_from_whitespace_string mongoengine/tests/fields/fields.py /^ def test_datetime_from_whitespace_string(self):$/;" m class:FieldTest -test_datetime_from_whitespace_string tests/fields/fields.py /^ def test_datetime_from_whitespace_string(self):$/;" m class:FieldTest -test_datetime_tz_aware_mark_as_changed mongoengine/tests/fields/fields.py /^ def test_datetime_tz_aware_mark_as_changed(self):$/;" m class:FieldTest -test_datetime_tz_aware_mark_as_changed tests/fields/fields.py /^ def test_datetime_tz_aware_mark_as_changed(self):$/;" m class:FieldTest -test_datetime_usage mongoengine/tests/fields/fields.py /^ def test_datetime_usage(self):$/;" m class:FieldTest -test_datetime_usage tests/fields/fields.py /^ def test_datetime_usage(self):$/;" m class:FieldTest -test_datetime_validation mongoengine/tests/fields/fields.py /^ def test_datetime_validation(self):$/;" m class:FieldTest -test_datetime_validation tests/fields/fields.py /^ def test_datetime_validation(self):$/;" m class:FieldTest -test_db_alias_overrides mongoengine/tests/document/instance.py /^ def test_db_alias_overrides(self):$/;" m class:InstanceTest -test_db_alias_propagates mongoengine/tests/document/instance.py /^ def test_db_alias_propagates(self):$/;" m class:InstanceTest -test_db_alias_tests mongoengine/tests/document/instance.py /^ def test_db_alias_tests(self):$/;" m class:InstanceTest -test_db_embedded_doc_field_load mongoengine/tests/document/instance.py /^ def test_db_embedded_doc_field_load(self):$/;" m class:InstanceTest -test_db_field_load mongoengine/tests/document/instance.py /^ def test_db_field_load(self):$/;" m class:InstanceTest -test_db_field_validation mongoengine/tests/fields/fields.py /^ def test_db_field_validation(self):$/;" m class:FieldTest -test_db_field_validation tests/fields/fields.py /^ def test_db_field_validation(self):$/;" m class:FieldTest -test_db_ref_usage mongoengine/tests/document/instance.py /^ def test_db_ref_usage(self):$/;" m class:InstanceTest -test_dbref_equality mongoengine/tests/document/instance.py /^ def test_dbref_equality(self):$/;" m class:InstanceTest -test_dbref_reference_fields mongoengine/tests/fields/fields.py /^ def test_dbref_reference_fields(self):$/;" m class:FieldTest -test_dbref_reference_fields tests/fields/fields.py /^ def test_dbref_reference_fields(self):$/;" m class:FieldTest -test_dbref_to_mongo mongoengine/tests/fields/fields.py /^ def test_dbref_to_mongo(self):$/;" m class:FieldTest -test_dbref_to_mongo tests/fields/fields.py /^ def test_dbref_to_mongo(self):$/;" m class:FieldTest -test_decimal_comparison mongoengine/tests/fields/fields.py /^ def test_decimal_comparison(self):$/;" m class:FieldTest -test_decimal_comparison tests/fields/fields.py /^ def test_decimal_comparison(self):$/;" m class:FieldTest -test_decimal_storage mongoengine/tests/fields/fields.py /^ def test_decimal_storage(self):$/;" m class:FieldTest -test_decimal_storage tests/fields/fields.py /^ def test_decimal_storage(self):$/;" m class:FieldTest -test_decimal_validation mongoengine/tests/fields/fields.py /^ def test_decimal_validation(self):$/;" m class:FieldTest -test_decimal_validation tests/fields/fields.py /^ def test_decimal_validation(self):$/;" m class:FieldTest -test_default_values mongoengine/tests/document/instance.py /^ def test_default_values(self):$/;" m class:InstanceTest -test_default_values_nothing_set mongoengine/tests/fields/fields.py /^ def test_default_values_nothing_set(self):$/;" m class:FieldTest -test_default_values_nothing_set tests/fields/fields.py /^ def test_default_values_nothing_set(self):$/;" m class:FieldTest -test_default_values_set_to_None mongoengine/tests/fields/fields.py /^ def test_default_values_set_to_None(self):$/;" m class:FieldTest -test_default_values_set_to_None tests/fields/fields.py /^ def test_default_values_set_to_None(self):$/;" m class:FieldTest -test_default_values_when_deleting_value mongoengine/tests/fields/fields.py /^ def test_default_values_when_deleting_value(self):$/;" m class:FieldTest -test_default_values_when_deleting_value tests/fields/fields.py /^ def test_default_values_when_deleting_value(self):$/;" m class:FieldTest -test_default_values_when_setting_to_None mongoengine/tests/fields/fields.py /^ def test_default_values_when_setting_to_None(self):$/;" m class:FieldTest -test_default_values_when_setting_to_None tests/fields/fields.py /^ def test_default_values_when_setting_to_None(self):$/;" m class:FieldTest -test_definition mongoengine/tests/document/class_methods.py /^ def test_definition(self):$/;" m class:ClassMethodsTest -test_del_slice_marks_field_as_changed mongoengine/tests/fields/fields.py /^ def test_del_slice_marks_field_as_changed(self):$/;" m class:FieldTest -test_del_slice_marks_field_as_changed tests/fields/fields.py /^ def test_del_slice_marks_field_as_changed(self):$/;" m class:FieldTest -test_delete mongoengine/tests/document/instance.py /^ def test_delete(self):$/;" m class:InstanceTest -test_delete mongoengine/tests/fields/fields.py /^ def test_delete(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_delete mongoengine/tests/queryset/queryset.py /^ def test_delete(self):$/;" m class:QuerySetTest -test_delete tests/fields/fields.py /^ def test_delete(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_delete_count mongoengine/tests/queryset/queryset.py /^ def test_delete_count(self):$/;" m class:QuerySetTest -test_delete_dynamic_field mongoengine/tests/document/dynamic.py /^ def test_delete_dynamic_field(self):$/;" m class:DynamicTest -test_delete_with_limit_handles_delete_rules mongoengine/tests/queryset/queryset.py /^ def test_delete_with_limit_handles_delete_rules(self):$/;" m class:QuerySetTest -test_delete_with_limits mongoengine/tests/queryset/queryset.py /^ def test_delete_with_limits(self):$/;" m class:QuerySetTest -test_delta mongoengine/tests/document/delta.py /^ def test_delta(self):$/;" m class:DeltaTest -test_delta_db_field mongoengine/tests/document/delta.py /^ def test_delta_db_field(self):$/;" m class:DeltaTest -test_delta_for_dynamic_documents mongoengine/tests/document/delta.py /^ def test_delta_for_dynamic_documents(self):$/;" m class:DeltaTest -test_delta_for_nested_map_fields mongoengine/tests/document/delta.py /^ def test_delta_for_nested_map_fields(self):$/;" m class:DeltaTest -test_delta_recursive mongoengine/tests/document/delta.py /^ def test_delta_recursive(self):$/;" m class:DeltaTest -test_delta_recursive_db_field mongoengine/tests/document/delta.py /^ def test_delta_recursive_db_field(self):$/;" m class:DeltaTest -test_delta_with_dbref_false mongoengine/tests/document/delta.py /^ def test_delta_with_dbref_false(self):$/;" m class:DeltaTest -test_delta_with_dbref_true mongoengine/tests/document/delta.py /^ def test_delta_with_dbref_true(self):$/;" m class:DeltaTest -test_dereferencing_embedded_listfield_referencefield mongoengine/tests/test_dereference.py /^ def test_dereferencing_embedded_listfield_referencefield(self):$/;" m class:FieldTest -test_dict_field mongoengine/tests/fields/fields.py /^ def test_dict_field(self):$/;" m class:FieldTest -test_dict_field mongoengine/tests/test_dereference.py /^ def test_dict_field(self):$/;" m class:FieldTest -test_dict_field tests/fields/fields.py /^ def test_dict_field(self):$/;" m class:FieldTest -test_dict_field_no_field_inheritance mongoengine/tests/test_dereference.py /^ def test_dict_field_no_field_inheritance(self):$/;" m class:FieldTest -test_dict_in_dbref_instance mongoengine/tests/test_dereference.py /^ def test_dict_in_dbref_instance(self):$/;" m class:FieldTest -test_dict_with_custom_baseclass mongoengine/tests/queryset/queryset.py /^ def test_dict_with_custom_baseclass(self):$/;" m class:QuerySetTest -test_dictfield_complex mongoengine/tests/fields/fields.py /^ def test_dictfield_complex(self):$/;" m class:FieldTest -test_dictfield_complex tests/fields/fields.py /^ def test_dictfield_complex(self):$/;" m class:FieldTest -test_dictfield_dump_document mongoengine/tests/fields/fields.py /^ def test_dictfield_dump_document(self):$/;" m class:FieldTest -test_dictfield_dump_document tests/fields/fields.py /^ def test_dictfield_dump_document(self):$/;" m class:FieldTest -test_dictfield_key_looks_like_a_digit mongoengine/tests/queryset/queryset.py /^ def test_dictfield_key_looks_like_a_digit(self):$/;" m class:QuerySetTest -test_dictfield_strict mongoengine/tests/fields/fields.py /^ def test_dictfield_strict(self):$/;" m class:FieldTest -test_dictfield_strict tests/fields/fields.py /^ def test_dictfield_strict(self):$/;" m class:FieldTest -test_dictfield_update mongoengine/tests/queryset/queryset.py /^ def test_dictfield_update(self):$/;" m class:QuerySetTest -test_dictionary_access mongoengine/tests/document/instance.py /^ def test_dictionary_access(self):$/;" m class:InstanceTest -test_dictionary_indexes mongoengine/tests/document/indexes.py /^ def test_dictionary_indexes(self):$/;" m class:IndexesTest -test_disable_index_creation mongoengine/tests/document/indexes.py /^ def test_disable_index_creation(self):$/;" m class:IndexesTest -test_disconnect mongoengine/tests/test_connection.py /^ def test_disconnect(self):$/;" m class:ConnectionTest -test_distinct mongoengine/tests/queryset/queryset.py /^ def test_distinct(self):$/;" m class:QuerySetTest -test_distinct_ListField_EmbeddedDocumentField mongoengine/tests/queryset/queryset.py /^ def test_distinct_ListField_EmbeddedDocumentField(self):$/;" m class:QuerySetTest -test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField mongoengine/tests/queryset/queryset.py /^ def test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField(self):$/;" m class:QuerySetTest -test_distinct_ListField_ReferenceField mongoengine/tests/queryset/queryset.py /^ def test_distinct_ListField_ReferenceField(self):$/;" m class:QuerySetTest -test_distinct_handles_db_field mongoengine/tests/queryset/queryset.py /^ def test_distinct_handles_db_field(self):$/;" m class:QuerySetTest -test_distinct_handles_references mongoengine/tests/queryset/queryset.py /^ def test_distinct_handles_references(self):$/;" m class:QuerySetTest -test_distinct_handles_references_to_alias mongoengine/tests/queryset/queryset.py /^ def test_distinct_handles_references_to_alias(self):$/;" m class:QuerySetTest -test_do_not_save_unchanged_references mongoengine/tests/document/instance.py /^ def test_do_not_save_unchanged_references(self):$/;" m class:InstanceTest -test_document_clean mongoengine/tests/document/instance.py /^ def test_document_clean(self):$/;" m class:InstanceTest -test_document_collection_syntax_warning mongoengine/tests/all_warnings/__init__.py /^ def test_document_collection_syntax_warning(self):$/;" m class:AllWarnings -test_document_embedded_clean mongoengine/tests/document/instance.py /^ def test_document_embedded_clean(self):$/;" m class:InstanceTest -test_document_hash mongoengine/tests/document/instance.py /^ def test_document_hash(self):$/;" m class:InstanceTest -test_document_inheritance mongoengine/tests/document/inheritance.py /^ def test_document_inheritance(self):$/;" m class:InheritanceTest -test_document_not_registered mongoengine/tests/document/instance.py /^ def test_document_not_registered(self):$/;" m class:InstanceTest -test_document_registry_regressions mongoengine/tests/document/instance.py /^ def test_document_registry_regressions(self):$/;" m class:InstanceTest -test_document_reload_no_inheritance mongoengine/tests/test_dereference.py /^ def test_document_reload_no_inheritance(self):$/;" m class:FieldTest -test_document_reload_reference_integrity mongoengine/tests/test_dereference.py /^ def test_document_reload_reference_integrity(self):$/;" m class:FieldTest -test_document_update mongoengine/tests/document/instance.py /^ def test_document_update(self):$/;" m class:InstanceTest -test_double_embedded_db_field mongoengine/tests/fields/fields.py /^ def test_double_embedded_db_field(self):$/;" m class:FieldTest -test_double_embedded_db_field tests/fields/fields.py /^ def test_double_embedded_db_field(self):$/;" m class:FieldTest -test_double_embedded_db_field_from_son mongoengine/tests/fields/fields.py /^ def test_double_embedded_db_field_from_son(self):$/;" m class:FieldTest -test_double_embedded_db_field_from_son tests/fields/fields.py /^ def test_double_embedded_db_field_from_son(self):$/;" m class:FieldTest -test_drop_abstract_document mongoengine/tests/fields/fields.py /^ def test_drop_abstract_document(self):$/;" m class:FieldTest -test_drop_abstract_document tests/fields/fields.py /^ def test_drop_abstract_document(self):$/;" m class:FieldTest -test_drop_collection mongoengine/tests/document/class_methods.py /^ def test_drop_collection(self):$/;" m class:ClassMethodsTest -test_duplicate_db_fields_raise_invalid_document_error mongoengine/tests/document/instance.py /^ def test_duplicate_db_fields_raise_invalid_document_error(self):$/;" m class:InstanceTest -test_dynamic_and_embedded mongoengine/tests/document/dynamic.py /^ def test_dynamic_and_embedded(self):$/;" m class:DynamicTest -test_dynamic_and_embedded_dict_access mongoengine/tests/document/dynamic.py /^ def test_dynamic_and_embedded_dict_access(self):$/;" m class:DynamicTest -test_dynamic_declarations mongoengine/tests/document/inheritance.py /^ def test_dynamic_declarations(self):$/;" m class:InheritanceTest -test_dynamic_delta mongoengine/tests/document/delta.py /^ def test_dynamic_delta(self):$/;" m class:DeltaTest -test_dynamic_document_pickle mongoengine/tests/document/instance.py /^ def test_dynamic_document_pickle(self):$/;" m class:InstanceTest -test_dynamic_document_queries mongoengine/tests/document/dynamic.py /^ def test_dynamic_document_queries(self):$/;" m class:DynamicTest -test_dynamic_embedded_works_with_only mongoengine/tests/document/dynamic.py /^ def test_dynamic_embedded_works_with_only(self):$/;" m class:DynamicTest -test_dynamic_fields_class mongoengine/tests/fields/fields.py /^ def test_dynamic_fields_class(self):$/;" m class:FieldTest -test_dynamic_fields_class tests/fields/fields.py /^ def test_dynamic_fields_class(self):$/;" m class:FieldTest -test_dynamic_fields_embedded_class mongoengine/tests/fields/fields.py /^ def test_dynamic_fields_embedded_class(self):$/;" m class:FieldTest -test_dynamic_fields_embedded_class tests/fields/fields.py /^ def test_dynamic_fields_embedded_class(self):$/;" m class:FieldTest -test_dynamicfield_dump_document mongoengine/tests/fields/fields.py /^ def test_dynamicfield_dump_document(self):$/;" m class:FieldTest -test_dynamicfield_dump_document tests/fields/fields.py /^ def test_dynamicfield_dump_document(self):$/;" m class:FieldTest -test_editting_embedded_objects mongoengine/tests/queryset/queryset.py /^ def test_editting_embedded_objects(self):$/;" m class:QuerySetTest -test_elem_match mongoengine/tests/queryset/queryset.py /^ def test_elem_match(self):$/;" m class:QuerySetTest -test_email_field mongoengine/tests/fields/fields.py /^ def test_email_field(self):$/;" m class:FieldTest -test_email_field tests/fields/fields.py /^ def test_email_field(self):$/;" m class:FieldTest -test_email_field_domain_whitelist mongoengine/tests/fields/fields.py /^ def test_email_field_domain_whitelist(self):$/;" m class:FieldTest -test_email_field_domain_whitelist tests/fields/fields.py /^ def test_email_field_domain_whitelist(self):$/;" m class:FieldTest -test_email_field_honors_regex mongoengine/tests/fields/fields.py /^ def test_email_field_honors_regex(self):$/;" m class:FieldTest -test_email_field_honors_regex tests/fields/fields.py /^ def test_email_field_honors_regex(self):$/;" m class:FieldTest -test_email_field_ip_domain mongoengine/tests/fields/fields.py /^ def test_email_field_ip_domain(self):$/;" m class:FieldTest -test_email_field_ip_domain tests/fields/fields.py /^ def test_email_field_ip_domain(self):$/;" m class:FieldTest -test_email_field_unicode_user mongoengine/tests/fields/fields.py /^ def test_email_field_unicode_user(self):$/;" m class:FieldTest -test_email_field_unicode_user tests/fields/fields.py /^ def test_email_field_unicode_user(self):$/;" m class:FieldTest -test_embedded_array_average mongoengine/tests/queryset/queryset.py /^ def test_embedded_array_average(self):$/;" m class:QuerySetTest -test_embedded_array_sum mongoengine/tests/queryset/queryset.py /^ def test_embedded_array_sum(self):$/;" m class:QuerySetTest -test_embedded_average mongoengine/tests/queryset/queryset.py /^ def test_embedded_average(self):$/;" m class:QuerySetTest -test_embedded_db_field mongoengine/tests/fields/fields.py /^ def test_embedded_db_field(self):$/;" m class:FieldTest -test_embedded_db_field tests/fields/fields.py /^ def test_embedded_db_field(self):$/;" m class:FieldTest -test_embedded_db_field_validate mongoengine/tests/document/validation.py /^ def test_embedded_db_field_validate(self):$/;" m class:ValidatorErrorTest -test_embedded_document mongoengine/tests/document/instance.py /^ def test_embedded_document(self):$/;" m class:InstanceTest -test_embedded_document_complex_instance mongoengine/tests/document/instance.py /^ def test_embedded_document_complex_instance(self):$/;" m class:InstanceTest -test_embedded_document_complex_instance_no_use_db_field mongoengine/tests/document/instance.py /^ def test_embedded_document_complex_instance_no_use_db_field(self):$/;" m class:InstanceTest -test_embedded_document_equality mongoengine/tests/document/instance.py /^ def test_embedded_document_equality(self):$/;" m class:InstanceTest -test_embedded_document_index mongoengine/tests/document/indexes.py /^ def test_embedded_document_index(self):$/;" m class:IndexesTest -test_embedded_document_index_meta mongoengine/tests/document/indexes.py /^ def test_embedded_document_index_meta(self):$/;" m class:IndexesTest -test_embedded_document_inheritance mongoengine/tests/fields/fields.py /^ def test_embedded_document_inheritance(self):$/;" m class:FieldTest -test_embedded_document_inheritance tests/fields/fields.py /^ def test_embedded_document_inheritance(self):$/;" m class:FieldTest -test_embedded_document_inheritance_with_list mongoengine/tests/fields/fields.py /^ def test_embedded_document_inheritance_with_list(self):$/;" m class:FieldTest -test_embedded_document_inheritance_with_list tests/fields/fields.py /^ def test_embedded_document_inheritance_with_list(self):$/;" m class:FieldTest -test_embedded_document_instance mongoengine/tests/document/instance.py /^ def test_embedded_document_instance(self):$/;" m class:InstanceTest -test_embedded_document_to_mongo mongoengine/tests/document/instance.py /^ def test_embedded_document_to_mongo(self):$/;" m class:InstanceTest -test_embedded_document_to_mongo_id mongoengine/tests/document/instance.py /^ def test_embedded_document_to_mongo_id(self):$/;" m class:InstanceTest -test_embedded_document_validation mongoengine/tests/document/validation.py /^ def test_embedded_document_validation(self):$/;" m class:ValidatorErrorTest -test_embedded_document_validation mongoengine/tests/fields/fields.py /^ def test_embedded_document_validation(self):$/;" m class:FieldTest -test_embedded_document_validation tests/fields/fields.py /^ def test_embedded_document_validation(self):$/;" m class:FieldTest -test_embedded_dynamic_document mongoengine/tests/document/dynamic.py /^ def test_embedded_dynamic_document(self):$/;" m class:DynamicTest -test_embedded_mapfield_db_field mongoengine/tests/fields/fields.py /^ def test_embedded_mapfield_db_field(self):$/;" m class:FieldTest -test_embedded_mapfield_db_field tests/fields/fields.py /^ def test_embedded_mapfield_db_field(self):$/;" m class:FieldTest -test_embedded_sequence_field mongoengine/tests/fields/fields.py /^ def test_embedded_sequence_field(self):$/;" m class:FieldTest -test_embedded_sequence_field tests/fields/fields.py /^ def test_embedded_sequence_field(self):$/;" m class:FieldTest -test_embedded_sum mongoengine/tests/queryset/queryset.py /^ def test_embedded_sum(self):$/;" m class:QuerySetTest -test_embedded_update mongoengine/tests/document/instance.py /^ def test_embedded_update(self):$/;" m class:InstanceTest -test_embedded_update_after_save mongoengine/tests/document/instance.py /^ def test_embedded_update_after_save(self):$/;" m class:InstanceTest -test_embedded_update_db_field mongoengine/tests/document/instance.py /^ def test_embedded_update_db_field(self):$/;" m class:InstanceTest -test_embedded_weakref mongoengine/tests/document/validation.py /^ def test_embedded_weakref(self):$/;" m class:ValidatorErrorTest -test_empty mongoengine/tests/queryset/field_list.py /^ def test_empty(self):$/;" m class:QueryFieldListTest -test_empty_list_embedded_documents_with_unique_field mongoengine/tests/fields/fields.py /^ def test_empty_list_embedded_documents_with_unique_field(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_empty_list_embedded_documents_with_unique_field tests/fields/fields.py /^ def test_empty_list_embedded_documents_with_unique_field(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_empty_q mongoengine/tests/queryset/visitor.py /^ def test_empty_q(self):$/;" m class:QTest -test_ensure_index mongoengine/tests/queryset/queryset.py /^ def test_ensure_index(self):$/;" m class:QuerySetTest -test_ensure_unique_default_instances mongoengine/tests/fields/fields.py /^ def test_ensure_unique_default_instances(self):$/;" m class:FieldTest -test_ensure_unique_default_instances tests/fields/fields.py /^ def test_ensure_unique_default_instances(self):$/;" m class:FieldTest -test_eq mongoengine/tests/test_datastructures.py /^ def test_eq(self):$/;" m class:TestStrictDict -test_exclude mongoengine/tests/queryset/field_list.py /^ def test_exclude(self):$/;" m class:OnlyExcludeAllTest -test_exclude_exclude mongoengine/tests/queryset/field_list.py /^ def test_exclude_exclude(self):$/;" m class:QueryFieldListTest -test_exclude_from_subclasses_docs mongoengine/tests/queryset/field_list.py /^ def test_exclude_from_subclasses_docs(self):$/;" m class:OnlyExcludeAllTest -test_exclude_include mongoengine/tests/queryset/field_list.py /^ def test_exclude_include(self):$/;" m class:QueryFieldListTest -test_exclude_only_combining mongoengine/tests/queryset/field_list.py /^ def test_exclude_only_combining(self):$/;" m class:OnlyExcludeAllTest -test_exec_js_field_sub mongoengine/tests/queryset/queryset.py /^ def test_exec_js_field_sub(self):$/;" m class:QuerySetTest -test_exec_js_query mongoengine/tests/queryset/queryset.py /^ def test_exec_js_query(self):$/;" m class:QuerySetTest -test_explicit_geo2d_index mongoengine/tests/document/indexes.py /^ def test_explicit_geo2d_index(self):$/;" m class:IndexesTest -test_explicit_geo2d_index_embedded mongoengine/tests/document/indexes.py /^ def test_explicit_geo2d_index_embedded(self):$/;" m class:IndexesTest -test_explicit_geohaystack_index mongoengine/tests/document/indexes.py /^ def test_explicit_geohaystack_index(self):$/;" m class:IndexesTest -test_explicit_geosphere_index mongoengine/tests/document/indexes.py /^ def test_explicit_geosphere_index(self):$/;" m class:IndexesTest -test_external_subclasses mongoengine/tests/document/inheritance.py /^ def test_external_subclasses(self):$/;" m class:InheritanceTest -test_external_superclasses mongoengine/tests/document/inheritance.py /^ def test_external_superclasses(self):$/;" m class:InheritanceTest -test_falsey_pk mongoengine/tests/document/instance.py /^ def test_falsey_pk(self):$/;" m class:InstanceTest -test_field mongoengine/tests/queryset/queryset.py /^ test_field = StringField()$/;" v class:QuerySetTest.test_cursor_in_an_if_stmt.Test -test_fields_rewrite mongoengine/tests/document/validation.py /^ def test_fields_rewrite(self):$/;" m class:ValidatorErrorTest -test_file_boolean mongoengine/tests/fields/file_tests.py /^ def test_file_boolean(self):$/;" m class:FileTest -test_file_cmp mongoengine/tests/fields/file_tests.py /^ def test_file_cmp(self):$/;" m class:FileTest -test_file_disk_space mongoengine/tests/fields/file_tests.py /^ def test_file_disk_space(self):$/;" m class:FileTest -test_file_field_no_default mongoengine/tests/fields/file_tests.py /^ def test_file_field_no_default(self):$/;" m class:FileTest -test_file_field_optional mongoengine/tests/fields/file_tests.py /^ def test_file_field_optional(self):$/;" m class:FileTest -test_file_fields mongoengine/tests/fields/file_tests.py /^ def test_file_fields(self):$/;" m class:FileTest -test_file_fields_set mongoengine/tests/fields/file_tests.py /^ def test_file_fields_set(self):$/;" m class:FileTest -test_file_fields_stream mongoengine/tests/fields/file_tests.py /^ def test_file_fields_stream(self):$/;" m class:FileTest -test_file_fields_stream_after_none mongoengine/tests/fields/file_tests.py /^ def test_file_fields_stream_after_none(self):$/;" m class:FileTest -test_file_multidb mongoengine/tests/fields/file_tests.py /^ def test_file_multidb(self):$/;" m class:FileTest -test_file_reassigning mongoengine/tests/fields/file_tests.py /^ def test_file_reassigning(self):$/;" m class:FileTest -test_file_saving mongoengine/tests/fields/file_tests.py /^ def test_file_saving(self):$/;" m class:FileTest -test_file_uniqueness mongoengine/tests/fields/file_tests.py /^ def test_file_uniqueness(self):$/;" m class:FileTest -test_filter_chaining mongoengine/tests/queryset/queryset.py /^ def test_filter_chaining(self):$/;" m class:QuerySetTest -test_filtered_count mongoengine/tests/fields/fields.py /^ def test_filtered_count(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_filtered_count tests/fields/fields.py /^ def test_filtered_count(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_filtered_create mongoengine/tests/fields/fields.py /^ def test_filtered_create(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_filtered_create tests/fields/fields.py /^ def test_filtered_create(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_filtered_delete mongoengine/tests/fields/fields.py /^ def test_filtered_delete(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_filtered_delete tests/fields/fields.py /^ def test_filtered_delete(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_find mongoengine/tests/queryset/queryset.py /^ def test_find(self):$/;" m class:QuerySetTest -test_find_and_modify_with_remove_not_existing mongoengine/tests/queryset/modify.py /^ def test_find_and_modify_with_remove_not_existing(self):$/;" m class:FindAndModifyTest -test_find_array_position mongoengine/tests/queryset/queryset.py /^ def test_find_array_position(self):$/;" m class:QuerySetTest -test_find_dict_item mongoengine/tests/queryset/queryset.py /^ def test_find_dict_item(self):$/;" m class:QuerySetTest -test_find_embedded mongoengine/tests/queryset/queryset.py /^ def test_find_embedded(self):$/;" m class:QuerySetTest -test_find_empty_embedded mongoengine/tests/queryset/queryset.py /^ def test_find_empty_embedded(self):$/;" m class:QuerySetTest -test_find_one mongoengine/tests/queryset/queryset.py /^ def test_find_one(self):$/;" m class:QuerySetTest -test_find_only_one mongoengine/tests/queryset/queryset.py /^ def test_find_only_one(self):$/;" m class:QuerySetTest -test_first mongoengine/tests/fields/fields.py /^ def test_first(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_first tests/fields/fields.py /^ def test_first(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_float_validation mongoengine/tests/fields/fields.py /^ def test_float_validation(self):$/;" m class:FieldTest -test_float_validation tests/fields/fields.py /^ def test_float_validation(self):$/;" m class:FieldTest -test_from_son mongoengine/tests/document/instance.py /^ def test_from_son(self):$/;" m class:InstanceTest -test_generic_embedded_document mongoengine/tests/fields/fields.py /^ def test_generic_embedded_document(self):$/;" m class:FieldTest -test_generic_embedded_document tests/fields/fields.py /^ def test_generic_embedded_document(self):$/;" m class:FieldTest -test_generic_embedded_document_choices mongoengine/tests/fields/fields.py /^ def test_generic_embedded_document_choices(self):$/;" m class:FieldTest -test_generic_embedded_document_choices tests/fields/fields.py /^ def test_generic_embedded_document_choices(self):$/;" m class:FieldTest -test_generic_lazy_reference_bad_set mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_bad_set(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_bad_set tests/fields/fields.py /^ def test_generic_lazy_reference_bad_set(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_choices mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_choices(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_choices tests/fields/fields.py /^ def test_generic_lazy_reference_choices(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_embedded mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_embedded(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_embedded tests/fields/fields.py /^ def test_generic_lazy_reference_embedded(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_not_set mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_not_set(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_not_set tests/fields/fields.py /^ def test_generic_lazy_reference_not_set(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_query_conversion mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_query_conversion(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_query_conversion tests/fields/fields.py /^ def test_generic_lazy_reference_query_conversion(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_set mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_set(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_set tests/fields/fields.py /^ def test_generic_lazy_reference_set(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_simple mongoengine/tests/fields/fields.py /^ def test_generic_lazy_reference_simple(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_lazy_reference_simple tests/fields/fields.py /^ def test_generic_lazy_reference_simple(self):$/;" m class:GenericLazyReferenceFieldTest -test_generic_list_embedded_document_choices mongoengine/tests/fields/fields.py /^ def test_generic_list_embedded_document_choices(self):$/;" m class:FieldTest -test_generic_list_embedded_document_choices tests/fields/fields.py /^ def test_generic_list_embedded_document_choices(self):$/;" m class:FieldTest -test_generic_reference mongoengine/tests/fields/fields.py /^ def test_generic_reference(self):$/;" m class:FieldTest -test_generic_reference mongoengine/tests/test_dereference.py /^ def test_generic_reference(self):$/;" m class:FieldTest -test_generic_reference tests/fields/fields.py /^ def test_generic_reference(self):$/;" m class:FieldTest -test_generic_reference_choices mongoengine/tests/fields/fields.py /^ def test_generic_reference_choices(self):$/;" m class:FieldTest -test_generic_reference_choices tests/fields/fields.py /^ def test_generic_reference_choices(self):$/;" m class:FieldTest -test_generic_reference_choices_no_dereference mongoengine/tests/fields/fields.py /^ def test_generic_reference_choices_no_dereference(self):$/;" m class:FieldTest -test_generic_reference_choices_no_dereference tests/fields/fields.py /^ def test_generic_reference_choices_no_dereference(self):$/;" m class:FieldTest -test_generic_reference_document_not_registered mongoengine/tests/fields/fields.py /^ def test_generic_reference_document_not_registered(self):$/;" m class:FieldTest -test_generic_reference_document_not_registered tests/fields/fields.py /^ def test_generic_reference_document_not_registered(self):$/;" m class:FieldTest -test_generic_reference_field_with_only_and_as_pymongo mongoengine/tests/queryset/queryset.py /^ def test_generic_reference_field_with_only_and_as_pymongo(self):$/;" m class:QuerySetTest -test_generic_reference_filter_by_dbref mongoengine/tests/fields/fields.py /^ def test_generic_reference_filter_by_dbref(self):$/;" m class:FieldTest -test_generic_reference_filter_by_dbref tests/fields/fields.py /^ def test_generic_reference_filter_by_dbref(self):$/;" m class:FieldTest -test_generic_reference_filter_by_objectid mongoengine/tests/fields/fields.py /^ def test_generic_reference_filter_by_objectid(self):$/;" m class:FieldTest -test_generic_reference_filter_by_objectid tests/fields/fields.py /^ def test_generic_reference_filter_by_objectid(self):$/;" m class:FieldTest -test_generic_reference_is_none mongoengine/tests/fields/fields.py /^ def test_generic_reference_is_none(self):$/;" m class:FieldTest -test_generic_reference_is_none tests/fields/fields.py /^ def test_generic_reference_is_none(self):$/;" m class:FieldTest -test_generic_reference_list mongoengine/tests/fields/fields.py /^ def test_generic_reference_list(self):$/;" m class:FieldTest -test_generic_reference_list tests/fields/fields.py /^ def test_generic_reference_list(self):$/;" m class:FieldTest -test_generic_reference_list_choices mongoengine/tests/fields/fields.py /^ def test_generic_reference_list_choices(self):$/;" m class:FieldTest -test_generic_reference_list_choices tests/fields/fields.py /^ def test_generic_reference_list_choices(self):$/;" m class:FieldTest -test_generic_reference_list_item_modification mongoengine/tests/fields/fields.py /^ def test_generic_reference_list_item_modification(self):$/;" m class:FieldTest -test_generic_reference_list_item_modification tests/fields/fields.py /^ def test_generic_reference_list_item_modification(self):$/;" m class:FieldTest -test_generic_reference_map_field mongoengine/tests/test_dereference.py /^ def test_generic_reference_map_field(self):$/;" m class:FieldTest -test_generic_reference_save_doesnt_cause_extra_queries mongoengine/tests/test_dereference.py /^ def test_generic_reference_save_doesnt_cause_extra_queries(self):$/;" m class:FieldTest -test_generic_reference_string_choices mongoengine/tests/fields/fields.py /^ def test_generic_reference_string_choices(self):$/;" m class:FieldTest -test_generic_reference_string_choices tests/fields/fields.py /^ def test_generic_reference_string_choices(self):$/;" m class:FieldTest -test_geo_indexes_auto_index mongoengine/tests/fields/geo.py /^ def test_geo_indexes_auto_index(self):$/;" m class:GeoFieldTest -test_geo_indexes_recursion mongoengine/tests/fields/geo.py /^ def test_geo_indexes_recursion(self):$/;" m class:GeoFieldTest -test_geo_spatial_embedded mongoengine/tests/queryset/geo.py /^ def test_geo_spatial_embedded(self):$/;" m class:GeoQueriesTest -test_geojson_LineStringField mongoengine/tests/queryset/transform.py /^ def test_geojson_LineStringField(self):$/;" m class:TransformTest -test_geojson_PointField mongoengine/tests/queryset/transform.py /^ def test_geojson_PointField(self):$/;" m class:TransformTest -test_geojson_PolygonField mongoengine/tests/queryset/geo.py /^ def test_geojson_PolygonField(self):$/;" m class:GeoQueriesTest -test_geojson_PolygonField mongoengine/tests/queryset/transform.py /^ def test_geojson_PolygonField(self):$/;" m class:TransformTest -test_geopoint_embedded_indexes mongoengine/tests/fields/geo.py /^ def test_geopoint_embedded_indexes(self):$/;" m class:GeoFieldTest -test_geopoint_validation mongoengine/tests/fields/geo.py /^ def test_geopoint_validation(self):$/;" m class:GeoFieldTest -test_get mongoengine/tests/test_datastructures.py /^ def test_get(self):$/;" m class:TestStrictDict -test_get_changed_fields_query_count mongoengine/tests/queryset/queryset.py /^ def test_get_changed_fields_query_count(self):$/;" m class:QuerySetTest -test_get_collection mongoengine/tests/document/class_methods.py /^ def test_get_collection(self):$/;" m class:ClassMethodsTest -test_get_collection_name mongoengine/tests/document/class_methods.py /^ def test_get_collection_name(self):$/;" m class:ClassMethodsTest -test_get_db mongoengine/tests/document/class_methods.py /^ def test_get_db(self):$/;" m class:ClassMethodsTest -test_get_image_by_grid_id mongoengine/tests/fields/file_tests.py /^ def test_get_image_by_grid_id(self):$/;" m class:FileTest -test_handle_old_style_references mongoengine/tests/test_dereference.py /^ def test_handle_old_style_references(self):$/;" m class:FieldTest -test_hashed_indexes mongoengine/tests/document/indexes.py /^ def test_hashed_indexes(self):$/;" m class:IndexesTest -test_hint mongoengine/tests/document/indexes.py /^ def test_hint(self):$/;" m class:IndexesTest -test_image_field mongoengine/tests/fields/file_tests.py /^ def test_image_field(self):$/;" m class:FileTest -test_image_field_reassigning mongoengine/tests/fields/file_tests.py /^ def test_image_field_reassigning(self):$/;" m class:FileTest -test_image_field_resize mongoengine/tests/fields/file_tests.py /^ def test_image_field_resize(self):$/;" m class:FileTest -test_image_field_resize_force mongoengine/tests/fields/file_tests.py /^ def test_image_field_resize_force(self):$/;" m class:FileTest -test_image_field_thumbnail mongoengine/tests/fields/file_tests.py /^ def test_image_field_thumbnail(self):$/;" m class:FileTest -test_in_operator_on_non_iterable mongoengine/tests/queryset/queryset.py /^ def test_in_operator_on_non_iterable(self):$/;" m class:QuerySetTest -test_include_exclude mongoengine/tests/queryset/field_list.py /^ def test_include_exclude(self):$/;" m class:QueryFieldListTest -test_include_include mongoengine/tests/queryset/field_list.py /^ def test_include_include(self):$/;" m class:QueryFieldListTest -test_index_dont_send_cls_option mongoengine/tests/document/indexes.py /^ def test_index_dont_send_cls_option(self):$/;" m class:IndexesTest -test_index_no_cls mongoengine/tests/document/indexes.py /^ def test_index_no_cls(self):$/;" m class:IndexesTest -test_index_on_id mongoengine/tests/document/indexes.py /^ def test_index_on_id(self):$/;" m class:IndexesTest -test_index_with_pk mongoengine/tests/document/indexes.py /^ def test_index_with_pk(self):$/;" m class:IndexesTest -test_indexes_2dsphere mongoengine/tests/fields/geo.py /^ def test_indexes_2dsphere(self):$/;" m class:GeoFieldTest -test_indexes_2dsphere_embedded mongoengine/tests/fields/geo.py /^ def test_indexes_2dsphere_embedded(self):$/;" m class:GeoFieldTest -test_indexes_after_database_drop mongoengine/tests/document/indexes.py /^ def test_indexes_after_database_drop(self):$/;" m class:IndexesTest -test_indexes_and_multiple_inheritance mongoengine/tests/document/inheritance.py /^ def test_indexes_and_multiple_inheritance(self):$/;" m class:InheritanceTest -test_indexes_document mongoengine/tests/document/indexes.py /^ def test_indexes_document(self):$/;" m class:IndexesTest -test_indexes_document_inheritance mongoengine/tests/document/indexes.py /^ def test_indexes_document_inheritance(self):$/;" m class:IndexesTest -test_indexes_dynamic_document mongoengine/tests/document/indexes.py /^ def test_indexes_dynamic_document(self):$/;" m class:IndexesTest -test_indexes_dynamic_document_inheritance mongoengine/tests/document/indexes.py /^ def test_indexes_dynamic_document_inheritance(self):$/;" m class:IndexesTest -test_indexes_geopoint mongoengine/tests/fields/geo.py /^ def test_indexes_geopoint(self):$/;" m class:GeoFieldTest -test_inherit_objects mongoengine/tests/queryset/queryset.py /^ def test_inherit_objects(self):$/;" m class:QuerySetTest -test_inherit_objects_override mongoengine/tests/queryset/queryset.py /^ def test_inherit_objects_override(self):$/;" m class:QuerySetTest -test_inheritance mongoengine/tests/document/dynamic.py /^ def test_inheritance(self):$/;" m class:DynamicTest -test_inheritance_meta_data mongoengine/tests/document/inheritance.py /^ def test_inheritance_meta_data(self):$/;" m class:InheritanceTest -test_inheritance_to_mongo_keys mongoengine/tests/document/inheritance.py /^ def test_inheritance_to_mongo_keys(self):$/;" m class:InheritanceTest -test_inherited_collections mongoengine/tests/document/inheritance.py /^ def test_inherited_collections(self):$/;" m class:InheritanceTest -test_inherited_index mongoengine/tests/document/indexes.py /^ def test_inherited_index(self):$/;" m class:IndexesTest -test_inherited_sequencefield mongoengine/tests/fields/fields.py /^ def test_inherited_sequencefield(self):$/;" m class:FieldTest -test_inherited_sequencefield tests/fields/fields.py /^ def test_inherited_sequencefield(self):$/;" m class:FieldTest -test_init mongoengine/tests/test_datastructures.py /^ def test_init(self):$/;" m class:TestStrictDict -test_init_fails_on_nonexisting_attrs mongoengine/tests/test_datastructures.py /^ def test_init_fails_on_nonexisting_attrs(self):$/;" m class:TestStrictDict -test_initialisation mongoengine/tests/queryset/queryset.py /^ def test_initialisation(self):$/;" m class:QuerySetTest -test_inserts_if_you_set_the_pk mongoengine/tests/document/instance.py /^ def test_inserts_if_you_set_the_pk(self):$/;" m class:InstanceTest -test_instance_is_set_on_setattr mongoengine/tests/document/instance.py /^ def test_instance_is_set_on_setattr(self):$/;" m class:InstanceTest -test_instance_is_set_on_setattr_on_embedded_document_list mongoengine/tests/document/instance.py /^ def test_instance_is_set_on_setattr_on_embedded_document_list(self):$/;" m class:InstanceTest -test_int_and_float_ne_operator mongoengine/tests/fields/fields.py /^ def test_int_and_float_ne_operator(self):$/;" m class:FieldTest -test_int_and_float_ne_operator tests/fields/fields.py /^ def test_int_and_float_ne_operator(self):$/;" m class:FieldTest -test_int_validation mongoengine/tests/fields/fields.py /^ def test_int_validation(self):$/;" m class:FieldTest -test_int_validation tests/fields/fields.py /^ def test_int_validation(self):$/;" m class:FieldTest -test_invalid_dict_value mongoengine/tests/fields/fields.py /^ def test_invalid_dict_value(self):$/;" m class:FieldTest -test_invalid_dict_value tests/fields/fields.py /^ def test_invalid_dict_value(self):$/;" m class:FieldTest -test_invalid_reverse_delete_rule_raise_errors mongoengine/tests/document/instance.py /^ def test_invalid_reverse_delete_rule_raise_errors(self):$/;" m class:InstanceTest -test_invalid_son mongoengine/tests/document/instance.py /^ def test_invalid_son(self):$/;" m class:InstanceTest -test_item_frequencies mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies(self):$/;" m class:QuerySetTest -test_item_frequencies_normalize mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_normalize(self):$/;" m class:QuerySetTest -test_item_frequencies_null_values mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_null_values(self):$/;" m class:QuerySetTest -test_item_frequencies_on_embedded mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_on_embedded(self):$/;" m class:QuerySetTest -test_item_frequencies_with_0_values mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_with_0_values(self):$/;" m class:QuerySetTest -test_item_frequencies_with_False_values mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_with_False_values(self):$/;" m class:QuerySetTest -test_item_frequencies_with_null_embedded mongoengine/tests/queryset/queryset.py /^ def test_item_frequencies_with_null_embedded(self):$/;" m class:QuerySetTest -test_items mongoengine/tests/test_datastructures.py /^ def test_items(self):$/;" m class:TestStrictDict -test_iteration_within_iteration mongoengine/tests/queryset/queryset.py /^ def test_iteration_within_iteration(self):$/;" m class:QuerySetTest -test_json_complex mongoengine/tests/document/json_serialisation.py /^ def test_json_complex(self):$/;" m class:TestJson -test_json_complex mongoengine/tests/queryset/queryset.py /^ def test_json_complex(self):$/;" m class:QuerySetTest -test_json_names mongoengine/tests/document/json_serialisation.py /^ def test_json_names(self):$/;" m class:TestJson -test_json_simple mongoengine/tests/document/json_serialisation.py /^ def test_json_simple(self):$/;" m class:TestJson -test_json_simple mongoengine/tests/queryset/queryset.py /^ def test_json_simple(self):$/;" m class:QuerySetTest -test_keyword_multiple_return_get mongoengine/tests/fields/fields.py /^ def test_keyword_multiple_return_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_keyword_multiple_return_get tests/fields/fields.py /^ def test_keyword_multiple_return_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_kwargs_complex mongoengine/tests/document/instance.py /^ def test_kwargs_complex(self):$/;" m class:InstanceTest -test_kwargs_simple mongoengine/tests/document/instance.py /^ def test_kwargs_simple(self):$/;" m class:InstanceTest -test_last_field_name_like_operator mongoengine/tests/queryset/transform.py /^ def test_last_field_name_like_operator(self):$/;" m class:TransformTest -test_lazy_reference_bad_set mongoengine/tests/fields/fields.py /^ def test_lazy_reference_bad_set(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_bad_set tests/fields/fields.py /^ def test_lazy_reference_bad_set(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_config mongoengine/tests/fields/fields.py /^ def test_lazy_reference_config(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_config tests/fields/fields.py /^ def test_lazy_reference_config(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_embedded mongoengine/tests/fields/fields.py /^ def test_lazy_reference_embedded(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_embedded tests/fields/fields.py /^ def test_lazy_reference_embedded(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_equality mongoengine/tests/fields/fields.py /^ def test_lazy_reference_equality(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_equality tests/fields/fields.py /^ def test_lazy_reference_equality(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_fetch_invalid_ref mongoengine/tests/fields/fields.py /^ def test_lazy_reference_fetch_invalid_ref(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_fetch_invalid_ref tests/fields/fields.py /^ def test_lazy_reference_fetch_invalid_ref(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_not_set mongoengine/tests/fields/fields.py /^ def test_lazy_reference_not_set(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_not_set tests/fields/fields.py /^ def test_lazy_reference_not_set(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_passthrough mongoengine/tests/fields/fields.py /^ def test_lazy_reference_passthrough(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_passthrough tests/fields/fields.py /^ def test_lazy_reference_passthrough(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_query_conversion mongoengine/tests/fields/fields.py /^ def test_lazy_reference_query_conversion(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_query_conversion tests/fields/fields.py /^ def test_lazy_reference_query_conversion(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_query_conversion_dbref mongoengine/tests/fields/fields.py /^ def test_lazy_reference_query_conversion_dbref(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_query_conversion_dbref tests/fields/fields.py /^ def test_lazy_reference_query_conversion_dbref(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_set mongoengine/tests/fields/fields.py /^ def test_lazy_reference_set(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_set tests/fields/fields.py /^ def test_lazy_reference_set(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_simple mongoengine/tests/fields/fields.py /^ def test_lazy_reference_simple(self):$/;" m class:LazyReferenceFieldTest -test_lazy_reference_simple tests/fields/fields.py /^ def test_lazy_reference_simple(self):$/;" m class:LazyReferenceFieldTest -test_len_during_iteration mongoengine/tests/queryset/queryset.py /^ def test_len_during_iteration(self):$/;" m class:QuerySetTest -test_limit mongoengine/tests/queryset/queryset.py /^ def test_limit(self):$/;" m class:QuerySetTest -test_limit_with_write_concern_0 mongoengine/tests/queryset/queryset.py /^ def test_limit_with_write_concern_0(self):$/;" m class:QuerySetTest -test_linestring mongoengine/tests/queryset/geo.py /^ def test_linestring(self):$/;" m class:GeoQueriesTest -test_linestring_validation mongoengine/tests/fields/geo.py /^ def test_linestring_validation(self):$/;" m class:GeoFieldTest -test_list_assignment mongoengine/tests/fields/fields.py /^ def test_list_assignment(self):$/;" m class:FieldTest -test_list_assignment tests/fields/fields.py /^ def test_list_assignment(self):$/;" m class:FieldTest -test_list_embedded_document_index mongoengine/tests/document/indexes.py /^ def test_list_embedded_document_index(self):$/;" m class:IndexesTest -test_list_field mongoengine/tests/fields/fields.py /^ def test_list_field(self):$/;" m class:FieldTest -test_list_field tests/fields/fields.py /^ def test_list_field(self):$/;" m class:FieldTest -test_list_field_complex mongoengine/tests/fields/fields.py /^ def test_list_field_complex(self):$/;" m class:FieldTest -test_list_field_complex mongoengine/tests/test_dereference.py /^ def test_list_field_complex(self):$/;" m class:FieldTest -test_list_field_complex tests/fields/fields.py /^ def test_list_field_complex(self):$/;" m class:FieldTest -test_list_field_invalid_operators mongoengine/tests/fields/fields.py /^ def test_list_field_invalid_operators(self):$/;" m class:FieldTest -test_list_field_invalid_operators tests/fields/fields.py /^ def test_list_field_invalid_operators(self):$/;" m class:FieldTest -test_list_field_lexicographic_operators mongoengine/tests/fields/fields.py /^ def test_list_field_lexicographic_operators(self):$/;" m class:FieldTest -test_list_field_lexicographic_operators tests/fields/fields.py /^ def test_list_field_lexicographic_operators(self):$/;" m class:FieldTest -test_list_field_manipulative_operators mongoengine/tests/fields/fields.py /^ def test_list_field_manipulative_operators(self):$/;" m class:FieldTest -test_list_field_manipulative_operators tests/fields/fields.py /^ def test_list_field_manipulative_operators(self):$/;" m class:FieldTest -test_list_field_passed_in_value mongoengine/tests/fields/fields.py /^ def test_list_field_passed_in_value(self):$/;" m class:FieldTest -test_list_field_passed_in_value tests/fields/fields.py /^ def test_list_field_passed_in_value(self):$/;" m class:FieldTest -test_list_field_rejects_strings mongoengine/tests/fields/fields.py /^ def test_list_field_rejects_strings(self):$/;" m class:FieldTest -test_list_field_rejects_strings tests/fields/fields.py /^ def test_list_field_rejects_strings(self):$/;" m class:FieldTest -test_list_field_strict mongoengine/tests/fields/fields.py /^ def test_list_field_strict(self):$/;" m class:FieldTest -test_list_field_strict tests/fields/fields.py /^ def test_list_field_strict(self):$/;" m class:FieldTest -test_list_field_with_negative_indices mongoengine/tests/fields/fields.py /^ def test_list_field_with_negative_indices(self):$/;" m class:FieldTest -test_list_field_with_negative_indices tests/fields/fields.py /^ def test_list_field_with_negative_indices(self):$/;" m class:FieldTest -test_list_indexes_inheritance mongoengine/tests/document/class_methods.py /^ def test_list_indexes_inheritance(self):$/;" m class:ClassMethodsTest -test_list_item_dereference mongoengine/tests/fields/fields.py /^ def test_list_item_dereference(self):$/;" m class:FieldTest -test_list_item_dereference mongoengine/tests/test_dereference.py /^ def test_list_item_dereference(self):$/;" m class:FieldTest -test_list_item_dereference tests/fields/fields.py /^ def test_list_item_dereference(self):$/;" m class:FieldTest -test_list_item_dereference_dref_false mongoengine/tests/test_dereference.py /^ def test_list_item_dereference_dref_false(self):$/;" m class:FieldTest -test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries mongoengine/tests/test_dereference.py /^ def test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries(self):$/;" m class:FieldTest -test_list_item_dereference_dref_false_stores_as_type mongoengine/tests/test_dereference.py /^ def test_list_item_dereference_dref_false_stores_as_type(self):$/;" m class:FieldTest -test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries mongoengine/tests/test_dereference.py /^ def test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries(self):$/;" m class:FieldTest -test_list_iter mongoengine/tests/document/instance.py /^ def test_list_iter(self):$/;" m class:InstanceTest -test_list_lookup_not_checked_in_map mongoengine/tests/test_dereference.py /^ def test_list_lookup_not_checked_in_map(self):$/;" m class:FieldTest -test_list_of_lists_of_references mongoengine/tests/test_dereference.py /^ def test_list_of_lists_of_references(self):$/;" m class:FieldTest -test_list_search_by_embedded mongoengine/tests/document/instance.py /^ def test_list_search_by_embedded(self):$/;" m class:InstanceTest -test_list_validation mongoengine/tests/fields/fields.py /^ def test_list_validation(self):$/;" m class:FieldTest -test_list_validation tests/fields/fields.py /^ def test_list_validation(self):$/;" m class:FieldTest -test_load_undefined_fields mongoengine/tests/document/instance.py /^ def test_load_undefined_fields(self):$/;" m class:InstanceTest -test_load_undefined_fields_on_embedded_document mongoengine/tests/document/instance.py /^ def test_load_undefined_fields_on_embedded_document(self):$/;" m class:InstanceTest -test_load_undefined_fields_on_embedded_document_with_strict_false mongoengine/tests/document/instance.py /^ def test_load_undefined_fields_on_embedded_document_with_strict_false(self):$/;" m class:InstanceTest -test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc mongoengine/tests/document/instance.py /^ def test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc(self):$/;" m class:InstanceTest -test_load_undefined_fields_with_strict_false mongoengine/tests/document/instance.py /^ def test_load_undefined_fields_with_strict_false(self):$/;" m class:InstanceTest -test_long_field_is_considered_as_int64 mongoengine/tests/fields/fields.py /^ def test_long_field_is_considered_as_int64(self):$/;" m class:FieldTest -test_long_field_is_considered_as_int64 tests/fields/fields.py /^ def test_long_field_is_considered_as_int64(self):$/;" m class:FieldTest -test_long_ne_operator mongoengine/tests/fields/fields.py /^ def test_long_ne_operator(self):$/;" m class:FieldTest -test_long_ne_operator tests/fields/fields.py /^ def test_long_ne_operator(self):$/;" m class:FieldTest -test_long_validation mongoengine/tests/fields/fields.py /^ def test_long_validation(self):$/;" m class:FieldTest -test_long_validation tests/fields/fields.py /^ def test_long_validation(self):$/;" m class:FieldTest -test_loop_over_invalid_id_does_not_crash mongoengine/tests/queryset/queryset.py /^ def test_loop_over_invalid_id_does_not_crash(self):$/;" m class:QuerySetTest -test_lower_level_mark_as_changed mongoengine/tests/document/delta.py /^ def test_lower_level_mark_as_changed(self):$/;" m class:DeltaTest -test_map_field_lookup mongoengine/tests/fields/fields.py /^ def test_map_field_lookup(self):$/;" m class:FieldTest -test_map_field_lookup tests/fields/fields.py /^ def test_map_field_lookup(self):$/;" m class:FieldTest -test_map_field_reference mongoengine/tests/test_dereference.py /^ def test_map_field_reference(self):$/;" m class:FieldTest -test_map_field_unicode mongoengine/tests/fields/fields.py /^ def test_map_field_unicode(self):$/;" m class:FieldTest -test_map_field_unicode tests/fields/fields.py /^ def test_map_field_unicode(self):$/;" m class:FieldTest -test_map_reduce mongoengine/tests/queryset/queryset.py /^ def test_map_reduce(self):$/;" m class:QuerySetTest -test_map_reduce_custom_output mongoengine/tests/queryset/queryset.py /^ def test_map_reduce_custom_output(self):$/;" m class:QuerySetTest -test_map_reduce_finalize mongoengine/tests/queryset/queryset.py /^ def test_map_reduce_finalize(self):$/;" m class:QuerySetTest -test_map_reduce_with_custom_object_ids mongoengine/tests/queryset/queryset.py /^ def test_map_reduce_with_custom_object_ids(self):$/;" m class:QuerySetTest -test_mapfield mongoengine/tests/fields/fields.py /^ def test_mapfield(self):$/;" m class:FieldTest -test_mapfield tests/fields/fields.py /^ def test_mapfield(self):$/;" m class:FieldTest -test_mapfield_numerical_index mongoengine/tests/fields/fields.py /^ def test_mapfield_numerical_index(self):$/;" m class:FieldTest -test_mapfield_numerical_index tests/fields/fields.py /^ def test_mapfield_numerical_index(self):$/;" m class:FieldTest -test_mapfield_update mongoengine/tests/queryset/queryset.py /^ def test_mapfield_update(self):$/;" m class:QuerySetTest -test_mappings_protocol mongoengine/tests/test_datastructures.py /^ def test_mappings_protocol(self):$/;" m class:TestStrictDict -test_max_time_ms mongoengine/tests/queryset/queryset.py /^ def test_max_time_ms(self):$/;" m class:QuerySetTest -test_migrate_references mongoengine/tests/test_dereference.py /^ def test_migrate_references(self):$/;" m class:FieldTest -test_mix_slice_with_other_fields mongoengine/tests/queryset/field_list.py /^ def test_mix_slice_with_other_fields(self):$/;" m class:OnlyExcludeAllTest -test_mixed_creation mongoengine/tests/document/instance.py /^ def test_mixed_creation(self):$/;" m class:InstanceTest -test_mixed_creation_dynamic mongoengine/tests/document/instance.py /^ def test_mixed_creation_dynamic(self):$/;" m class:InstanceTest -test_mixed_creation_embedded mongoengine/tests/document/instance.py /^ def test_mixed_creation_embedded(self):$/;" m class:InstanceTest -test_mixin_inheritance mongoengine/tests/document/instance.py /^ def test_mixin_inheritance(self):$/;" m class:InstanceTest -test_mixing_only_exclude mongoengine/tests/queryset/field_list.py /^ def test_mixing_only_exclude(self):$/;" m class:OnlyExcludeAllTest -test_model_signals mongoengine/tests/test_signals.py /^ def test_model_signals(self):$/;" m class:SignalTests -test_model_validation mongoengine/tests/document/validation.py /^ def test_model_validation(self):$/;" m class:ValidatorErrorTest -test_modify mongoengine/tests/queryset/modify.py /^ def test_modify(self):$/;" m class:FindAndModifyTest -test_modify_empty mongoengine/tests/document/instance.py /^ def test_modify_empty(self):$/;" m class:InstanceTest -test_modify_invalid_query mongoengine/tests/document/instance.py /^ def test_modify_invalid_query(self):$/;" m class:InstanceTest -test_modify_match_another_document mongoengine/tests/document/instance.py /^ def test_modify_match_another_document(self):$/;" m class:InstanceTest -test_modify_not_existing mongoengine/tests/queryset/modify.py /^ def test_modify_not_existing(self):$/;" m class:FindAndModifyTest -test_modify_not_exists mongoengine/tests/document/instance.py /^ def test_modify_not_exists(self):$/;" m class:InstanceTest -test_modify_update mongoengine/tests/document/instance.py /^ def test_modify_update(self):$/;" m class:InstanceTest -test_modify_with_fields mongoengine/tests/queryset/modify.py /^ def test_modify_with_fields(self):$/;" m class:FindAndModifyTest -test_modify_with_new mongoengine/tests/queryset/modify.py /^ def test_modify_with_new(self):$/;" m class:FindAndModifyTest -test_modify_with_order_by mongoengine/tests/queryset/modify.py /^ def test_modify_with_order_by(self):$/;" m class:FindAndModifyTest -test_modify_with_positional_push mongoengine/tests/document/instance.py /^ def test_modify_with_positional_push(self):$/;" m class:InstanceTest -test_modify_with_push mongoengine/tests/queryset/modify.py /^ def test_modify_with_push(self):$/;" m class:FindAndModifyTest -test_modify_with_remove mongoengine/tests/queryset/modify.py /^ def test_modify_with_remove(self):$/;" m class:FindAndModifyTest -test_modify_with_upsert mongoengine/tests/queryset/modify.py /^ def test_modify_with_upsert(self):$/;" m class:FindAndModifyTest -test_modify_with_upsert_existing mongoengine/tests/queryset/modify.py /^ def test_modify_with_upsert_existing(self):$/;" m class:FindAndModifyTest -test_modify_with_upsert_with_new mongoengine/tests/queryset/modify.py /^ def test_modify_with_upsert_with_new(self):$/;" m class:FindAndModifyTest -test_multi_keyword_exclude mongoengine/tests/fields/fields.py /^ def test_multi_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_multi_keyword_exclude tests/fields/fields.py /^ def test_multi_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_multi_keyword_filter mongoengine/tests/fields/fields.py /^ def test_multi_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_multi_keyword_filter tests/fields/fields.py /^ def test_multi_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_multi_keyword_get mongoengine/tests/fields/fields.py /^ def test_multi_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_multi_keyword_get tests/fields/fields.py /^ def test_multi_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_multidirectional_lists mongoengine/tests/test_dereference.py /^ def test_multidirectional_lists(self):$/;" m class:FieldTest -test_multilinestring_validation mongoengine/tests/fields/geo.py /^ def test_multilinestring_validation(self):$/;" m class:GeoFieldTest -test_multiple_connection_settings mongoengine/tests/test_connection.py /^ def test_multiple_connection_settings(self):$/;" m class:ConnectionTest -test_multiple_occurence_in_field mongoengine/tests/queryset/visitor.py /^ def test_multiple_occurence_in_field(self):$/;" m class:QTest -test_multiple_sequence_fields mongoengine/tests/fields/fields.py /^ def test_multiple_sequence_fields(self):$/;" m class:FieldTest -test_multiple_sequence_fields tests/fields/fields.py /^ def test_multiple_sequence_fields(self):$/;" m class:FieldTest -test_multiple_sequence_fields_on_docs mongoengine/tests/fields/fields.py /^ def test_multiple_sequence_fields_on_docs(self):$/;" m class:FieldTest -test_multiple_sequence_fields_on_docs tests/fields/fields.py /^ def test_multiple_sequence_fields_on_docs(self):$/;" m class:FieldTest -test_multipoint_validation mongoengine/tests/fields/geo.py /^ def test_multipoint_validation(self):$/;" m class:GeoFieldTest -test_multipolygon_validation mongoengine/tests/fields/geo.py /^ def test_multipolygon_validation(self):$/;" m class:GeoFieldTest -test_mutating_documents mongoengine/tests/document/instance.py /^ def test_mutating_documents(self):$/;" m class:InstanceTest -test_near mongoengine/tests/queryset/geo.py /^ def test_near(self):$/;" m class:GeoQueriesTest -test_near_and_max_distance mongoengine/tests/queryset/geo.py /^ def test_near_and_max_distance(self):$/;" m class:GeoQueriesTest -test_near_and_min_distance mongoengine/tests/queryset/geo.py /^ def test_near_and_min_distance(self):$/;" m class:GeoQueriesTest -test_nested_nested_fields_mark_as_changed mongoengine/tests/document/delta.py /^ def test_nested_nested_fields_mark_as_changed(self):$/;" m class:DeltaTest -test_nested_queryset_iterator mongoengine/tests/queryset/queryset.py /^ def test_nested_queryset_iterator(self):$/;" m class:QuerySetTest -test_no_cache mongoengine/tests/queryset/queryset.py /^ def test_no_cache(self):$/;" m class:QuerySetTest -test_no_cached_queryset mongoengine/tests/queryset/queryset.py /^ def test_no_cached_queryset(self):$/;" m class:QuerySetTest -test_no_dereference mongoengine/tests/queryset/queryset.py /^ def test_no_dereference(self):$/;" m class:QuerySetTest -test_no_dereference_context_manager_dbref mongoengine/tests/test_context_managers.py /^ def test_no_dereference_context_manager_dbref(self):$/;" m class:ContextManagersTest -test_no_dereference_context_manager_object_id mongoengine/tests/test_context_managers.py /^ def test_no_dereference_context_manager_object_id(self):$/;" m class:ContextManagersTest -test_no_dereference_embedded_doc mongoengine/tests/queryset/queryset.py /^ def test_no_dereference_embedded_doc(self):$/;" m class:QuerySetTest -test_no_inherited_sequencefield mongoengine/tests/fields/fields.py /^ def test_no_inherited_sequencefield(self):$/;" m class:FieldTest -test_no_inherited_sequencefield tests/fields/fields.py /^ def test_no_inherited_sequencefield(self):$/;" m class:FieldTest -test_no_keyword_exclude mongoengine/tests/fields/fields.py /^ def test_no_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_no_keyword_exclude tests/fields/fields.py /^ def test_no_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_no_keyword_filter mongoengine/tests/fields/fields.py /^ def test_no_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_no_keyword_filter tests/fields/fields.py /^ def test_no_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_no_keyword_multiple_return_get mongoengine/tests/fields/fields.py /^ def test_no_keyword_multiple_return_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_no_keyword_multiple_return_get tests/fields/fields.py /^ def test_no_keyword_multiple_return_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_no_keyword_update mongoengine/tests/fields/fields.py /^ def test_no_keyword_update(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_no_keyword_update tests/fields/fields.py /^ def test_no_keyword_update(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_no_ordering_for_get mongoengine/tests/queryset/queryset.py /^ def test_no_ordering_for_get(self):$/;" m class:QuerySetTest -test_no_result_get mongoengine/tests/fields/fields.py /^ def test_no_result_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_no_result_get tests/fields/fields.py /^ def test_no_result_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_no_sub_classes mongoengine/tests/queryset/queryset.py /^ def test_no_sub_classes(self):$/;" m class:QuerySetTest -test_no_sub_classes mongoengine/tests/test_context_managers.py /^ def test_no_sub_classes(self):$/;" m class:ContextManagersTest -test_non_ascii_pk mongoengine/tests/test_dereference.py /^ def test_non_ascii_pk(self):$/;" m class:FieldTest -test_non_matching_exclude mongoengine/tests/fields/fields.py /^ def test_non_matching_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_non_matching_exclude tests/fields/fields.py /^ def test_non_matching_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_none mongoengine/tests/queryset/queryset.py /^ def test_none(self):$/;" m class:QuerySetTest -test_not mongoengine/tests/queryset/queryset.py /^ def test_not(self):$/;" m class:QuerySetTest -test_not_required_handles_none_from_database mongoengine/tests/fields/fields.py /^ def test_not_required_handles_none_from_database(self):$/;" m class:FieldTest -test_not_required_handles_none_from_database tests/fields/fields.py /^ def test_not_required_handles_none_from_database(self):$/;" m class:FieldTest -test_not_required_handles_none_in_update mongoengine/tests/fields/fields.py /^ def test_not_required_handles_none_in_update(self):$/;" m class:FieldTest -test_not_required_handles_none_in_update tests/fields/fields.py /^ def test_not_required_handles_none_in_update(self):$/;" m class:FieldTest -test_not_saved_eq mongoengine/tests/document/instance.py /^ def test_not_saved_eq(self):$/;" m class:InstanceTest -test_null_field mongoengine/tests/document/instance.py /^ def test_null_field(self):$/;" m class:InstanceTest -test_object_id_validation mongoengine/tests/fields/fields.py /^ def test_object_id_validation(self):$/;" m class:FieldTest -test_object_id_validation tests/fields/fields.py /^ def test_object_id_validation(self):$/;" m class:FieldTest -test_object_mixins mongoengine/tests/document/instance.py /^ def test_object_mixins(self):$/;" m class:InstanceTest -test_objectid_reference_across_databases mongoengine/tests/test_dereference.py /^ def test_objectid_reference_across_databases(self):$/;" m class:FieldTest -test_objectid_reference_fields mongoengine/tests/fields/fields.py /^ def test_objectid_reference_fields(self):$/;" m class:FieldTest -test_objectid_reference_fields tests/fields/fields.py /^ def test_objectid_reference_fields(self):$/;" m class:FieldTest -test_only mongoengine/tests/queryset/field_list.py /^ def test_only(self):$/;" m class:OnlyExcludeAllTest -test_only_with_subfields mongoengine/tests/queryset/field_list.py /^ def test_only_with_subfields(self):$/;" m class:OnlyExcludeAllTest -test_or_and_or_combination mongoengine/tests/queryset/visitor.py /^ def test_or_and_or_combination(self):$/;" m class:QTest -test_or_combination mongoengine/tests/queryset/visitor.py /^ def test_or_combination(self):$/;" m class:QTest -test_order_by mongoengine/tests/queryset/queryset.py /^ def test_order_by(self):$/;" m class:QuerySetTest -test_order_by_chaining mongoengine/tests/queryset/queryset.py /^ def test_order_by_chaining(self):$/;" m class:QuerySetTest -test_order_by_list mongoengine/tests/queryset/queryset.py /^ def test_order_by_list(self):$/;" m class:QuerySetTest -test_order_by_optional mongoengine/tests/queryset/queryset.py /^ def test_order_by_optional(self):$/;" m class:QuerySetTest -test_order_then_filter mongoengine/tests/queryset/queryset.py /^ def test_order_then_filter(self):$/;" m class:QuerySetTest -test_order_works_with_custom_db_field_names mongoengine/tests/queryset/queryset.py /^ def test_order_works_with_custom_db_field_names(self):$/;" m class:QuerySetTest -test_order_works_with_primary mongoengine/tests/queryset/queryset.py /^ def test_order_works_with_primary(self):$/;" m class:QuerySetTest -test_ordering mongoengine/tests/queryset/queryset.py /^ def test_ordering(self):$/;" m class:QuerySetTest -test_override_method_with_field mongoengine/tests/document/instance.py /^ def test_override_method_with_field(self):$/;" m class:InstanceTest -test_parent_reference_in_child_document mongoengine/tests/document/validation.py /^ def test_parent_reference_in_child_document(self):$/;" m class:ValidatorErrorTest -test_parent_reference_set_as_attribute_in_child_document mongoengine/tests/document/validation.py /^ def test_parent_reference_set_as_attribute_in_child_document(self):$/;" m class:ValidatorErrorTest -test_picke_simple_qs mongoengine/tests/queryset/pickable.py /^ def test_picke_simple_qs(self):$/;" m class:TestQuerysetPickable -test_picklable mongoengine/tests/document/instance.py /^ def test_picklable(self):$/;" m class:InstanceTest -test_picklable_on_signals mongoengine/tests/document/instance.py /^ def test_picklable_on_signals(self):$/;" m class:InstanceTest -test_pickle_support_filtration mongoengine/tests/queryset/pickable.py /^ def test_pickle_support_filtration(self):$/;" m class:TestQuerysetPickable -test_point_validation mongoengine/tests/fields/geo.py /^ def test_point_validation(self):$/;" m class:GeoFieldTest -test_polygon mongoengine/tests/queryset/geo.py /^ def test_polygon(self):$/;" m class:GeoQueriesTest -test_polygon_validation mongoengine/tests/fields/geo.py /^ def test_polygon_validation(self):$/;" m class:GeoFieldTest -test_polymorphic_queries mongoengine/tests/document/inheritance.py /^ def test_polymorphic_queries(self):$/;" m class:InheritanceTest -test_polymorphic_references mongoengine/tests/document/instance.py /^ def test_polymorphic_references(self):$/;" m class:InstanceTest -test_positional_creation mongoengine/tests/document/instance.py /^ def test_positional_creation(self):$/;" m class:InstanceTest -test_positional_creation_embedded mongoengine/tests/document/instance.py /^ def test_positional_creation_embedded(self):$/;" m class:InstanceTest -test_pull_from_nested_embedded mongoengine/tests/queryset/queryset.py /^ def test_pull_from_nested_embedded(self):$/;" m class:QuerySetTest -test_pull_from_nested_mapfield mongoengine/tests/queryset/queryset.py /^ def test_pull_from_nested_mapfield(self):$/;" m class:QuerySetTest -test_pull_in_genericembedded_field mongoengine/tests/queryset/queryset.py /^ def test_pull_in_genericembedded_field(self):$/;" m class:QuerySetTest -test_pull_nested mongoengine/tests/queryset/queryset.py /^ def test_pull_nested(self):$/;" m class:QuerySetTest -test_push_nested_list mongoengine/tests/document/instance.py /^ def test_push_nested_list(self):$/;" m class:InstanceTest -test_push_with_position mongoengine/tests/document/instance.py /^ def test_push_with_position(self):$/;" m class:InstanceTest -test_q mongoengine/tests/queryset/visitor.py /^ def test_q(self):$/;" m class:QTest -test_q_clone mongoengine/tests/queryset/visitor.py /^ def test_q_clone(self):$/;" m class:QTest -test_q_lists mongoengine/tests/queryset/visitor.py /^ def test_q_lists(self):$/;" m class:QTest -test_q_merge_queries_edge_case mongoengine/tests/queryset/visitor.py /^ def test_q_merge_queries_edge_case(self):$/;" m class:QTest -test_q_regex mongoengine/tests/queryset/visitor.py /^ def test_q_regex(self):$/;" m class:QTest -test_q_with_dbref mongoengine/tests/queryset/visitor.py /^ def test_q_with_dbref(self):$/;" m class:QTest -test_query_count_when_saving mongoengine/tests/document/instance.py /^ def test_query_count_when_saving(self):$/;" m class:InstanceTest -test_query_counter mongoengine/tests/test_context_managers.py /^ def test_query_counter(self):$/;" m class:ContextManagersTest -test_query_field_name mongoengine/tests/queryset/transform.py /^ def test_query_field_name(self):$/;" m class:TransformTest -test_query_generic_embedded_document mongoengine/tests/queryset/queryset.py /^ def test_query_generic_embedded_document(self):$/;" m class:QuerySetTest -test_query_pk_field_name mongoengine/tests/queryset/transform.py /^ def test_query_pk_field_name(self):$/;" m class:TransformTest -test_query_reference_to_custom_pk_doc mongoengine/tests/queryset/queryset.py /^ def test_query_reference_to_custom_pk_doc(self):$/;" m class:QuerySetTest -test_query_value_conversion mongoengine/tests/queryset/queryset.py /^ def test_query_value_conversion(self):$/;" m class:QuerySetTest -test_queryset_aggregation_framework mongoengine/tests/queryset/queryset.py /^ def test_queryset_aggregation_framework(self):$/;" m class:QuerySetTest -test_queryset_delete_signals mongoengine/tests/test_signals.py /^ def test_queryset_delete_signals(self):$/;" m class:SignalTests -test_queryset_resurrects_dropped_collection mongoengine/tests/document/instance.py /^ def test_queryset_resurrects_dropped_collection(self):$/;" m class:InstanceTest -test_raw_and_merging mongoengine/tests/queryset/transform.py /^ def test_raw_and_merging(self):$/;" m class:TransformTest -test_raw_query_and_Q_objects mongoengine/tests/queryset/transform.py /^ def test_raw_query_and_Q_objects(self):$/;" m class:TransformTest -test_read_preference mongoengine/tests/queryset/queryset.py /^ def test_read_preference(self):$/;" m class:QuerySetTest -test_recursive_embedded_objects_dont_break_indexes mongoengine/tests/document/indexes.py /^ def test_recursive_embedded_objects_dont_break_indexes(self):$/;" m class:IndexesTest -test_recursive_embedding mongoengine/tests/fields/fields.py /^ def test_recursive_embedding(self):$/;" m class:FieldTest -test_recursive_embedding tests/fields/fields.py /^ def test_recursive_embedding(self):$/;" m class:FieldTest -test_recursive_reference mongoengine/tests/fields/fields.py /^ def test_recursive_reference(self):$/;" m class:FieldTest -test_recursive_reference mongoengine/tests/test_dereference.py /^ def test_recursive_reference(self):$/;" m class:FieldTest -test_recursive_reference tests/fields/fields.py /^ def test_recursive_reference(self):$/;" m class:FieldTest -test_recursive_validation mongoengine/tests/fields/fields.py /^ def test_recursive_validation(self):$/;" m class:FieldTest -test_recursive_validation tests/fields/fields.py /^ def test_recursive_validation(self):$/;" m class:FieldTest -test_reference_abstract_class mongoengine/tests/fields/fields.py /^ def test_reference_abstract_class(self):$/;" m class:FieldTest -test_reference_abstract_class tests/fields/fields.py /^ def test_reference_abstract_class(self):$/;" m class:FieldTest -test_reference_class_with_abstract_parent mongoengine/tests/fields/fields.py /^ def test_reference_class_with_abstract_parent(self):$/;" m class:FieldTest -test_reference_class_with_abstract_parent tests/fields/fields.py /^ def test_reference_class_with_abstract_parent(self):$/;" m class:FieldTest -test_reference_field_find mongoengine/tests/queryset/queryset.py /^ def test_reference_field_find(self):$/;" m class:QuerySetTest -test_reference_field_find_dbref mongoengine/tests/queryset/queryset.py /^ def test_reference_field_find_dbref(self):$/;" m class:QuerySetTest -test_reference_inheritance mongoengine/tests/document/instance.py /^ def test_reference_inheritance(self):$/;" m class:InstanceTest -test_reference_miss mongoengine/tests/fields/fields.py /^ def test_reference_miss(self):$/;" m class:FieldTest -test_reference_miss tests/fields/fields.py /^ def test_reference_miss(self):$/;" m class:FieldTest -test_reference_query_conversion mongoengine/tests/fields/fields.py /^ def test_reference_query_conversion(self):$/;" m class:FieldTest -test_reference_query_conversion tests/fields/fields.py /^ def test_reference_query_conversion(self):$/;" m class:FieldTest -test_reference_query_conversion_dbref mongoengine/tests/fields/fields.py /^ def test_reference_query_conversion_dbref(self):$/;" m class:FieldTest -test_reference_query_conversion_dbref tests/fields/fields.py /^ def test_reference_query_conversion_dbref(self):$/;" m class:FieldTest -test_reference_validation mongoengine/tests/fields/fields.py /^ def test_reference_validation(self):$/;" m class:FieldTest -test_reference_validation tests/fields/fields.py /^ def test_reference_validation(self):$/;" m class:FieldTest -test_referenced_object_changed_attributes mongoengine/tests/document/delta.py /^ def test_referenced_object_changed_attributes(self):$/;" m class:DeltaTest -test_regex_query_shortcuts mongoengine/tests/queryset/queryset.py /^ def test_regex_query_shortcuts(self):$/;" m class:QuerySetTest -test_register_connection mongoengine/tests/test_connection.py /^ def test_register_connection(self):$/;" m class:ConnectionTest -test_register_connection_defaults mongoengine/tests/test_connection.py /^ def test_register_connection_defaults(self):$/;" m class:ConnectionTest -test_register_delete_rule mongoengine/tests/document/class_methods.py /^ def test_register_delete_rule(self):$/;" m class:ClassMethodsTest -test_register_delete_rule_inherited mongoengine/tests/document/class_methods.py /^ def test_register_delete_rule_inherited(self):$/;" m class:ClassMethodsTest -test_regular_document_pickle mongoengine/tests/document/instance.py /^ def test_regular_document_pickle(self):$/;" m class:InstanceTest -test_reload mongoengine/tests/document/instance.py /^ def test_reload(self):$/;" m class:InstanceTest -test_reload_after_unsetting mongoengine/tests/document/dynamic.py /^ def test_reload_after_unsetting(self):$/;" m class:DynamicTest -test_reload_doesnt_exist mongoengine/tests/document/instance.py /^ def test_reload_doesnt_exist(self):$/;" m class:InstanceTest -test_reload_dynamic_field mongoengine/tests/document/dynamic.py /^ def test_reload_dynamic_field(self):$/;" m class:DynamicTest -test_reload_embedded_docs_instance mongoengine/tests/queryset/queryset.py /^ def test_reload_embedded_docs_instance(self):$/;" m class:QuerySetTest -test_reload_list_embedded_docs_instance mongoengine/tests/queryset/queryset.py /^ def test_reload_list_embedded_docs_instance(self):$/;" m class:QuerySetTest -test_reload_of_non_strict_with_special_field_name mongoengine/tests/document/instance.py /^ def test_reload_of_non_strict_with_special_field_name(self):$/;" m class:InstanceTest -test_reload_referencing mongoengine/tests/document/instance.py /^ def test_reload_referencing(self):$/;" m class:InstanceTest -test_reload_sharded mongoengine/tests/document/instance.py /^ def test_reload_sharded(self):$/;" m class:InstanceTest -test_reload_sharded_nested mongoengine/tests/document/instance.py /^ def test_reload_sharded_nested(self):$/;" m class:InstanceTest -test_repeated_iteration mongoengine/tests/queryset/queryset.py /^ def test_repeated_iteration(self):$/;" m class:QuerySetTest -test_replicaset_uri_passes_read_preference mongoengine/tests/test_replicaset_connection.py /^ def test_replicaset_uri_passes_read_preference(self):$/;" m class:ConnectionTest -test_repr mongoengine/tests/document/instance.py /^ def test_repr(self):$/;" m class:InstanceTest -test_repr mongoengine/tests/queryset/queryset.py /^ def test_repr(self):$/;" m class:QuerySetTest -test_repr mongoengine/tests/test_datastructures.py /^ def test_repr(self):$/;" m class:TestStrictDict -test_repr_none mongoengine/tests/document/instance.py /^ def test_repr_none(self):$/;" m class:InstanceTest -test_required_values mongoengine/tests/fields/fields.py /^ def test_required_values(self):$/;" m class:FieldTest -test_required_values tests/fields/fields.py /^ def test_required_values(self):$/;" m class:FieldTest -test_reset mongoengine/tests/queryset/field_list.py /^ def test_reset(self):$/;" m class:QueryFieldListTest -test_reverse_delete_rule_cascade mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_cascade(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_cascade_and_nullify mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_cascade_and_nullify(self):$/;" m class:InstanceTest -test_reverse_delete_rule_cascade_and_nullify_complex_field mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_cascade_and_nullify_complex_field(self):$/;" m class:InstanceTest -test_reverse_delete_rule_cascade_complex_cycle mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_cascade_complex_cycle(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_cascade_cycle mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_cascade_cycle(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_cascade_on_abstract_document mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_cascade_on_abstract_document(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_cascade_recurs mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_cascade_recurs(self):$/;" m class:InstanceTest -test_reverse_delete_rule_cascade_self_referencing mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_cascade_self_referencing(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_cascade_triggers_pre_delete_signal mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_cascade_triggers_pre_delete_signal(self):$/;" m class:InstanceTest -test_reverse_delete_rule_deny mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_deny(self):$/;" m class:InstanceTest -test_reverse_delete_rule_deny mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_deny(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_deny_on_abstract_document mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_deny_on_abstract_document(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_nullify mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_nullify(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_nullify_on_abstract_document mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_nullify_on_abstract_document(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_pull mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_pull(self):$/;" m class:InstanceTest -test_reverse_delete_rule_pull mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_pull(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_pull_on_abstract_documents mongoengine/tests/queryset/queryset.py /^ def test_reverse_delete_rule_pull_on_abstract_documents(self):$/;" m class:QuerySetTest -test_reverse_delete_rule_with_custom_id_field mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_with_custom_id_field(self):$/;" m class:InstanceTest -test_reverse_delete_rule_with_document_inheritance mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_with_document_inheritance(self):$/;" m class:InstanceTest -test_reverse_delete_rule_with_shared_id_among_collections mongoengine/tests/document/instance.py /^ def test_reverse_delete_rule_with_shared_id_among_collections(self):$/;" m class:InstanceTest -test_reverse_list_sorting mongoengine/tests/fields/fields.py /^ def test_reverse_list_sorting(self):$/;" m class:FieldTest -test_reverse_list_sorting tests/fields/fields.py /^ def test_reverse_list_sorting(self):$/;" m class:FieldTest -test_save mongoengine/tests/document/instance.py /^ def test_save(self):$/;" m class:InstanceTest -test_save mongoengine/tests/fields/fields.py /^ def test_save(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_save tests/fields/fields.py /^ def test_save(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_save_abstract_document mongoengine/tests/document/instance.py /^ def test_save_abstract_document(self):$/;" m class:InstanceTest -test_save_and_only_on_fields_with_default mongoengine/tests/queryset/queryset.py /^ def test_save_and_only_on_fields_with_default(self):$/;" m class:QuerySetTest -test_save_atomicity_condition mongoengine/tests/document/instance.py /^ def test_save_atomicity_condition(self):$/;" m class:InstanceTest -test_save_cascade_kwargs mongoengine/tests/document/instance.py /^ def test_save_cascade_kwargs(self):$/;" m class:InstanceTest -test_save_cascade_meta_false mongoengine/tests/document/instance.py /^ def test_save_cascade_meta_false(self):$/;" m class:InstanceTest -test_save_cascade_meta_true mongoengine/tests/document/instance.py /^ def test_save_cascade_meta_true(self):$/;" m class:InstanceTest -test_save_cascades mongoengine/tests/document/instance.py /^ def test_save_cascades(self):$/;" m class:InstanceTest -test_save_cascades_generically mongoengine/tests/document/instance.py /^ def test_save_cascades_generically(self):$/;" m class:InstanceTest -test_save_custom_id mongoengine/tests/document/instance.py /^ def test_save_custom_id(self):$/;" m class:InstanceTest -test_save_custom_pk mongoengine/tests/document/instance.py /^ def test_save_custom_pk(self):$/;" m class:InstanceTest -test_save_embedded_document mongoengine/tests/document/instance.py /^ def test_save_embedded_document(self):$/;" m class:InstanceTest -test_save_list mongoengine/tests/document/instance.py /^ def test_save_list(self):$/;" m class:InstanceTest -test_save_max_recursion_not_hit mongoengine/tests/document/instance.py /^ def test_save_max_recursion_not_hit(self):$/;" m class:InstanceTest -test_save_max_recursion_not_hit_with_file_field mongoengine/tests/document/instance.py /^ def test_save_max_recursion_not_hit_with_file_field(self):$/;" m class:InstanceTest -test_save_only_changed_fields mongoengine/tests/document/instance.py /^ def test_save_only_changed_fields(self):$/;" m class:InstanceTest -test_save_only_changed_fields_recursive mongoengine/tests/document/instance.py /^ def test_save_only_changed_fields_recursive(self):$/;" m class:InstanceTest -test_save_reference mongoengine/tests/document/instance.py /^ def test_save_reference(self):$/;" m class:InstanceTest -test_save_to_a_value_that_equates_to_false mongoengine/tests/document/instance.py /^ def test_save_to_a_value_that_equates_to_false(self):$/;" m class:InstanceTest -test_scalar mongoengine/tests/queryset/queryset.py /^ def test_scalar(self):$/;" m class:QuerySetTest -test_scalar_cursor_behaviour mongoengine/tests/queryset/queryset.py /^ def test_scalar_cursor_behaviour(self):$/;" m class:QuerySetTest -test_scalar_db_field mongoengine/tests/queryset/queryset.py /^ def test_scalar_db_field(self):$/;" m class:QuerySetTest -test_scalar_decimal mongoengine/tests/queryset/queryset.py /^ def test_scalar_decimal(self):$/;" m class:QuerySetTest -test_scalar_embedded mongoengine/tests/queryset/queryset.py /^ def test_scalar_embedded(self):$/;" m class:QuerySetTest -test_scalar_generic_reference_field mongoengine/tests/queryset/queryset.py /^ def test_scalar_generic_reference_field(self):$/;" m class:QuerySetTest -test_scalar_primary_key mongoengine/tests/queryset/queryset.py /^ def test_scalar_primary_key(self):$/;" m class:QuerySetTest -test_scalar_reference_field mongoengine/tests/queryset/queryset.py /^ def test_scalar_reference_field(self):$/;" m class:QuerySetTest -test_scalar_simple mongoengine/tests/queryset/queryset.py /^ def test_scalar_simple(self):$/;" m class:QuerySetTest -test_select_related_follows_embedded_referencefields mongoengine/tests/test_dereference.py /^ def test_select_related_follows_embedded_referencefields(self):$/;" m class:FieldTest -test_sequence_field mongoengine/tests/fields/fields.py /^ def test_sequence_field(self):$/;" m class:FieldTest -test_sequence_field tests/fields/fields.py /^ def test_sequence_field(self):$/;" m class:FieldTest -test_sequence_field_get_next_value mongoengine/tests/fields/fields.py /^ def test_sequence_field_get_next_value(self):$/;" m class:FieldTest -test_sequence_field_get_next_value tests/fields/fields.py /^ def test_sequence_field_get_next_value(self):$/;" m class:FieldTest -test_sequence_field_sequence_name mongoengine/tests/fields/fields.py /^ def test_sequence_field_sequence_name(self):$/;" m class:FieldTest -test_sequence_field_sequence_name tests/fields/fields.py /^ def test_sequence_field_sequence_name(self):$/;" m class:FieldTest -test_sequence_field_value_decorator mongoengine/tests/fields/fields.py /^ def test_sequence_field_value_decorator(self):$/;" m class:FieldTest -test_sequence_field_value_decorator tests/fields/fields.py /^ def test_sequence_field_value_decorator(self):$/;" m class:FieldTest -test_sequence_fields_reload mongoengine/tests/fields/fields.py /^ def test_sequence_fields_reload(self):$/;" m class:FieldTest -test_sequence_fields_reload tests/fields/fields.py /^ def test_sequence_fields_reload(self):$/;" m class:FieldTest -test_set_generic_embedded_documents mongoengine/tests/queryset/queryset.py /^ def test_set_generic_embedded_documents(self):$/;" m class:QuerySetTest -test_set_list_embedded_documents mongoengine/tests/queryset/queryset.py /^ def test_set_list_embedded_documents(self):$/;" m class:QuerySetTest -test_set_on_insert mongoengine/tests/queryset/queryset.py /^ def test_set_on_insert(self):$/;" m class:QuerySetTest -test_set_unset_one_operation mongoengine/tests/document/instance.py /^ def test_set_unset_one_operation(self):$/;" m class:InstanceTest -test_setattr_getattr mongoengine/tests/test_datastructures.py /^ def test_setattr_getattr(self):$/;" m class:TestStrictDict -test_setattr_getattr_special mongoengine/tests/test_datastructures.py /^ def test_setattr_getattr_special(self):$/;" m class:TestStrictDict -test_setattr_raises_on_nonexisting_attr mongoengine/tests/test_datastructures.py /^ def test_setattr_raises_on_nonexisting_attr(self):$/;" m class:TestStrictDict -test_shard_key mongoengine/tests/document/instance.py /^ def test_shard_key(self):$/;" m class:InstanceTest -test_shard_key_in_embedded_document mongoengine/tests/document/instance.py /^ def test_shard_key_in_embedded_document(self):$/;" m class:InstanceTest -test_shard_key_primary mongoengine/tests/document/instance.py /^ def test_shard_key_primary(self):$/;" m class:InstanceTest -test_sharing_connections mongoengine/tests/test_connection.py /^ def test_sharing_connections(self):$/;" m class:ConnectionTest -test_signal_kwargs mongoengine/tests/test_signals.py /^ def test_signal_kwargs(self):$/;" m class:SignalTests -test_signals_bulk_insert mongoengine/tests/test_signals.py /^ def test_signals_bulk_insert(self):$/;" m class:SignalTests -test_signals_with_explicit_doc_ids mongoengine/tests/test_signals.py /^ def test_signals_with_explicit_doc_ids(self):$/;" m class:SignalTests -test_signals_with_switch_collection mongoengine/tests/test_signals.py /^ def test_signals_with_switch_collection(self):$/;" m class:SignalTests -test_signals_with_switch_db mongoengine/tests/test_signals.py /^ def test_signals_with_switch_db(self):$/;" m class:SignalTests -test_simple_choices_get_field_display mongoengine/tests/fields/fields.py /^ def test_simple_choices_get_field_display(self):$/;" m class:FieldTest -test_simple_choices_get_field_display tests/fields/fields.py /^ def test_simple_choices_get_field_display(self):$/;" m class:FieldTest -test_simple_choices_validation mongoengine/tests/fields/fields.py /^ def test_simple_choices_validation(self):$/;" m class:FieldTest -test_simple_choices_validation tests/fields/fields.py /^ def test_simple_choices_validation(self):$/;" m class:FieldTest -test_simple_choices_validation_invalid_value mongoengine/tests/fields/fields.py /^ def test_simple_choices_validation_invalid_value(self):$/;" m class:FieldTest -test_simple_choices_validation_invalid_value tests/fields/fields.py /^ def test_simple_choices_validation_invalid_value(self):$/;" m class:FieldTest -test_simple_dynamic_document mongoengine/tests/document/dynamic.py /^ def test_simple_dynamic_document(self):$/;" m class:DynamicTest -test_single_keyword_exclude mongoengine/tests/fields/fields.py /^ def test_single_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_single_keyword_exclude tests/fields/fields.py /^ def test_single_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_single_keyword_filter mongoengine/tests/fields/fields.py /^ def test_single_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_single_keyword_filter tests/fields/fields.py /^ def test_single_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_single_keyword_get mongoengine/tests/fields/fields.py /^ def test_single_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_single_keyword_get tests/fields/fields.py /^ def test_single_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_single_keyword_update mongoengine/tests/fields/fields.py /^ def test_single_keyword_update(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_single_keyword_update tests/fields/fields.py /^ def test_single_keyword_update(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_skip mongoengine/tests/queryset/queryset.py /^ def test_skip(self):$/;" m class:QuerySetTest -test_slave_okay mongoengine/tests/queryset/queryset.py /^ def test_slave_okay(self):$/;" m class:QuerySetTest -test_slice mongoengine/tests/queryset/queryset.py /^ def test_slice(self):$/;" m class:QuerySetTest -test_slice_marks_field_as_changed mongoengine/tests/fields/fields.py /^ def test_slice_marks_field_as_changed(self):$/;" m class:FieldTest -test_slice_marks_field_as_changed tests/fields/fields.py /^ def test_slice_marks_field_as_changed(self):$/;" m class:FieldTest -test_slicing mongoengine/tests/queryset/field_list.py /^ def test_slicing(self):$/;" m class:OnlyExcludeAllTest -test_slicing_fields mongoengine/tests/queryset/field_list.py /^ def test_slicing_fields(self):$/;" m class:OnlyExcludeAllTest -test_slicing_nested_fields mongoengine/tests/queryset/field_list.py /^ def test_slicing_nested_fields(self):$/;" m class:OnlyExcludeAllTest -test_sorted_list_sorting mongoengine/tests/fields/fields.py /^ def test_sorted_list_sorting(self):$/;" m class:FieldTest -test_sorted_list_sorting tests/fields/fields.py /^ def test_sorted_list_sorting(self):$/;" m class:FieldTest -test_spaces_in_keys mongoengine/tests/document/instance.py /^ def test_spaces_in_keys(self):$/;" m class:InstanceTest -test_sparse_compound_indexes mongoengine/tests/document/indexes.py /^ def test_sparse_compound_indexes(self):$/;" m class:IndexesTest -test_sparse_field mongoengine/tests/fields/fields.py /^ def test_sparse_field(self):$/;" m class:FieldTest -test_sparse_field tests/fields/fields.py /^ def test_sparse_field(self):$/;" m class:FieldTest -test_spherical_geospatial_operators mongoengine/tests/queryset/geo.py /^ def test_spherical_geospatial_operators(self):$/;" m class:GeoQueriesTest -test_string_indexes mongoengine/tests/document/indexes.py /^ def test_string_indexes(self):$/;" m class:IndexesTest -test_string_validation mongoengine/tests/fields/fields.py /^ def test_string_validation(self):$/;" m class:FieldTest -test_string_validation tests/fields/fields.py /^ def test_string_validation(self):$/;" m class:FieldTest -test_subclass_field_query mongoengine/tests/queryset/queryset.py /^ def test_subclass_field_query(self):$/;" m class:QuerySetTest -test_subclasses mongoengine/tests/document/inheritance.py /^ def test_subclasses(self):$/;" m class:InheritanceTest -test_sum mongoengine/tests/queryset/queryset.py /^ def test_sum(self):$/;" m class:QuerySetTest -test_sum_over_db_field mongoengine/tests/queryset/queryset.py /^ def test_sum_over_db_field(self):$/;" m class:QuerySetTest -test_superclasses mongoengine/tests/document/inheritance.py /^ def test_superclasses(self):$/;" m class:InheritanceTest -test_switch_collection_context_manager mongoengine/tests/test_context_managers.py /^ def test_switch_collection_context_manager(self):$/;" m class:ContextManagersTest -test_switch_db_context_manager mongoengine/tests/test_context_managers.py /^ def test_switch_db_context_manager(self):$/;" m class:ContextManagersTest -test_switch_db_instance mongoengine/tests/document/instance.py /^ def test_switch_db_instance(self):$/;" m class:InstanceTest -test_text_indexes mongoengine/tests/document/indexes.py /^ def test_text_indexes(self):$/;" m class:IndexesTest -test_text_indexes mongoengine/tests/queryset/queryset.py /^ def test_text_indexes(self):$/;" m class:QuerySetTest -test_three_level_complex_data_lookups mongoengine/tests/document/dynamic.py /^ def test_three_level_complex_data_lookups(self):$/;" m class:DynamicTest -test_to_dbref mongoengine/tests/document/instance.py /^ def test_to_dbref(self):$/;" m class:InstanceTest -test_to_dict mongoengine/tests/document/validation.py /^ def test_to_dict(self):$/;" m class:ValidatorErrorTest -test_transform_query mongoengine/tests/queryset/transform.py /^ def test_transform_query(self):$/;" m class:TransformTest -test_transform_update mongoengine/tests/queryset/transform.py /^ def test_transform_update(self):$/;" m class:TransformTest -test_ttl_indexes mongoengine/tests/document/indexes.py /^ def test_ttl_indexes(self):$/;" m class:IndexesTest -test_tuples_as_tuples mongoengine/tests/fields/fields.py /^ def test_tuples_as_tuples(self):$/;" m class:FieldTest -test_tuples_as_tuples tests/fields/fields.py /^ def test_tuples_as_tuples(self):$/;" m class:FieldTest -test_two_way_reverse_delete_rule mongoengine/tests/document/instance.py /^ def test_two_way_reverse_delete_rule(self):$/;" m class:InstanceTest -test_type mongoengine/tests/queryset/transform.py /^ def test_type(self):$/;" m class:TransformTest -test_undefined_field_exception mongoengine/tests/fields/fields.py /^ def test_undefined_field_exception(self):$/;" m class:FieldTest -test_undefined_field_exception tests/fields/fields.py /^ def test_undefined_field_exception(self):$/;" m class:FieldTest -test_undefined_field_exception_with_strict mongoengine/tests/fields/fields.py /^ def test_undefined_field_exception_with_strict(self):$/;" m class:FieldTest -test_undefined_field_exception_with_strict tests/fields/fields.py /^ def test_undefined_field_exception_with_strict(self):$/;" m class:FieldTest -test_undefined_reference mongoengine/tests/fields/fields.py /^ def test_undefined_reference(self):$/;" m class:FieldTest -test_undefined_reference tests/fields/fields.py /^ def test_undefined_reference(self):$/;" m class:FieldTest -test_understandable_error_raised mongoengine/tests/queryset/transform.py /^ def test_understandable_error_raised(self):$/;" m class:TransformTest -test_unicode mongoengine/tests/fields/fields.py /^ def test_unicode(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_unicode tests/fields/fields.py /^ def test_unicode(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_unicode_url_validation mongoengine/tests/fields/fields.py /^ def test_unicode_url_validation(self):$/;" m class:FieldTest -test_unicode_url_validation tests/fields/fields.py /^ def test_unicode_url_validation(self):$/;" m class:FieldTest -test_unique mongoengine/tests/document/indexes.py /^ def test_unique(self):$/;" m class:IndexesTest -test_unique_and_indexes mongoengine/tests/document/indexes.py /^ def test_unique_and_indexes(self):$/;" m class:IndexesTest -test_unique_and_primary mongoengine/tests/document/indexes.py /^ def test_unique_and_primary(self):$/;" m class:IndexesTest -test_unique_and_primary_create mongoengine/tests/document/indexes.py /^ def test_unique_and_primary_create(self):$/;" m class:IndexesTest -test_unique_embedded_document mongoengine/tests/document/indexes.py /^ def test_unique_embedded_document(self):$/;" m class:IndexesTest -test_unique_embedded_document_in_list mongoengine/tests/document/indexes.py /^ def test_unique_embedded_document_in_list(self):$/;" m class:IndexesTest -test_unique_with mongoengine/tests/document/indexes.py /^ def test_unique_with(self):$/;" m class:IndexesTest -test_unique_with_embedded_document_and_embedded_unique mongoengine/tests/document/indexes.py /^ def test_unique_with_embedded_document_and_embedded_unique(self):$/;" m class:IndexesTest -test_unknown_keyword_exclude mongoengine/tests/fields/fields.py /^ def test_unknown_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_unknown_keyword_exclude tests/fields/fields.py /^ def test_unknown_keyword_exclude(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_unknown_keyword_filter mongoengine/tests/fields/fields.py /^ def test_unknown_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_unknown_keyword_filter tests/fields/fields.py /^ def test_unknown_keyword_filter(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_unknown_keyword_get mongoengine/tests/fields/fields.py /^ def test_unknown_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_unknown_keyword_get tests/fields/fields.py /^ def test_unknown_keyword_get(self):$/;" m class:EmbeddedDocumentListFieldTestCase -test_unpickle mongoengine/tests/queryset/pickable.py /^ def test_unpickle(self):$/;" m class:TestQuerysetPickable -test_unset_reference mongoengine/tests/queryset/queryset.py /^ def test_unset_reference(self):$/;" m class:QuerySetTest -test_update mongoengine/tests/document/instance.py /^ def test_update(self):$/;" m class:InstanceTest -test_update mongoengine/tests/queryset/queryset.py /^ def test_update(self):$/;" m class:QuerySetTest -test_update_array_position mongoengine/tests/queryset/queryset.py /^ def test_update_array_position(self):$/;" m class:QuerySetTest -test_update_list_field mongoengine/tests/document/instance.py /^ def test_update_list_field(self):$/;" m class:InstanceTest -test_update_min_max mongoengine/tests/queryset/queryset.py /^ def test_update_min_max(self):$/;" m class:QuerySetTest -test_update_one_pop_generic_reference mongoengine/tests/queryset/queryset.py /^ def test_update_one_pop_generic_reference(self):$/;" m class:QuerySetTest -test_update_push_and_pull_add_to_set mongoengine/tests/queryset/queryset.py /^ def test_update_push_and_pull_add_to_set(self):$/;" m class:QuerySetTest -test_update_push_list_of_list mongoengine/tests/queryset/queryset.py /^ def test_update_push_list_of_list(self):$/;" m class:QuerySetTest -test_update_push_with_position mongoengine/tests/queryset/queryset.py /^ def test_update_push_with_position(self):$/;" m class:QuerySetTest -test_update_related_models mongoengine/tests/queryset/queryset.py /^ def test_update_related_models(self):$/;" m class:QuerySetTest -test_update_rename_operator mongoengine/tests/document/instance.py /^ def test_update_rename_operator(self):$/;" m class:InstanceTest -test_update_results mongoengine/tests/queryset/queryset.py /^ def test_update_results(self):$/;" m class:QuerySetTest -test_update_unique_field mongoengine/tests/document/instance.py /^ def test_update_unique_field(self):$/;" m class:InstanceTest -test_update_update_has_a_value mongoengine/tests/queryset/queryset.py /^ def test_update_update_has_a_value(self):$/;" m class:QuerySetTest -test_update_upsert_looks_like_a_digit mongoengine/tests/queryset/queryset.py /^ def test_update_upsert_looks_like_a_digit(self):$/;" m class:QuerySetTest -test_update_using_positional_operator mongoengine/tests/queryset/queryset.py /^ def test_update_using_positional_operator(self):$/;" m class:QuerySetTest -test_update_using_positional_operator_embedded_document mongoengine/tests/queryset/queryset.py /^ def test_update_using_positional_operator_embedded_document(self):$/;" m class:QuerySetTest -test_update_using_positional_operator_matches_first mongoengine/tests/queryset/queryset.py /^ def test_update_using_positional_operator_matches_first(self):$/;" m class:QuerySetTest -test_update_validate mongoengine/tests/queryset/queryset.py /^ def test_update_validate(self):$/;" m class:QuerySetTest -test_update_value_conversion mongoengine/tests/queryset/queryset.py /^ def test_update_value_conversion(self):$/;" m class:QuerySetTest -test_update_write_concern mongoengine/tests/queryset/queryset.py /^ def test_update_write_concern(self):$/;" m class:QuerySetTest -test_updates_can_have_match_operators mongoengine/tests/queryset/queryset.py /^ def test_updates_can_have_match_operators(self):$/;" m class:QuerySetTest -test_updating_an_embedded_document mongoengine/tests/document/instance.py /^ def test_updating_an_embedded_document(self):$/;" m class:InstanceTest -test_upper_level_mark_as_changed mongoengine/tests/document/delta.py /^ def test_upper_level_mark_as_changed(self):$/;" m class:DeltaTest -test_upsert mongoengine/tests/queryset/queryset.py /^ def test_upsert(self):$/;" m class:QuerySetTest -test_upsert_includes_cls mongoengine/tests/queryset/queryset.py /^ def test_upsert_includes_cls(self):$/;" m class:QuerySetTest -test_upsert_one mongoengine/tests/queryset/queryset.py /^ def test_upsert_one(self):$/;" m class:QuerySetTest -test_uri_without_credentials_doesnt_override_conn_settings mongoengine/tests/test_connection.py /^ def test_uri_without_credentials_doesnt_override_conn_settings(self):$/;" m class:ConnectionTest -test_url_scheme_validation mongoengine/tests/fields/fields.py /^ def test_url_scheme_validation(self):$/;" m class:FieldTest -test_url_scheme_validation tests/fields/fields.py /^ def test_url_scheme_validation(self):$/;" m class:FieldTest -test_url_validation mongoengine/tests/fields/fields.py /^ def test_url_validation(self):$/;" m class:FieldTest -test_url_validation tests/fields/fields.py /^ def test_url_validation(self):$/;" m class:FieldTest -test_using mongoengine/tests/queryset/queryset.py /^ def test_using(self):$/;" m class:QuerySetTest -test_using_a_slice mongoengine/tests/queryset/field_list.py /^ def test_using_a_slice(self):$/;" m class:QueryFieldListTest -test_uuid_field_binary mongoengine/tests/fields/fields.py /^ def test_uuid_field_binary(self):$/;" m class:FieldTest -test_uuid_field_binary tests/fields/fields.py /^ def test_uuid_field_binary(self):$/;" m class:FieldTest -test_uuid_field_string mongoengine/tests/fields/fields.py /^ def test_uuid_field_string(self):$/;" m class:FieldTest -test_uuid_field_string tests/fields/fields.py /^ def test_uuid_field_string(self):$/;" m class:FieldTest -test_where mongoengine/tests/queryset/queryset.py /^ def test_where(self):$/;" m class:QuerySetTest -test_within_box mongoengine/tests/queryset/geo.py /^ def test_within_box(self):$/;" m class:GeoQueriesTest -test_within_distance mongoengine/tests/queryset/geo.py /^ def test_within_distance(self):$/;" m class:GeoQueriesTest -test_within_polygon mongoengine/tests/queryset/geo.py /^ def test_within_polygon(self):$/;" m class:GeoQueriesTest -test_write_concern mongoengine/tests/test_connection.py /^ def test_write_concern(self):$/;" m class:ConnectionTest -testdict mongoengine/tests/queryset/queryset.py /^ testdict = DictField()$/;" v class:QuerySetTest.test_dict_with_custom_baseclass.Test -testdict mongoengine/tests/queryset/queryset.py /^ testdict = DictField(basecls=StringField)$/;" v class:QuerySetTest.test_dict_with_custom_baseclass.Test -text mongoengine/tests/document/indexes.py /^ text = StringField()$/;" v class:IndexesTest.test_compound_key_dictfield.ReportDictField -text mongoengine/tests/document/indexes.py /^ text = StringField()$/;" v class:IndexesTest.test_compound_key_embedded.ReportEmbedded -text mongoengine/tests/document/instance.py /^ text = StringField()$/;" v class:InstanceTest.test_reverse_delete_rule_cascade_recurs.Comment -text mongoengine/tests/fields/fields.py /^ text = StringField()$/;" v class:FieldTest.test_list_field_passed_in_value.Bar -text mongoengine/tests/queryset/field_list.py /^ text = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude.Comment -text mongoengine/tests/queryset/field_list.py /^ text = StringField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.Comment -text mongoengine/tests/queryset/queryset.py /^ text = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_ReferenceField.Bar -text mongoengine/tests/queryset/queryset.py /^ text = StringField()$/;" v class:QuerySetTest.test_distinct_handles_references.Bar -text mongoengine/tests/queryset/queryset.py /^ text = StringField()$/;" v class:QuerySetTest.test_distinct_handles_references_to_alias.Bar -text mongoengine/tests/queryset/queryset.py /^ text = StringField()$/;" v class:QuerySetTest.test_unset_reference.Comment -text mongoengine/tests/test_dereference.py /^ text = StringField()$/;" v class:FieldTest.test_list_lookup_not_checked_in_map.Comment -text tests/fields/fields.py /^ text = StringField()$/;" v class:FieldTest.test_list_field_passed_in_value.Bar -text_info mongoengine/tests/fields/fields.py /^ text_info = ListField(StringField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost -text_info tests/fields/fields.py /^ text_info = ListField(StringField())$/;" v class:FieldTest.test_list_field_lexicographic_operators.BlogPost -the_date mongoengine/tests/test_connection.py /^ the_date = DateTimeField(required=True)$/;" v class:ConnectionTest.test_datetime.DateDoc -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_copyable.PutFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_boolean.TestFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_cmp.TestFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_disk_space.TestFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_field_no_default.GridDocument -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_field_optional.DemoFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_fields.PutFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_fields_set.SetFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_fields_stream.StreamFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_fields_stream_after_none.StreamFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_reassigning.TestFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField()$/;" v class:FileTest.test_file_uniqueness.TestFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = FileField(db_alias="test_files",$/;" v class:FileTest.test_file_multidb.TestFile -the_file mongoengine/tests/fields/file_tests.py /^ the_file = ImageField()$/;" v class:FileTest.test_image_field_reassigning.TestFile -thick mongoengine/tests/queryset/queryset.py /^ thick = BooleanField()$/;" v class:QuerySetTest.test_elem_match.Foo -thing mongoengine/tests/document/instance.py /^ thing = EmbeddedDocumentField(Thing)$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document.User -thing mongoengine/tests/document/instance.py /^ thing = EmbeddedDocumentField(Thing)$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false.User -thing mongoengine/tests/document/instance.py /^ thing = EmbeddedDocumentField(Thing)$/;" v class:InstanceTest.test_load_undefined_fields_on_embedded_document_with_strict_false_on_doc.User -thing mongoengine/tests/document/instance.py /^ thing = EmbeddedDocumentField(Thing)$/;" v class:InstanceTest.test_save_to_a_value_that_equates_to_false.User -thing mongoengine/tests/fields/fields.py /^ thing = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Ocurrence -thing tests/fields/fields.py /^ thing = GenericLazyReferenceField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_choices.Ocurrence -thumbnail mongoengine/fields.py /^ def thumbnail(self):$/;" m class:ImageGridFsProxy -thumbnail mongoengine/mongoengine/fields.py /^ def thumbnail(self):$/;" m class:ImageGridFsProxy -time mongoengine/tests/fields/fields.py /^ time = DateTimeField()$/;" v class:FieldTest.test_datetime_tz_aware_mark_as_changed.LogEntry -time mongoengine/tests/fields/fields.py /^ time = DateTimeField()$/;" v class:FieldTest.test_datetime_validation.LogEntry -time tests/fields/fields.py /^ time = DateTimeField()$/;" v class:FieldTest.test_datetime_tz_aware_mark_as_changed.LogEntry -time tests/fields/fields.py /^ time = DateTimeField()$/;" v class:FieldTest.test_datetime_validation.LogEntry -timeout mongoengine/mongoengine/queryset/base.py /^ def timeout(self, enabled):$/;" m class:BaseQuerySet -title mongoengine/docs/code/tumblelog.py /^ title = StringField(max_length=120, required=True)$/;" v class:Post -title mongoengine/tests/document/class_methods.py /^ title = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes.BlogPost -title mongoengine/tests/document/class_methods.py /^ title = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_inheritance.BlogPost -title mongoengine/tests/document/class_methods.py /^ title = StringField()$/;" v class:ClassMethodsTest.test_compare_indexes_multiple_subclasses.BlogPost -title mongoengine/tests/document/class_methods.py /^ title = StringField()$/;" v class:ClassMethodsTest.test_list_indexes_inheritance.BlogPost -title mongoengine/tests/document/indexes.py /^ title = DictField()$/;" v class:IndexesTest.test_text_indexes.Book -title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest._index_test_inheritance.ExtendedBlogPost -title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_embedded_document_index.BlogPost -title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_index_no_cls.A -title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_indexes_after_database_drop.BlogPost -title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_inherited_index.A -title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_list_embedded_document_index.BlogPost -title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_unique.BlogPost -title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_unique_embedded_document.BlogPost -title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_unique_embedded_document_in_list.BlogPost -title mongoengine/tests/document/indexes.py /^ title = StringField()$/;" v class:IndexesTest.test_unique_with.BlogPost -title mongoengine/tests/document/indexes.py /^ title = StringField(required=True)$/;" v class:IndexesTest.test_embedded_document_index_meta.Rank -title mongoengine/tests/document/indexes.py /^ title = StringField(required=True)$/;" v class:IndexesTest.test_index_on_id.BlogPost -title mongoengine/tests/document/indexes.py /^ title = StringField(unique_with='sub.year')$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.BlogPost -title mongoengine/tests/document/instance.py /^ title = StringField()$/;" v class:InstanceTest.test_reload_of_non_strict_with_special_field_name.Post -title mongoengine/tests/document/instance.py /^ title = StringField()$/;" v class:InstanceTest.test_repr.Article -title mongoengine/tests/document/instance.py /^ title = StringField()$/;" v class:InstanceTest.test_repr_none.Article -title mongoengine/tests/document/instance.py /^ title = StringField(required=True)$/;" v class:InstanceTest.test_db_embedded_doc_field_load.Rank -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference.Link -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference.Post -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices.Link -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices.Post -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Post -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_document_not_registered.Link -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list.Link -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list.Post -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_choices.Link -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_choices.Post -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_item_modification.Post -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_string_choices.Link -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_string_choices.Post -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_reference_query_conversion.BlogPost -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_reference_query_conversion_dbref.BlogPost -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.BlogPost -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.BlogPost -title mongoengine/tests/fields/fields.py /^ title = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.BlogPost -title mongoengine/tests/fields/fields.py /^ title = StringField(required=True)$/;" v class:FieldTest.test_embedded_sequence_field.Post -title mongoengine/tests/fields/fields.py /^ title = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Post -title mongoengine/tests/fields/geo.py /^ title = StringField()$/;" v class:GeoFieldTest.test_geopoint_embedded_indexes.Event -title mongoengine/tests/fields/geo.py /^ title = StringField()$/;" v class:GeoFieldTest.test_indexes_2dsphere.Event -title mongoengine/tests/fields/geo.py /^ title = StringField()$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Event -title mongoengine/tests/fields/geo.py /^ title = StringField()$/;" v class:GeoFieldTest.test_indexes_geopoint.Event -title mongoengine/tests/queryset/field_list.py /^ title = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude.Comment -title mongoengine/tests/queryset/field_list.py /^ title = StringField()$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.Comment -title mongoengine/tests/queryset/geo.py /^ title = StringField()$/;" v class:GeoQueriesTest._create_event_data.Event -title mongoengine/tests/queryset/geo.py /^ title = StringField()$/;" v class:GeoQueriesTest._test_embedded.Event -title mongoengine/tests/queryset/geo.py /^ title="Coltrane Motion @ Bottom of the Hill",$/;" v class:GeoQueriesTest._create_event_data.Event -title mongoengine/tests/queryset/geo.py /^ title="Coltrane Motion @ Double Door",$/;" v class:GeoQueriesTest._create_event_data.Event -title mongoengine/tests/queryset/geo.py /^ title="Coltrane Motion @ Empty Bottle",$/;" v class:GeoQueriesTest._create_event_data.Event -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_bulk.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_call_after_limits_set.Post -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_clear_ordering.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_count_limit_and_skip.Post -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField.Book -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_distinct_ListField_EmbeddedDocumentField_EmbeddedDocumentField.Book -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_map_reduce.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_no_ordering_for_get.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_order_by_list.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_order_by_optional.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_ordering.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_set_list_embedded_documents.Message -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_text_indexes.News -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_update.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_update_using_positional_operator.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField()$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField(db_field='bpTitle')$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -title mongoengine/tests/queryset/queryset.py /^ title = StringField(primary_key=True)$/;" v class:QuerySetTest.test_map_reduce_with_custom_object_ids.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title = StringField(required=True)$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Post -title mongoengine/tests/queryset/queryset.py /^ title = StringField(unique=True)$/;" v class:QuerySetTest.test_bulk_insert.Blog -title mongoengine/tests/queryset/queryset.py /^ title="A",$/;" v class:QuerySetTest.test_order_by_list.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="B",$/;" v class:QuerySetTest.test_order_by_list.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #1",$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #1",$/;" v class:QuerySetTest.test_order_by_optional.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #1",$/;" v class:QuerySetTest.test_ordering.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #2",$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #2",$/;" v class:QuerySetTest.test_order_by_optional.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #2",$/;" v class:QuerySetTest.test_ordering.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #3",$/;" v class:QuerySetTest.test_filter_chaining.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #3",$/;" v class:QuerySetTest.test_order_by_optional.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #3",$/;" v class:QuerySetTest.test_ordering.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="Blog Post #4",$/;" v class:QuerySetTest.test_order_by_optional.BlogPost -title mongoengine/tests/queryset/queryset.py /^ title="C",$/;" v class:QuerySetTest.test_order_by_list.BlogPost -title mongoengine/tests/queryset/transform.py /^ title = StringField()$/;" v class:TransformTest.test_understandable_error_raised.Event -title mongoengine/tests/queryset/transform.py /^ title = StringField(db_field='postTitle')$/;" v class:TransformTest.test_query_field_name.BlogPost -title mongoengine/tests/queryset/transform.py /^ title = StringField(primary_key=True, db_field='postTitle')$/;" v class:TransformTest.test_query_pk_field_name.BlogPost -title mongoengine/tests/queryset/visitor.py /^ title = StringField()$/;" v class:QTest.test_q.BlogPost -title mongoengine/tests/queryset/visitor.py /^ title = StringField(max_length=40)$/;" v class:QTest.test_multiple_occurence_in_field.Test -title mongoengine/tests/test_dereference.py /^ title = StringField()$/;" v class:FieldTest.test_multidirectional_lists.Asset -title mongoengine/tests/test_dereference.py /^ title = StringField()$/;" v class:FieldTest.test_select_related_follows_embedded_referencefields.Song -title mongoengine/tests/test_dereference.py /^ title = StringField(max_length=255, primary_key=True)$/;" v class:FieldTest.test_non_ascii_pk.Brand -title mongoengine/tests/test_dereference.py /^ title = StringField(max_length=255, primary_key=True)$/;" v class:FieldTest.test_non_ascii_pk.BrandGroup -title mongoengine/tests/test_signals.py /^ title = StringField()$/;" v class:SignalTests.setUp.Post -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference.Link -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference.Post -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices.Link -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices.Post -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_choices_no_dereference.Post -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_document_not_registered.Link -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list.Link -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list.Post -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_choices.Link -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_choices.Post -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_list_item_modification.Post -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_string_choices.Link -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_generic_reference_string_choices.Post -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_reference_query_conversion.BlogPost -title tests/fields/fields.py /^ title = StringField()$/;" v class:FieldTest.test_reference_query_conversion_dbref.BlogPost -title tests/fields/fields.py /^ title = StringField()$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.BlogPost -title tests/fields/fields.py /^ title = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.BlogPost -title tests/fields/fields.py /^ title = StringField()$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.BlogPost -title tests/fields/fields.py /^ title = StringField(required=True)$/;" v class:FieldTest.test_embedded_sequence_field.Post -title tests/fields/fields.py /^ title = StringField(required=True)$/;" v class:FieldTest.test_recursive_validation.Post -to mongoengine/tests/queryset/field_list.py /^ to = StringField()$/;" v class:OnlyExcludeAllTest.test_all_fields.Email -to mongoengine/tests/queryset/field_list.py /^ to = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_only_combining.Email -to_dbref mongoengine/mongoengine/document.py /^ def to_dbref(self):$/;" m class:Document -to_dict mongoengine/mongoengine/errors.py /^ def to_dict(self):$/;" m class:ValidationError -to_json mongoengine/mongoengine/base/document.py /^ def to_json(self, *args, **kwargs):$/;" m class:BaseDocument -to_json mongoengine/mongoengine/queryset/base.py /^ def to_json(self, *args, **kwargs):$/;" m class:BaseQuerySet -to_mongo mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:GenericLazyReferenceField -to_mongo mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:GenericReferenceField -to_mongo mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:ReferenceField -to_mongo mongoengine/fields.py /^ def to_mongo(self, document, use_db_field=True, fields=None):$/;" m class:CachedReferenceField -to_mongo mongoengine/fields.py /^ def to_mongo(self, document, use_db_field=True, fields=None):$/;" m class:GenericEmbeddedDocumentField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:BinaryField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:ComplexDateTimeField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:DateTimeField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:DecimalField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:FileField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:LazyReferenceField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:LongField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:UUIDField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:DynamicField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:EmbeddedDocumentField -to_mongo mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:SortedListField -to_mongo mongoengine/mongoengine/base/document.py /^ def to_mongo(self, use_db_field=True, fields=None):$/;" m class:BaseDocument -to_mongo mongoengine/mongoengine/base/fields.py /^ def to_mongo(self, value):$/;" m class:BaseField -to_mongo mongoengine/mongoengine/base/fields.py /^ def to_mongo(self, value):$/;" m class:GeoJsonBaseField -to_mongo mongoengine/mongoengine/base/fields.py /^ def to_mongo(self, value):$/;" m class:ObjectIdField -to_mongo mongoengine/mongoengine/base/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:ComplexBaseField -to_mongo mongoengine/mongoengine/document.py /^ def to_mongo(self, *args, **kwargs):$/;" m class:Document -to_mongo mongoengine/mongoengine/document.py /^ def to_mongo(self, *args, **kwargs):$/;" m class:EmbeddedDocument -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:GenericLazyReferenceField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:GenericReferenceField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, document):$/;" m class:ReferenceField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, document, use_db_field=True, fields=None):$/;" m class:CachedReferenceField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, document, use_db_field=True, fields=None):$/;" m class:GenericEmbeddedDocumentField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:BinaryField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:ComplexDateTimeField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:DateTimeField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:DecimalField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:FileField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:LazyReferenceField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:LongField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value):$/;" m class:UUIDField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:DynamicField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:EmbeddedDocumentField -to_mongo mongoengine/mongoengine/fields.py /^ def to_mongo(self, value, use_db_field=True, fields=None):$/;" m class:SortedListField -to_mongo mongoengine/tests/fields/fields.py /^ def to_mongo(self, value):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField -to_mongo tests/fields/fields.py /^ def to_mongo(self, value):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:BooleanField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:CachedReferenceField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:ComplexDateTimeField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:DecimalField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:DynamicField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:EmbeddedDocumentField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:FileField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:FloatField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:GenericEmbeddedDocumentField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:IntField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:LongField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:ReferenceField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:SequenceField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:StringField -to_python mongoengine/fields.py /^ def to_python(self, value):$/;" m class:UUIDField -to_python mongoengine/mongoengine/base/fields.py /^ def to_python(self, value):$/;" m class:BaseField -to_python mongoengine/mongoengine/base/fields.py /^ def to_python(self, value):$/;" m class:ComplexBaseField -to_python mongoengine/mongoengine/base/fields.py /^ def to_python(self, value):$/;" m class:ObjectIdField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:BooleanField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:CachedReferenceField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:ComplexDateTimeField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:DecimalField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:DynamicField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:EmbeddedDocumentField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:FileField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:FloatField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:GenericEmbeddedDocumentField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:IntField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:LongField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:ReferenceField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:SequenceField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:StringField -to_python mongoengine/mongoengine/fields.py /^ def to_python(self, value):$/;" m class:UUIDField -to_python mongoengine/tests/fields/fields.py /^ def to_python(self, value):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField -to_python tests/fields/fields.py /^ def to_python(self, value):$/;" m class:FieldTest.test_tuples_as_tuples.EnumField -to_query mongoengine/mongoengine/queryset/visitor.py /^ def to_query(self, document):$/;" m class:QNode -toggle mongoengine/tests/document/instance.py /^ toggle = BooleanField(default=False)$/;" v class:InstanceTest.test_save_atomicity_condition.Widget -topic mongoengine/tests/test_dereference.py /^ topic = ReferenceField(Topic)$/;" v class:FieldTest.test_document_reload_reference_integrity.Message -tp mongoengine/tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person -tp mongoengine/tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone -tp mongoengine/tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -tp mongoengine/tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person -tp tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync.Person -tp tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_auto_sync_disabled.Persone -tp tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -tp tests/fields/fields.py /^ tp = StringField($/;" v class:CachedReferenceFieldTest.test_cached_reference_field_update_all.Person -txt mongoengine/tests/document/indexes.py /^ txt = StringField()$/;" v class:IndexesTest.test_index_dont_send_cls_option.TestDoc -txt mongoengine/tests/fields/fields.py /^ txt = StringField()$/;" v class:FieldTest.test_double_embedded_db_field.C -txt mongoengine/tests/fields/fields.py /^ txt = StringField()$/;" v class:FieldTest.test_double_embedded_db_field_from_son.C -txt mongoengine/tests/queryset/queryset.py /^ txt = StringField()$/;" v class:QuerySetTest.test_read_preference.Bar -txt tests/fields/fields.py /^ txt = StringField()$/;" v class:FieldTest.test_double_embedded_db_field.C -txt tests/fields/fields.py /^ txt = StringField()$/;" v class:FieldTest.test_double_embedded_db_field_from_son.C -txt2 mongoengine/tests/document/indexes.py /^ txt2 = StringField()$/;" v class:IndexesTest.test_index_dont_send_cls_option.TestChildDoc -txt_1 mongoengine/tests/document/indexes.py /^ txt_1 = StringField()$/;" v class:IndexesTest.test_compound_index_underscore_cls_not_overwritten.TestDoc -type mongoengine/tests/document/delta.py /^ type = StringField()$/;" v class:DeltaTest.test_delta_for_nested_map_fields.EmbeddedRole -type mongoengine/tests/queryset/transform.py /^ type = StringField()$/;" v class:TransformTest.test_last_field_name_like_operator.EmbeddedItem -unhelpful mongoengine/tests/queryset/queryset.py /^ unhelpful = ListField(EmbeddedDocumentField(User))$/;" v class:QuerySetTest.test_pull_from_nested_embedded.Collaborator -up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=1079,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=1446,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=215,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=48,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=481,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -up_votes mongoengine/tests/queryset/queryset.py /^ up_votes=74,$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -up_votes mongoengine/tests/queryset/queryset.py /^ up_votes = IntField()$/;" v class:QuerySetTest.test_map_reduce_finalize.Link -update mongoengine/mongoengine/base/datastructures.py /^ def update(self, **update):$/;" m class:EmbeddedDocumentList -update mongoengine/mongoengine/base/datastructures.py /^ def update(self, *args, **kwargs):$/;" m class:BaseDict -update mongoengine/mongoengine/document.py /^ def update(self, **kwargs):$/;" m class:Document -update mongoengine/mongoengine/queryset/base.py /^ def update(self, upsert=False, multi=True, write_concern=None,$/;" m class:BaseQuerySet -update mongoengine/mongoengine/queryset/transform.py /^def update(_doc_cls=None, **update):$/;" f -update mongoengine/tests/queryset/transform.py /^ update = transform.update(DicDoc, **{"%s__dictField__test" % k: doc})$/;" v class:TransformTest.test_transform_update.Doc -update_one mongoengine/mongoengine/queryset/base.py /^ def update_one(self, upsert=False, write_concern=None, **update):$/;" m class:BaseQuerySet -upsert_one mongoengine/mongoengine/queryset/base.py /^ def upsert_one(self, write_concern=None, **update):$/;" m class:BaseQuerySet -url mongoengine/tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_unicode_url_validation.Link -url mongoengine/tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_url_scheme_validation.Link -url mongoengine/tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_url_validation.Link -url mongoengine/tests/fields/fields.py /^ url = URLField(schemes=['ws', 'irc'])$/;" v class:FieldTest.test_url_scheme_validation.SchemeLink -url tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_unicode_url_validation.Link -url tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_url_scheme_validation.Link -url tests/fields/fields.py /^ url = URLField()$/;" v class:FieldTest.test_url_validation.Link -url tests/fields/fields.py /^ url = URLField(schemes=['ws', 'irc'])$/;" v class:FieldTest.test_url_scheme_validation.SchemeLink -url_field mongoengine/tests/document/instance.py /^ url_field = URLField(default="http:\/\/mongoengine.org")$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -url_field mongoengine/tests/document/json_serialisation.py /^ url_field = URLField(default="http:\/\/mongoengine.org")$/;" v class:TestJson.test_json_complex.Doc -url_field mongoengine/tests/queryset/queryset.py /^ url_field = URLField(default="http:\/\/mongoengine.org")$/;" v class:QuerySetTest.test_json_complex.Doc -use_db_field mongoengine/tests/document/instance.py /^ use_db_field=False).to_dict()$/;" v class:InstanceTest.test_embedded_document_complex_instance_no_use_db_field.Doc -user mongoengine/tests/document/instance.py /^ user = ReferenceField(User)$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription -user mongoengine/tests/document/instance.py /^ user = ReferenceField(User,$/;" v class:InstanceTest.test_list_search_by_embedded.Comment -user mongoengine/tests/document/instance.py /^ user = User.objects.first()$/;" v class:InstanceTest.test_query_count_when_saving.UserSubscription -user mongoengine/tests/queryset/queryset.py /^ user = ReferenceField(User)$/;" v class:QuerySetTest.test_no_dereference_embedded_doc.Member -user mongoengine/tests/queryset/queryset.py /^ user = StringField()$/;" v class:QuerySetTest.test_pull_from_nested_mapfield.Collaborator -user mongoengine/tests/queryset/queryset.py /^ user = StringField()$/;" v class:QuerySetTest.test_pull_nested.Collaborator -user mongoengine/tests/test_dereference.py /^ user = User(name='user %s' % i)$/;" v class:FieldTest.test_handle_old_style_references.Group -user mongoengine/tests/test_dereference.py /^ user = User(name='user %s' % i)$/;" v class:FieldTest.test_list_item_dereference.Group -user mongoengine/tests/test_dereference.py /^ user = User(name='user %s' % i)$/;" v class:FieldTest.test_list_item_dereference_dref_false.Group -user mongoengine/tests/test_dereference.py /^ user = User(name='user %s' % i)$/;" v class:FieldTest.test_map_field_reference.Group -user_guid mongoengine/tests/document/indexes.py /^ user_guid = StringField(required=True)$/;" v class:IndexesTest.test_abstract_index_inheritance.UserBase -user_guid mongoengine/tests/document/indexes.py /^ user_guid = StringField(required=True)$/;" v class:IndexesTest.test_disable_index_creation.User -user_lists mongoengine/tests/test_dereference.py /^ user_lists = ListField(ListField(ReferenceField(User)))$/;" v class:FieldTest.test_list_of_lists_of_references.Post -user_num mongoengine/tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:FieldTest.test_reference_query_conversion.Member -user_num mongoengine/tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:FieldTest.test_reference_query_conversion_dbref.Member -user_num mongoengine/tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.Member -user_num mongoengine/tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.Member -user_num mongoengine/tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.Member -user_num tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:FieldTest.test_reference_query_conversion.Member -user_num tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:FieldTest.test_reference_query_conversion_dbref.Member -user_num tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:GenericLazyReferenceFieldTest.test_generic_lazy_reference_query_conversion.Member -user_num tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion.Member -user_num tests/fields/fields.py /^ user_num = IntField(primary_key=True)$/;" v class:LazyReferenceFieldTest.test_lazy_reference_query_conversion_dbref.Member -userid mongoengine/tests/fields/fields.py /^ userid = StringField()$/;" v class:FieldTest.test_required_values.Person -userid mongoengine/tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_nothing_set.Person -userid mongoengine/tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_set_to_None.Person -userid mongoengine/tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person -userid mongoengine/tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person -userid mongoengine/tests/fields/fields.py /^ userid = StringField(r'[0-9a-z_]+$')$/;" v class:FieldTest.test_string_validation.Person -userid tests/fields/fields.py /^ userid = StringField()$/;" v class:FieldTest.test_required_values.Person -userid tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_nothing_set.Person -userid tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_set_to_None.Person -userid tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_when_deleting_value.Person -userid tests/fields/fields.py /^ userid = StringField(default=lambda: 'test', required=True)$/;" v class:FieldTest.test_default_values_when_setting_to_None.Person -userid tests/fields/fields.py /^ userid = StringField(r'[0-9a-z_]+$')$/;" v class:FieldTest.test_string_validation.Person -username mongoengine/tests/document/instance.py /^ username = StringField(primary_key=True)$/;" v class:InstanceTest.test_custom_id_field.User -username mongoengine/tests/document/instance.py /^ username = StringField(required=True)$/;" v class:InstanceTest.test_list_search_by_embedded.User -username mongoengine/tests/document/validation.py /^ username = StringField(primary_key=True)$/;" v class:ValidatorErrorTest.test_model_validation.User -username mongoengine/tests/fields/fields.py /^ username = StringField()$/;" v class:FieldTest.test_generic_reference_list_item_modification.User -username mongoengine/tests/queryset/field_list.py /^ username = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_from_subclasses_docs.Base -username mongoengine/tests/queryset/queryset.py /^ username = StringField()$/;" v class:QuerySetTest.test_set_generic_embedded_documents.User -username tests/fields/fields.py /^ username = StringField()$/;" v class:FieldTest.test_generic_reference_list_item_modification.User -users mongoengine/tests/document/delta.py /^ users = MapField(field=EmbeddedDocumentField(EmbeddedUser))$/;" v class:DeltaTest.test_delta_for_nested_map_fields.Doc -users mongoengine/tests/test_dereference.py /^ users = ListField(ReferenceField(User))$/;" v class:FieldTest.test_list_of_lists_of_references.SimpleList -using mongoengine/mongoengine/queryset/base.py /^ def using(self, alias):$/;" m class:BaseQuerySet -uuid_field mongoengine/tests/document/instance.py /^ uuid_field = UUIDField(default=uuid.uuid4)$/;" v class:InstanceTest.test_can_save_if_not_included.Doc -uuid_field mongoengine/tests/document/json_serialisation.py /^ uuid_field = UUIDField(default=uuid.uuid4)$/;" v class:TestJson.test_json_complex.Doc -uuid_field mongoengine/tests/queryset/queryset.py /^ uuid_field = UUIDField(default=uuid.uuid4)$/;" v class:QuerySetTest.test_json_complex.Doc -v mongoengine/tests/document/instance.py /^ v = StringField()$/;" v class:InstanceTest.test_list_iter.B -vaccine_made mongoengine/tests/document/class_methods.py /^ vaccine_made = ListField(ReferenceField("Vaccine", reverse_delete_rule=PULL))$/;" v class:ClassMethodsTest.test_register_delete_rule_inherited.Animal -val mongoengine/tests/document/validation.py /^ val = IntField(required=True)$/;" v class:ValidatorErrorTest.test_embedded_db_field_validate.SubDoc -val mongoengine/tests/document/validation.py /^ val = IntField(required=True)$/;" v class:ValidatorErrorTest.test_embedded_weakref.SubDoc -val mongoengine/tests/queryset/queryset.py /^ val = BooleanField()$/;" v class:QuerySetTest.test_item_frequencies_with_False_values.Test -val mongoengine/tests/queryset/queryset.py /^ val = IntField()$/;" v class:QuerySetTest.test_item_frequencies_normalize.Test -val mongoengine/tests/queryset/queryset.py /^ val = IntField()$/;" v class:QuerySetTest.test_item_frequencies_with_0_values.Test -val mongoengine/tests/queryset/queryset.py /^ val = IntField()$/;" v class:QuerySetTest.test_reload_embedded_docs_instance.SubDoc -val mongoengine/tests/queryset/queryset.py /^ val = IntField()$/;" v class:QuerySetTest.test_reload_list_embedded_docs_instance.SubDoc -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:BinaryField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:BooleanField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:CachedReferenceField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:ComplexDateTimeField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:DateTimeField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:DecimalField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:DictField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:EmailField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:FileField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:FloatField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:GenericLazyReferenceField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:GenericReferenceField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:GeoPointField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:IntField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:LazyReferenceField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:ListField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:LongField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:ReferenceField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:StringField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:URLField -validate mongoengine/fields.py /^ def validate(self, value):$/;" m class:UUIDField -validate mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:DynamicField -validate mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:EmbeddedDocumentField -validate mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:GenericEmbeddedDocumentField -validate mongoengine/mongoengine/base/document.py /^ def validate(self, clean=True):$/;" m class:BaseDocument -validate mongoengine/mongoengine/base/fields.py /^ def validate(self, value):$/;" m class:ComplexBaseField -validate mongoengine/mongoengine/base/fields.py /^ def validate(self, value):$/;" m class:GeoJsonBaseField -validate mongoengine/mongoengine/base/fields.py /^ def validate(self, value):$/;" m class:ObjectIdField -validate mongoengine/mongoengine/base/fields.py /^ def validate(self, value, clean=True):$/;" m class:BaseField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:BinaryField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:BooleanField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:CachedReferenceField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:ComplexDateTimeField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:DateTimeField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:DecimalField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:DictField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:EmailField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:FileField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:FloatField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:GenericLazyReferenceField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:GenericReferenceField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:GeoPointField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:IntField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:LazyReferenceField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:ListField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:LongField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:ReferenceField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:StringField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:URLField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value):$/;" m class:UUIDField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:DynamicField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:EmbeddedDocumentField -validate mongoengine/mongoengine/fields.py /^ def validate(self, value, clean=True):$/;" m class:GenericEmbeddedDocumentField -validate mongoengine/tests/document/instance.py /^ validate = DictField()$/;" v class:InstanceTest.test_override_method_with_field.Blog -validate_domain_part mongoengine/fields.py /^ def validate_domain_part(self, domain_part):$/;" m class:EmailField -validate_domain_part mongoengine/mongoengine/fields.py /^ def validate_domain_part(self, domain_part):$/;" m class:EmailField -validate_user_part mongoengine/fields.py /^ def validate_user_part(self, user_part):$/;" m class:EmailField -validate_user_part mongoengine/mongoengine/fields.py /^ def validate_user_part(self, user_part):$/;" m class:EmailField -value mongoengine/tests/document/instance.py /^ value = DynamicField(default="UNDEFINED")$/;" v class:InstanceTest.test_complex_nesting_document_and_embedded_document.Macro -value mongoengine/tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_complex_mapfield.IntegerSetting -value mongoengine/tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_dictfield_complex.IntegerSetting -value mongoengine/tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_list_field_complex.IntegerSetting -value mongoengine/tests/fields/fields.py /^ value = LongField(min_value=0, max_value=110)$/;" v class:FieldTest.test_long_validation.TestDocument -value mongoengine/tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_complex_mapfield.StringSetting -value mongoengine/tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_dictfield_complex.StringSetting -value mongoengine/tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_list_field_complex.StringSetting -value mongoengine/tests/queryset/modify.py /^ value = IntField()$/;" v class:Doc -value mongoengine/tests/queryset/queryset.py /^ value = DecimalField()$/;" v class:QuerySetTest.test_embedded_average.Pay -value mongoengine/tests/queryset/queryset.py /^ value = DecimalField()$/;" v class:QuerySetTest.test_embedded_sum.Pay -value mongoengine/tests/queryset/queryset.py /^ value = StringField()$/;" v class:QuerySetTest.test_scalar_primary_key.SettingValue -value tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_complex_mapfield.IntegerSetting -value tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_dictfield_complex.IntegerSetting -value tests/fields/fields.py /^ value = IntField()$/;" v class:FieldTest.test_list_field_complex.IntegerSetting -value tests/fields/fields.py /^ value = LongField(min_value=0, max_value=110)$/;" v class:FieldTest.test_long_validation.TestDocument -value tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_complex_mapfield.StringSetting -value tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_dictfield_complex.StringSetting -value tests/fields/fields.py /^ value = StringField()$/;" v class:FieldTest.test_list_field_complex.StringSetting -value_list mongoengine/tests/fields/fields.py /^ value_list = ListField(field=StringField())$/;" v class:FieldTest.test_map_field_unicode.Info -value_list tests/fields/fields.py /^ value_list = ListField(field=StringField())$/;" v class:FieldTest.test_map_field_unicode.Info -values mongoengine/tests/queryset/queryset.py /^ values = ListField(DecimalField())$/;" v class:QuerySetTest.test_array_average.Doc -values mongoengine/tests/queryset/queryset.py /^ values = ListField(DecimalField())$/;" v class:QuerySetTest.test_array_sum.Doc -values mongoengine/tests/queryset/queryset.py /^ values = ListField(DecimalField())$/;" v class:QuerySetTest.test_embedded_array_average.Pay -values mongoengine/tests/queryset/queryset.py /^ values = ListField(DecimalField())$/;" v class:QuerySetTest.test_embedded_array_sum.Pay -values_list mongoengine/mongoengine/queryset/base.py /^ def values_list(self, *fields):$/;" m class:BaseQuerySet -various mongoengine/tests/queryset/field_list.py /^ various = MapField(field=EmbeddedDocumentField(VariousData))$/;" v class:OnlyExcludeAllTest.test_only_with_subfields.BlogPost -venue mongoengine/tests/fields/geo.py /^ venue = EmbeddedDocumentField(Venue)$/;" v class:GeoFieldTest.test_geopoint_embedded_indexes.Event -venue mongoengine/tests/fields/geo.py /^ venue = EmbeddedDocumentField(Venue)$/;" v class:GeoFieldTest.test_indexes_2dsphere_embedded.Event -venue mongoengine/tests/queryset/geo.py /^ venue=venue1).save()$/;" v class:GeoQueriesTest._test_embedded.Event -venue mongoengine/tests/queryset/geo.py /^ venue=venue2).save()$/;" v class:GeoQueriesTest._test_embedded.Event -venue mongoengine/tests/queryset/geo.py /^ venue = EmbeddedDocumentField(Venue)$/;" v class:GeoQueriesTest._test_embedded.Event -verbose_name mongoengine/tests/fields/fields.py /^ verbose_name="Type",$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -verbose_name tests/fields/fields.py /^ verbose_name="Type",$/;" v class:CachedReferenceFieldTest.test_cached_reference_embedded_fields.Owner -version mongoengine/docs/conf.py /^version = mongoengine.get_version()$/;" v -version_line mongoengine/setup.py /^version_line = list(filter(lambda l: l.startswith('VERSION'), open(init)))[0]$/;" v -visit_combination mongoengine/mongoengine/queryset/visitor.py /^ def visit_combination(self, combination):$/;" m class:QNodeVisitor -visit_combination mongoengine/mongoengine/queryset/visitor.py /^ def visit_combination(self, combination):$/;" m class:QueryCompilerVisitor -visit_combination mongoengine/mongoengine/queryset/visitor.py /^ def visit_combination(self, combination):$/;" m class:SimplificationVisitor -visit_query mongoengine/mongoengine/queryset/visitor.py /^ def visit_query(self, query):$/;" m class:QNodeVisitor -visit_query mongoengine/mongoengine/queryset/visitor.py /^ def visit_query(self, query):$/;" m class:QueryCompilerVisitor -visited mongoengine/tests/fields/fields.py /^ visited = MapField(DateTimeField())$/;" v class:FieldTest.test_map_field_lookup.Log -visited tests/fields/fields.py /^ visited = MapField(DateTimeField())$/;" v class:FieldTest.test_map_field_lookup.Log -visited__friends__exists mongoengine/tests/fields/fields.py /^ visited__friends__exists=True).count())$/;" v class:FieldTest.test_map_field_lookup.Log -visited__friends__exists tests/fields/fields.py /^ visited__friends__exists=True).count())$/;" v class:FieldTest.test_map_field_lookup.Log -vote mongoengine/tests/queryset/queryset.py /^ vote = IntField()$/;" v class:QuerySetTest.test_updates_can_have_match_operators.Comment -votes mongoengine/tests/queryset/queryset.py /^ votes = EmbeddedDocumentField(Vote)$/;" v class:QuerySetTest.test_update_using_positional_operator_embedded_document.Comment -votes mongoengine/tests/queryset/queryset.py /^ votes = IntField()$/;" v class:QuerySetTest.test_update_using_positional_operator.Comment -weight mongoengine/tests/queryset/queryset.py /^ weight = IntField()$/;" v class:QuerySetTest.setUp.PersonMeta -where mongoengine/mongoengine/queryset/base.py /^ def where(self, where_clause):$/;" m class:BaseQuerySet -whiskers_length mongoengine/tests/queryset/queryset.py /^ whiskers_length = FloatField()$/;" v class:QuerySetTest.test_subclass_field_query.Cat -wibble mongoengine/tests/queryset/field_list.py /^ wibble = StringField()$/;" v class:OnlyExcludeAllTest.test_exclude_from_subclasses_docs.User -widgets mongoengine/tests/document/instance.py /^ widgets = StringField()$/;" v class:InstanceTest.test_object_mixins.Bar -widgets mongoengine/tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_del_slice_marks_field_as_changed.Simple -widgets mongoengine/tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_list_field_with_negative_indices.Simple -widgets mongoengine/tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_slice_marks_field_as_changed.Simple -widgets tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_del_slice_marks_field_as_changed.Simple -widgets tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_list_field_with_negative_indices.Simple -widgets tests/fields/fields.py /^ widgets = ListField()$/;" v class:FieldTest.test_slice_marks_field_as_changed.Simple -with_id mongoengine/mongoengine/queryset/base.py /^ def with_id(self, object_id):$/;" m class:BaseQuerySet -with_inactive mongoengine/tests/queryset/queryset.py /^ def with_inactive(doc_cls, queryset):$/;" m class:QuerySetTest.test_custom_manager_overriding_objects_works.Foo -write mongoengine/fields.py /^ def write(self, *args, **kwargs):$/;" m class:ImageGridFsProxy -write mongoengine/fields.py /^ def write(self, string):$/;" m class:GridFSProxy -write mongoengine/mongoengine/fields.py /^ def write(self, *args, **kwargs):$/;" m class:ImageGridFsProxy -write mongoengine/mongoengine/fields.py /^ def write(self, string):$/;" m class:GridFSProxy -write_concern mongoengine/tests/queryset/queryset.py /^ write_concern={"w": 0, 'continue_on_error': True})$/;" v class:QuerySetTest.test_bulk_insert.Author -writelines mongoengine/fields.py /^ def writelines(self, *args, **kwargs):$/;" m class:ImageGridFsProxy -writelines mongoengine/fields.py /^ def writelines(self, lines):$/;" m class:GridFSProxy -writelines mongoengine/mongoengine/fields.py /^ def writelines(self, *args, **kwargs):$/;" m class:ImageGridFsProxy -writelines mongoengine/mongoengine/fields.py /^ def writelines(self, lines):$/;" m class:GridFSProxy -x mongoengine/tests/document/instance.py /^ x = IntField(required=True)$/;" v class:InstanceTest.test_document_embedded_clean.TestEmbeddedDocument -x mongoengine/tests/queryset/queryset.py /^ x = IntField()$/;" v class:QuerySetTest.test_no_sub_classes.A -x mongoengine/tests/queryset/queryset.py /^ x = IntField()$/;" v class:QuerySetTest.test_scalar_db_field.TestDoc -x mongoengine/tests/queryset/queryset.py /^ x = IntField()$/;" v class:QuerySetTest.test_scalar_simple.TestDoc -x mongoengine/tests/queryset/queryset.py /^ x = ListField()$/;" v class:QuerySetTest.test_update_using_positional_operator_matches_first.Simple -x mongoengine/tests/queryset/visitor.py /^ x = IntField()$/;" v class:QTest.test_and_combination.TestDoc -x mongoengine/tests/queryset/visitor.py /^ x = IntField()$/;" v class:QTest.test_and_or_combination.TestDoc -x mongoengine/tests/queryset/visitor.py /^ x = IntField()$/;" v class:QTest.test_or_and_or_combination.TestDoc -x mongoengine/tests/queryset/visitor.py /^ x = IntField()$/;" v class:QTest.test_or_combination.TestDoc -x mongoengine/tests/queryset/visitor.py /^ x = IntField()$/;" v class:QTest.test_q_clone.TestDoc -x mongoengine/tests/test_context_managers.py /^ x = IntField()$/;" v class:ContextManagersTest.test_no_sub_classes.A -y mongoengine/tests/document/instance.py /^ y = IntField(required=True)$/;" v class:InstanceTest.test_document_embedded_clean.TestEmbeddedDocument -y mongoengine/tests/queryset/queryset.py /^ y = BooleanField()$/;" v class:QuerySetTest.test_scalar_db_field.TestDoc -y mongoengine/tests/queryset/queryset.py /^ y = BooleanField()$/;" v class:QuerySetTest.test_scalar_simple.TestDoc -y mongoengine/tests/queryset/queryset.py /^ y = IntField()$/;" v class:QuerySetTest.test_no_sub_classes.A -y mongoengine/tests/queryset/visitor.py /^ y = BooleanField()$/;" v class:QTest.test_and_or_combination.TestDoc -y mongoengine/tests/queryset/visitor.py /^ y = BooleanField()$/;" v class:QTest.test_or_and_or_combination.TestDoc -y mongoengine/tests/queryset/visitor.py /^ y = StringField()$/;" v class:QTest.test_and_combination.TestDoc -y mongoengine/tests/test_context_managers.py /^ y = IntField()$/;" v class:ContextManagersTest.test_no_sub_classes.A -year mongoengine/tests/document/indexes.py /^ year = IntField(db_field='yr')$/;" v class:IndexesTest.test_embedded_document_index.Date -year mongoengine/tests/document/indexes.py /^ year = IntField(db_field='yr')$/;" v class:IndexesTest.test_unique_embedded_document.SubDocument -year mongoengine/tests/document/indexes.py /^ year = IntField(db_field='yr')$/;" v class:IndexesTest.test_unique_embedded_document_in_list.SubDocument -year mongoengine/tests/document/indexes.py /^ year = IntField(db_field='yr')$/;" v class:IndexesTest.test_unique_with.Date -year mongoengine/tests/document/indexes.py /^ year = IntField(db_field='yr')$/;" v class:IndexesTest.test_unique_with_embedded_document_and_embedded_unique.SubDocument -years mongoengine/tests/document/instance.py /^ years = IntField()$/;" v class:InstanceTest.setUp.Job -z mongoengine/tests/document/instance.py /^ z = IntField(required=True)$/;" v class:InstanceTest.test_document_embedded_clean.TestEmbeddedDocument -z mongoengine/tests/queryset/queryset.py /^ z = IntField()$/;" v class:QuerySetTest.test_no_sub_classes.B -z mongoengine/tests/test_context_managers.py /^ z = IntField()$/;" v class:ContextManagersTest.test_no_sub_classes.B -zz mongoengine/tests/queryset/queryset.py /^ zz = IntField()$/;" v class:QuerySetTest.test_no_sub_classes.C -zz mongoengine/tests/test_context_managers.py /^ zz = IntField()$/;" v class:ContextManagersTest.test_no_sub_classes.C From b04dc90cdf4e71afb38594af7113a93302527a31 Mon Sep 17 00:00:00 2001 From: Eddie Linder Date: Thu, 20 Dec 2018 00:39:32 +0200 Subject: [PATCH 236/250] Bring back _cls and _id fields just as they return in pymongo --- mongoengine/queryset/base.py | 5 +---- tests/queryset/queryset.py | 24 ++++++++++++++++-------- 2 files changed, 17 insertions(+), 12 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 862a1826..5f11c01e 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -1845,10 +1845,7 @@ class BaseQuerySet(object): # remove it from the doc (we always fetch it so that we can properly # construct documents). fields = self._loaded_fields - if fields and '_id' in doc and ( - (fields.value == QueryFieldList.ONLY and '_id' not in fields.fields) or - (fields.value == QueryFieldList.EXCLUDE and '_id' in fields.fields) - ): + if fields and '_id' in doc and fields.value == QueryFieldList.EXCLUDE and '_id' in fields.fields: del doc['_id'] return doc diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index b44c36df..586913aa 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4635,7 +4635,7 @@ class QuerySetTest(unittest.TestCase): ip = StringField() class User(Document): - id = ObjectIdField('_id') + id = StringField(primary_key=True) name = StringField() age = IntField() price = DecimalField() @@ -4643,9 +4643,10 @@ class QuerySetTest(unittest.TestCase): User.drop_collection() - User.objects.create(name="Bob Dole", age=89, price=Decimal('1.11')) + User.objects.create(id='Bob', name="Bob Dole", age=89, price=Decimal('1.11')) User.objects.create( - name="Barack Obama", + id='Barak', + name="Barak Obama", age=51, price=Decimal('2.22'), last_login=LastLogin( @@ -4673,7 +4674,7 @@ class QuerySetTest(unittest.TestCase): self.assertIsInstance(results[1], dict) self.assertEqual(results[0]['name'], 'Bob Dole') self.assertEqual(results[0]['price'], 1.11) - self.assertEqual(results[1]['name'], 'Barack Obama') + self.assertEqual(results[1]['name'], 'Barak Obama') self.assertEqual(results[1]['price'], 2.22) users = User.objects.only('name', 'last_login').as_pymongo() @@ -4681,10 +4682,12 @@ class QuerySetTest(unittest.TestCase): self.assertIsInstance(results[0], dict) self.assertIsInstance(results[1], dict) self.assertEqual(results[0], { + '_id': 'Bob', 'name': 'Bob Dole' }) self.assertEqual(results[1], { - 'name': 'Barack Obama', + '_id': 'Barak', + 'name': 'Barak Obama', 'last_login': { 'location': 'White House', 'ip': '104.107.108.116' @@ -4701,8 +4704,8 @@ class QuerySetTest(unittest.TestCase): db_field='password_salt', required=True) User.drop_collection() - User(email="ross@example.com", password_salt="SomeSalt", - password_hash="SomeHash").save() + user = User(email="ross@example.com", password_salt="SomeSalt", + password_hash="SomeHash").save() serialized_user = User.objects.exclude( 'password_salt', 'password_hash').as_pymongo()[0] @@ -4714,11 +4717,16 @@ class QuerySetTest(unittest.TestCase): serialized_user = User.objects.exclude( 'password_salt').only('email').as_pymongo()[0] + self.assertEqual(set(['_id', 'email']), set(serialized_user.keys())) + + serialized_user = User.objects.exclude( + 'password_salt', 'id').only('email').as_pymongo()[0] self.assertEqual(set(['email']), set(serialized_user.keys())) serialized_user = User.objects.exclude( 'password_salt').only('email').to_json() - self.assertEqual('[{"email": "ross@example.com"}]', serialized_user) + self.assertEqual('[{"_id": {"$oid": "%s"}, "email": "ross@example.com"}]' % user.id, + serialized_user) def test_only_after_count(self): """Test that only() works after count()""" From 6fbdde63d8d39e00f9d33c8f5ed0d55caee09de6 Mon Sep 17 00:00:00 2001 From: Eddie Linder Date: Thu, 20 Dec 2018 00:57:02 +0200 Subject: [PATCH 237/250] Fix id in test_only_after_count ut --- tests/queryset/queryset.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 586913aa..7490cad3 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4736,19 +4736,19 @@ class QuerySetTest(unittest.TestCase): age = IntField() address = StringField() User.drop_collection() - User(name="User", age=50, - address="Moscow, Russia").save() + user = User(name="User", age=50, + address="Moscow, Russia").save() user_queryset = User.objects(age=50) result = user_queryset.only("name", "age").as_pymongo().first() - self.assertEqual(result, {"name": "User", "age": 50}) + self.assertEqual(result, {"_id": user.id, "name": "User", "age": 50}) result = user_queryset.count() self.assertEqual(result, 1) result = user_queryset.only("name", "age").as_pymongo().first() - self.assertEqual(result, {"name": "User", "age": 50}) + self.assertEqual(result, {"_id": user.id, "name": "User", "age": 50}) def test_no_dereference(self): From 7fd4f792ba30d1ac8061bdb017fe7703493ff0e0 Mon Sep 17 00:00:00 2001 From: Eddie Linder Date: Thu, 20 Dec 2018 01:02:42 +0200 Subject: [PATCH 238/250] Don't hide _cls field when using as_pymongo --- mongoengine/queryset/base.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 5f11c01e..5493ffac 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -1837,10 +1837,6 @@ class BaseQuerySet(object): """Clean up a PyMongo doc, removing fields that were only fetched for the sake of MongoEngine's implementation, and return it. """ - # Always remove _cls as a MongoEngine's implementation detail. - if '_cls' in doc: - del doc['_cls'] - # If the _id was not included in a .only or was excluded in a .exclude, # remove it from the doc (we always fetch it so that we can properly # construct documents). From 363aefe399efc6acc035a846241acd136ca8277d Mon Sep 17 00:00:00 2001 From: Eddie Linder Date: Thu, 20 Dec 2018 01:09:28 +0200 Subject: [PATCH 239/250] Get rid of _get_as_pymongo wrapper altogether as we return raw output --- mongoengine/queryset/base.py | 19 +++---------------- 1 file changed, 3 insertions(+), 16 deletions(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 5493ffac..8ae88422 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -188,7 +188,7 @@ class BaseQuerySet(object): ) if queryset._as_pymongo: - return queryset._get_as_pymongo(queryset._cursor[key]) + return queryset._cursor[key] return queryset._document._from_son( queryset._cursor[key], @@ -690,7 +690,7 @@ class BaseQuerySet(object): self._document._from_son(doc, only_fields=self.only_fields)) elif self._as_pymongo: for doc in docs: - doc_map[doc['_id']] = self._get_as_pymongo(doc) + doc_map[doc['_id']] = doc else: for doc in docs: doc_map[doc['_id']] = self._document._from_son( @@ -1486,7 +1486,7 @@ class BaseQuerySet(object): raw_doc = six.next(self._cursor) if self._as_pymongo: - return self._get_as_pymongo(raw_doc) + return raw_doc doc = self._document._from_son( raw_doc, _auto_dereference=self._auto_dereference, @@ -1833,19 +1833,6 @@ class BaseQuerySet(object): return tuple(data) - def _get_as_pymongo(self, doc): - """Clean up a PyMongo doc, removing fields that were only fetched - for the sake of MongoEngine's implementation, and return it. - """ - # If the _id was not included in a .only or was excluded in a .exclude, - # remove it from the doc (we always fetch it so that we can properly - # construct documents). - fields = self._loaded_fields - if fields and '_id' in doc and fields.value == QueryFieldList.EXCLUDE and '_id' in fields.fields: - del doc['_id'] - - return doc - def _sub_js_fields(self, code): """When fields are specified with [~fieldname] syntax, where *fieldname* is the Python name of a field, *fieldname* will be From 56d9f7a8af1b628c52c69dfa23a6d4374d2a2ac3 Mon Sep 17 00:00:00 2001 From: Eddie Linder Date: Thu, 20 Dec 2018 01:14:23 +0200 Subject: [PATCH 240/250] Fix ut to pass constantly --- tests/queryset/queryset.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index 7490cad3..faadfe0c 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4704,8 +4704,8 @@ class QuerySetTest(unittest.TestCase): db_field='password_salt', required=True) User.drop_collection() - user = User(email="ross@example.com", password_salt="SomeSalt", - password_hash="SomeHash").save() + User(email="ross@example.com", password_salt="SomeSalt", + password_hash="SomeHash").save() serialized_user = User.objects.exclude( 'password_salt', 'password_hash').as_pymongo()[0] @@ -4724,8 +4724,8 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(set(['email']), set(serialized_user.keys())) serialized_user = User.objects.exclude( - 'password_salt').only('email').to_json() - self.assertEqual('[{"_id": {"$oid": "%s"}, "email": "ross@example.com"}]' % user.id, + 'password_salt', 'id').only('email').to_json() + self.assertEqual('[{"email": "ross@example.com"}]', serialized_user) def test_only_after_count(self): From 69a99c70c69dda1e0116566308adfb6e93dfede9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Mon, 24 Dec 2018 23:51:30 +0100 Subject: [PATCH 241/250] minor update to .all() doc to make it clear that it does not return a list but a queryset --- mongoengine/queryset/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 862a1826..af19bf34 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -215,7 +215,7 @@ class BaseQuerySet(object): # Core functions def all(self): - """Returns all documents.""" + """Returns a copy of the current QuerySet.""" return self.__call__() def filter(self, *q_objs, **query): From e7000db4914dcba49b2022133816ddbcbc630bbd Mon Sep 17 00:00:00 2001 From: G Roques Date: Sat, 29 Dec 2018 13:08:39 -0600 Subject: [PATCH 242/250] Add LongField to Fields list --- docs/guide/defining-documents.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/guide/defining-documents.rst b/docs/guide/defining-documents.rst index 4449b00b..911de36d 100644 --- a/docs/guide/defining-documents.rst +++ b/docs/guide/defining-documents.rst @@ -85,6 +85,7 @@ are as follows: * :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` From c6c68abfccff298fbe3f173aa337fe6e62d85d4d Mon Sep 17 00:00:00 2001 From: Eddie Linder Date: Fri, 11 Jan 2019 19:23:47 +0200 Subject: [PATCH 243/250] Update changelog and add another ut case --- docs/changelog.rst | 1 + tests/queryset/queryset.py | 9 ++++++--- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index def5cc34..d8bed7e6 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -6,6 +6,7 @@ Development =========== - (Fill this out as you fix issues and develop your features). - Fix .only() working improperly after using .count() of the same instance of QuerySet +- POTENTIAL BREAKING CHANGE: All result fields are now passed, including internal fields (_cls, _id) when using `QuerySet.as_pymongo` #1976 ================= Changes in 0.16.3 diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index faadfe0c..c183aa86 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4709,19 +4709,22 @@ class QuerySetTest(unittest.TestCase): serialized_user = User.objects.exclude( 'password_salt', 'password_hash').as_pymongo()[0] - self.assertEqual(set(['_id', 'email']), set(serialized_user.keys())) + self.assertEqual({'_id', 'email'}, set(serialized_user.keys())) serialized_user = User.objects.exclude( 'id', 'password_salt', 'password_hash').to_json() self.assertEqual('[{"email": "ross@example.com"}]', serialized_user) + serialized_user = User.objects.only('email').as_pymongo()[0] + self.assertEqual({'_id', 'email'}, set(serialized_user.keys())) + serialized_user = User.objects.exclude( 'password_salt').only('email').as_pymongo()[0] - self.assertEqual(set(['_id', 'email']), set(serialized_user.keys())) + self.assertEqual({'_id', 'email'}, set(serialized_user.keys())) serialized_user = User.objects.exclude( 'password_salt', 'id').only('email').as_pymongo()[0] - self.assertEqual(set(['email']), set(serialized_user.keys())) + self.assertEqual({'email'}, set(serialized_user.keys())) serialized_user = User.objects.exclude( 'password_salt', 'id').only('email').to_json() From 4c054bf316c0a7ec0823c0a8d9f8289998732b3b Mon Sep 17 00:00:00 2001 From: Hamidreza Date: Wed, 13 Feb 2019 21:27:54 +0330 Subject: [PATCH 244/250] Fix indentation in LazyReferenceField ref doc --- mongoengine/fields.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 9062333e..df6be2f0 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -2251,9 +2251,9 @@ class LazyReferenceField(BaseField): :param reverse_delete_rule: Determines what to do when the referring object is deleted :param passthrough: When trying to access unknown fields, the - :class:`~mongoengine.base.datastructure.LazyReference` instance will - automatically call `fetch()` and try to retrive the field on the fetched - document. Note this only work getting field (not setting or deleting). + :class:`~mongoengine.base.datastructure.LazyReference` instance will + automatically call `fetch()` and try to retrive the field on the fetched + document. Note this only work getting field (not setting or deleting). """ # XXX ValidationError raised outside of the "validate" method. if ( From 3484ceabb8a092655764ae5893d67b59644c4b88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sat, 16 Feb 2019 22:54:00 +0100 Subject: [PATCH 245/250] Fix documentation regarding limitation with fields with underscore in their name in DynamicDocument --- mongoengine/document.py | 2 +- tests/document/dynamic.py | 76 ++++++++++++++++++++++++++++++++++++--- 2 files changed, 72 insertions(+), 6 deletions(-) diff --git a/mongoengine/document.py b/mongoengine/document.py index 0945a8ed..7a491b7d 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -1016,7 +1016,7 @@ class DynamicDocument(six.with_metaclass(TopLevelDocumentMetaclass, Document)): .. note:: - There is one caveat on Dynamic Documents: fields cannot start with `_` + There is one caveat on Dynamic Documents: undeclared fields cannot start with `_` """ # The __metaclass__ attribute is removed by 2to3 when running with Python3 diff --git a/tests/document/dynamic.py b/tests/document/dynamic.py index 94cea134..44548d27 100644 --- a/tests/document/dynamic.py +++ b/tests/document/dynamic.py @@ -1,16 +1,15 @@ import unittest 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() @@ -98,6 +97,72 @@ class DynamicTest(unittest.TestCase): 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() @@ -369,5 +434,6 @@ class DynamicTest(unittest.TestCase): person.save() self.assertEqual(Person.objects.first().age, 35) + if __name__ == '__main__': unittest.main() From 2919e6765c71abe6a07ed5a8fefa5f8e6a31d5e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 17 Feb 2019 21:45:05 +0100 Subject: [PATCH 246/250] separate test on binary field (#1983) --- tests/fields/fields.py | 78 +---------------------- tests/fields/test_binary_field.py | 100 ++++++++++++++++++++++++++++++ 2 files changed, 103 insertions(+), 75 deletions(-) create mode 100644 tests/fields/test_binary_field.py diff --git a/tests/fields/fields.py b/tests/fields/fields.py index b09c0a2d..05810f2c 100644 --- a/tests/fields/fields.py +++ b/tests/fields/fields.py @@ -17,7 +17,7 @@ except ImportError: from decimal import Decimal -from bson import Binary, DBRef, ObjectId, SON +from bson import DBRef, ObjectId, SON try: from bson.int64 import Int64 except ImportError: @@ -1699,7 +1699,7 @@ class FieldTest(MongoDBTestCase): post.save() post = BlogPost() - post.info = {'title' : 'dollar_sign', 'details' : {'te$t' : 'test'} } + post.info = {'title': 'dollar_sign', 'details': {'te$t': 'test'}} post.save() post = BlogPost() @@ -1718,7 +1718,7 @@ class FieldTest(MongoDBTestCase): 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) @@ -2934,78 +2934,6 @@ class FieldTest(MongoDBTestCase): doc = Doc.objects.get(ref=doc1.pk) self.assertEqual(doc, doc2) - 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_binary_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_binary_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_binary_field_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_binary_field_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_choices_allow_using_sets_as_choices(self): """Ensure that sets can be used when setting choices """ diff --git a/tests/fields/test_binary_field.py b/tests/fields/test_binary_field.py new file mode 100644 index 00000000..d96f59e9 --- /dev/null +++ b/tests/fields/test_binary_field.py @@ -0,0 +1,100 @@ +# -*- coding: utf-8 -*- +import datetime +import unittest +import uuid +import math +import itertools +import re +import sys + +from nose.plugins.skip import SkipTest +import six + +try: + import dateutil +except ImportError: + dateutil = None + +from bson import Binary + +try: + from bson.int64 import Int64 +except ImportError: + Int64 = long + +from mongoengine import * +from tests.utils import MongoDBTestCase + + +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_binary_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_binary_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_binary_field_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_binary_field_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()) From e02261be6d86489945ad022ed73ae45c39fcc9a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 17 Feb 2019 21:54:36 +0100 Subject: [PATCH 247/250] add test coverage for #1557 --- docs/changelog.rst | 1 + tests/fields/test_binary_field.py | 77 +++++++++++++++++++++++-------- 2 files changed, 58 insertions(+), 20 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index d8bed7e6..25e1a585 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -7,6 +7,7 @@ Development - (Fill this out as you fix issues and develop your features). - Fix .only() working improperly after using .count() of the same instance of QuerySet - POTENTIAL BREAKING CHANGE: All result fields are now passed, including internal fields (_cls, _id) when using `QuerySet.as_pymongo` #1976 +- Fix InvalidStringData error when using modify on a BinaryField #1127 ================= Changes in 0.16.3 diff --git a/tests/fields/test_binary_field.py b/tests/fields/test_binary_field.py index d96f59e9..b0427766 100644 --- a/tests/fields/test_binary_field.py +++ b/tests/fields/test_binary_field.py @@ -1,30 +1,16 @@ # -*- coding: utf-8 -*- -import datetime -import unittest import uuid -import math -import itertools -import re -import sys from nose.plugins.skip import SkipTest import six -try: - import dateutil -except ImportError: - dateutil = None - from bson import Binary -try: - from bson.int64 import Int64 -except ImportError: - Int64 = long - 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): @@ -46,7 +32,7 @@ class TestBinaryField(MongoDBTestCase): self.assertEqual(MIME_TYPE, attachment_1.content_type) self.assertEqual(BLOB, six.binary_type(attachment_1.blob)) - def test_binary_validation_succeeds(self): + def test_validation_succeeds(self): """Ensure that valid values can be assigned to binary fields. """ class AttachmentRequired(Document): @@ -65,7 +51,7 @@ class TestBinaryField(MongoDBTestCase): self.assertRaises(ValidationError, AttachmentSizeLimit(blob=_5_BYTES).validate) AttachmentSizeLimit(blob=_4_BYTES).validate() - def test_binary_validation_fails(self): + def test_validation_fails(self): """Ensure that invalid values cannot be assigned to binary fields.""" class Attachment(Document): @@ -74,7 +60,7 @@ class TestBinaryField(MongoDBTestCase): for invalid_data in (2, u'Im_a_unicode', ['some_str']): self.assertRaises(ValidationError, Attachment(blob=invalid_data).validate) - def test_binary_field_primary(self): + def test__primary(self): class Attachment(Document): id = BinaryField(primary_key=True) @@ -86,7 +72,7 @@ class TestBinaryField(MongoDBTestCase): att.delete() self.assertEqual(0, Attachment.objects.count()) - def test_binary_field_primary_filter_by_binary_pk_as_str(self): + def test_primary_filter_by_binary_pk_as_str(self): raise SkipTest("Querying by id as string is not currently supported") class Attachment(Document): @@ -98,3 +84,54 @@ class TestBinaryField(MongoDBTestCase): 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') + 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) + self.assertEqual(fetched.bin_field, Binary(BIN_VALUE)) From f4873fee18793543266d10ac5d7fbd0341ba2442 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 17 Feb 2019 22:50:42 +0100 Subject: [PATCH 248/250] add additional test for #1976 --- tests/queryset/queryset.py | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/tests/queryset/queryset.py b/tests/queryset/queryset.py index c183aa86..d3a2418a 100644 --- a/tests/queryset/queryset.py +++ b/tests/queryset/queryset.py @@ -4628,8 +4628,6 @@ class QuerySetTest(unittest.TestCase): self.assertEqual(doc_objects, Doc.objects.from_json(json_data)) def test_as_pymongo(self): - from decimal import Decimal - class LastLogin(EmbeddedDocument): location = StringField() ip = StringField() @@ -4694,6 +4692,24 @@ class QuerySetTest(unittest.TestCase): } }) + def test_as_pymongo_returns_cls_attribute_when_using_inheritance(self): + class User(Document): + name = StringField() + meta = {'allow_inheritance': True} + + User.drop_collection() + + user = User(name="Bob Dole").save() + result = User.objects.as_pymongo().first() + self.assertEqual( + result, + { + '_cls': 'User', + '_id': user.id, + 'name': 'Bob Dole' + } + ) + def test_as_pymongo_json_limit_fields(self): class User(Document): From 201f3008b1c451c93d112e5905fe7e64259a8d7e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Sun, 17 Feb 2019 22:56:56 +0100 Subject: [PATCH 249/250] Fix for py3 in binary field test --- tests/fields/test_binary_field.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/tests/fields/test_binary_field.py b/tests/fields/test_binary_field.py index b0427766..8af75d4e 100644 --- a/tests/fields/test_binary_field.py +++ b/tests/fields/test_binary_field.py @@ -119,7 +119,10 @@ class TestBinaryField(MongoDBTestCase): set__bin_field=BIN_VALUE ) self.assertEqual(doc.some_field, 'test') - self.assertEqual(doc.bin_field, Binary(BIN_VALUE)) + 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""" @@ -134,4 +137,7 @@ class TestBinaryField(MongoDBTestCase): 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) - self.assertEqual(fetched.bin_field, Binary(BIN_VALUE)) + if six.PY3: + self.assertEqual(fetched.bin_field, BIN_VALUE) + else: + self.assertEqual(fetched.bin_field, Binary(BIN_VALUE)) From 57a38282a9a583983c6625d3e81731f9b461786f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Mon, 18 Feb 2019 22:03:03 +0100 Subject: [PATCH 250/250] Add DeprecationWarning for EmbeddedDocument.save & .reload - those will be removed soon --- docs/changelog.rst | 1 + mongoengine/document.py | 6 ++++++ tests/document/instance.py | 24 +++++++++++++++++++++--- 3 files changed, 28 insertions(+), 3 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 25e1a585..dbd328d8 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -8,6 +8,7 @@ Development - Fix .only() working improperly after using .count() of the same instance of QuerySet - POTENTIAL BREAKING CHANGE: All result fields are now passed, including internal fields (_cls, _id) when using `QuerySet.as_pymongo` #1976 - 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 ================= Changes in 0.16.3 diff --git a/mongoengine/document.py b/mongoengine/document.py index 7a491b7d..57364ae6 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -90,9 +90,15 @@ class EmbeddedDocument(six.with_metaclass(DocumentMetaclass, BaseDocument)): return data def save(self, *args, **kwargs): + warnings.warn("EmbeddedDocument.save is deprecated and will be removed in a next version of mongoengine." + "Use the parent document's .save() or ._instance.save()", + DeprecationWarning, stacklevel=2) self._instance.save(*args, **kwargs) def reload(self, *args, **kwargs): + warnings.warn("EmbeddedDocument.reload is deprecated and will be removed in a next version of mongoengine." + "Use the parent document's .reload() or ._instance.reload()", + DeprecationWarning, stacklevel=2) self._instance.reload(*args, **kwargs) diff --git a/tests/document/instance.py b/tests/document/instance.py index 5319ace4..39e47524 100644 --- a/tests/document/instance.py +++ b/tests/document/instance.py @@ -7,6 +7,8 @@ import uuid import weakref from datetime import datetime + +import warnings from bson import DBRef, ObjectId from pymongo.errors import DuplicateKeyError @@ -1482,7 +1484,7 @@ class InstanceTest(MongoDBTestCase): Message.drop_collection() # All objects share the same id, but each in a different collection - user = User(id=1, name='user-name')#.save() + user = User(id=1, name='user-name') # .save() message = Message(id=1, author=user).save() message.author.name = 'tutu' @@ -2000,7 +2002,6 @@ class InstanceTest(MongoDBTestCase): child_record.delete() self.assertEqual(Record.objects(name='parent').get().children, []) - def test_reverse_delete_rule_with_custom_id_field(self): """Ensure that a referenced document with custom primary key is also deleted upon deletion. @@ -3086,6 +3087,24 @@ class InstanceTest(MongoDBTestCase): "UNDEFINED", system.nodes["node"].parameters["param"].macros["test"].value) + def test_embedded_document_save_reload_warning(self): + """Relates to #1570""" + class Embedded(EmbeddedDocument): + pass + + class Doc(Document): + emb = EmbeddedDocumentField(Embedded) + + doc = Doc(emb=Embedded()).save() + doc.emb.save() # Make sure its still working + with warnings.catch_warnings(): + warnings.simplefilter("error", DeprecationWarning) + with self.assertRaises(DeprecationWarning): + doc.emb.save() + + with self.assertRaises(DeprecationWarning): + doc.emb.reload() + def test_embedded_document_equality(self): class Test(Document): field = StringField(required=True) @@ -3381,7 +3400,6 @@ class InstanceTest(MongoDBTestCase): class User(Document): company = ReferenceField(Company) - # Ensure index creation exception aren't swallowed (#1688) with self.assertRaises(DuplicateKeyError): User.objects().select_related()