From ee6ef1ff4b6efefdb3d12b271c24c6adc466b12a Mon Sep 17 00:00:00 2001 From: Bastien Gerard Date: Tue, 8 Dec 2020 23:08:21 +0100 Subject: [PATCH 1/6] autoformat w prettier --- .travis.yml | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/.travis.yml b/.travis.yml index 05ce782d..b29dab33 100644 --- a/.travis.yml +++ b/.travis.yml @@ -16,11 +16,11 @@ language: python dist: xenial python: -- 3.6 -- 3.7 -- 3.8 -- 3.9 -- pypy3 + - 3.6 + - 3.7 + - 3.8 + - 3.9 + - pypy3 env: global: @@ -42,14 +42,14 @@ matrix: fast_finish: true include: - - python: 3.7 - env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_6} - - python: 3.7 - env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_9} - - python: 3.7 - env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_11} - - python: 3.8 - env: MONGODB=${MONGODB_4_0} PYMONGO=${PYMONGO_3_11} + - python: 3.7 + env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_6} + - python: 3.7 + env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_9} + - python: 3.7 + env: MONGODB=${MONGODB_3_6} PYMONGO=${PYMONGO_3_11} + - python: 3.8 + env: MONGODB=${MONGODB_4_0} PYMONGO=${PYMONGO_3_11} install: # Install Mongo @@ -69,7 +69,7 @@ before_script: - ${PWD}/mongodb-linux-x86_64-${MONGODB}/bin/mongod --dbpath ${PWD}/mongodb-linux-x86_64-${MONGODB}/data --logpath ${PWD}/mongodb-linux-x86_64-${MONGODB}/mongodb.log --fork # Run pre-commit hooks (black, flake8, etc) on entire codebase - if [[ $TRAVIS_PYTHON_VERSION == $MAIN_PYTHON_VERSION ]]; then pre-commit run -a; else echo "pre-commit checks only runs on py37"; fi - - mongo --eval 'db.version();' # Make sure mongo is awake + - mongo --eval 'db.version();' # Make sure mongo is awake script: - tox -e $(echo py$TRAVIS_PYTHON_VERSION-mg$PYMONGO | tr -d . | sed -e 's/pypypy/pypy/') -- -a "--cov=mongoengine" @@ -83,8 +83,8 @@ notifications: # Only run builds on the master branch and GitHub releases (tagged as vX.Y.Z) branches: only: - - master - - /^v.*$/ + - master + - /^v.*$/ # Whenever a new release is created via GitHub, publish it on PyPI. deploy: From c00a378776b654beac3358ae6af230e13257e1bf Mon Sep 17 00:00:00 2001 From: Bastien Gerard Date: Tue, 8 Dec 2020 23:10:07 +0100 Subject: [PATCH 2/6] autoformat with updated black --- .pre-commit-config.yaml | 2 +- mongoengine/base/document.py | 18 ++- mongoengine/base/fields.py | 3 +- mongoengine/context_managers.py | 3 +- mongoengine/dereference.py | 3 +- mongoengine/pymongo_support.py | 3 +- mongoengine/queryset/base.py | 17 +-- mongoengine/queryset/visitor.py | 12 +- tests/document/test_class_methods.py | 29 ++--- tests/document/test_delta.py | 5 +- tests/document/test_indexes.py | 36 ++---- tests/document/test_inheritance.py | 20 ++-- tests/document/test_instance.py | 15 +-- tests/document/test_validation.py | 6 +- tests/fields/test_binary_field.py | 6 +- tests/fields/test_decimal_field.py | 3 +- tests/fields/test_fields.py | 45 +++----- tests/fields/test_file_field.py | 12 +- tests/fields/test_float_field.py | 3 +- tests/fields/test_geo_fields.py | 9 +- tests/fields/test_int_field.py | 3 +- tests/fields/test_long_field.py | 3 +- tests/fields/test_reference_field.py | 3 +- tests/fields/test_url_field.py | 3 +- tests/fields/test_uuid_field.py | 3 +- tests/queryset/test_field_list.py | 9 +- tests/queryset/test_queryset.py | 162 +++++++++------------------ tests/queryset/test_transform.py | 6 +- tests/queryset/test_visitor.py | 24 ++-- tests/test_connection.py | 24 ++-- tests/test_context_managers.py | 6 +- tests/test_dereference.py | 39 +++---- tests/test_replicaset_connection.py | 3 +- 33 files changed, 189 insertions(+), 349 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index e11640b8..cb68249a 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,7 +1,7 @@ fail_fast: false repos: - repo: https://github.com/ambv/black - rev: 19.10b0 + rev: 20.8b1 hooks: - id: black - repo: https://gitlab.com/pycqa/flake8 diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 019d62d0..32ad0adc 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -244,8 +244,7 @@ class BaseDocument: return iter(self._fields_ordered) def __getitem__(self, name): - """Dictionary-style field access, return a field's value if present. - """ + """Dictionary-style field access, return a field's value if present.""" try: if name in self._fields_ordered: return getattr(self, name) @@ -254,8 +253,7 @@ class BaseDocument: raise KeyError(name) def __setitem__(self, name, value): - """Dictionary-style field access, set a field's value. - """ + """Dictionary-style field access, set a field's value.""" # Ensure that the field exists before settings its value if not self._dynamic and name not in self._fields: raise KeyError(name) @@ -617,8 +615,7 @@ class BaseDocument: ) def _get_changed_fields(self): - """Return a list of all fields that have explicitly been changed. - """ + """Return a list of all fields that have explicitly been changed.""" EmbeddedDocument = _import_class("EmbeddedDocument") ReferenceField = _import_class("ReferenceField") GenericReferenceField = _import_class("GenericReferenceField") @@ -750,8 +747,7 @@ class BaseDocument: @classmethod def _from_son(cls, son, _auto_dereference=True, created=False): - """Create an instance of a Document (subclass) from a PyMongo SON (dict) - """ + """Create an instance of a Document (subclass) from a PyMongo SON (dict)""" if son and not isinstance(son, dict): raise ValueError( "The source SON object needs to be of type 'dict' but a '%s' was found" @@ -800,7 +796,8 @@ class BaseDocument: ["Field '{}' - {}".format(k, v) for k, v in errors_dict.items()] ) msg = "Invalid data to create a `{}` instance.\n{}".format( - cls._class_name, errors, + cls._class_name, + errors, ) raise InvalidDocumentError(msg) @@ -1165,8 +1162,7 @@ class BaseDocument: @classmethod def _translate_field_name(cls, field, sep="."): - """Translate a field attribute name to a database field name. - """ + """Translate a field attribute name to a database field name.""" parts = field.split(sep) parts = [f.db_field for f in cls._lookup_field(parts)] return ".".join(parts) diff --git a/mongoengine/base/fields.py b/mongoengine/base/fields.py index 347940f5..8df3d089 100644 --- a/mongoengine/base/fields.py +++ b/mongoengine/base/fields.py @@ -117,8 +117,7 @@ class BaseField: BaseField.creation_counter += 1 def __get__(self, instance, owner): - """Descriptor for retrieving a value from a field in a document. - """ + """Descriptor for retrieving a value from a field in a document.""" if instance is None: # Document class being used rather than a document object return self diff --git a/mongoengine/context_managers.py b/mongoengine/context_managers.py index 5f2b5229..257d27f8 100644 --- a/mongoengine/context_managers.py +++ b/mongoengine/context_managers.py @@ -184,8 +184,7 @@ class query_counter: """ def __init__(self, alias=DEFAULT_CONNECTION_NAME): - """Construct the query_counter - """ + """Construct the query_counter""" self.db = get_db(alias=alias) self.initial_profiling_level = None self._ctx_query_counter = 0 # number of queries issued by the context diff --git a/mongoengine/dereference.py b/mongoengine/dereference.py index ff608a3b..a89bc15a 100644 --- a/mongoengine/dereference.py +++ b/mongoengine/dereference.py @@ -157,8 +157,7 @@ class DeReference: return reference_map def _fetch_objects(self, doc_type=None): - """Fetch all references and convert to their document objects - """ + """Fetch all references and convert to their document objects""" object_map = {} for collection, dbrefs in self.reference_map.items(): diff --git a/mongoengine/pymongo_support.py b/mongoengine/pymongo_support.py index 9cf9e2ae..dc7aaa6b 100644 --- a/mongoengine/pymongo_support.py +++ b/mongoengine/pymongo_support.py @@ -14,8 +14,7 @@ IS_PYMONGO_GTE_37 = PYMONGO_VERSION >= _PYMONGO_37 def count_documents( collection, filter, skip=None, limit=None, hint=None, collation=None ): - """Pymongo>3.7 deprecates count in favour of count_documents - """ + """Pymongo>3.7 deprecates count in favour of count_documents""" if limit == 0: return 0 # Pymongo raises an OperationFailure if called with limit=0 diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index f41cb81b..43e03ef8 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -189,7 +189,8 @@ class BaseQuerySet: if queryset._scalar: return queryset._get_scalar( queryset._document._from_son( - queryset._cursor[key], _auto_dereference=self._auto_dereference, + queryset._cursor[key], + _auto_dereference=self._auto_dereference, ) ) @@ -197,7 +198,8 @@ class BaseQuerySet: return queryset._cursor[key] return queryset._document._from_son( - queryset._cursor[key], _auto_dereference=self._auto_dereference, + queryset._cursor[key], + _auto_dereference=self._auto_dereference, ) raise TypeError("Provide a slice or an integer index") @@ -720,7 +722,7 @@ class BaseQuerySet: return queryset.filter(pk=object_id).first() def in_bulk(self, object_ids): - """"Retrieve a set of documents by their ids. + """ "Retrieve a set of documents by their ids. :param object_ids: a list or tuple of ObjectId's :rtype: dict of ObjectId's as keys and collection-specific @@ -738,7 +740,8 @@ class BaseQuerySet: else: for doc in docs: doc_map[doc["_id"]] = self._document._from_son( - doc, _auto_dereference=self._auto_dereference, + doc, + _auto_dereference=self._auto_dereference, ) return doc_map @@ -1556,8 +1559,7 @@ class BaseQuerySet: # Iterator helpers def __next__(self): - """Wrap the result in a :class:`~mongoengine.Document` object. - """ + """Wrap the result in a :class:`~mongoengine.Document` object.""" if self._none or self._empty: raise StopIteration @@ -1567,7 +1569,8 @@ class BaseQuerySet: return raw_doc doc = self._document._from_son( - raw_doc, _auto_dereference=self._auto_dereference, + raw_doc, + _auto_dereference=self._auto_dereference, ) if self._scalar: diff --git a/mongoengine/queryset/visitor.py b/mongoengine/queryset/visitor.py index a2448f28..9e26d4e8 100644 --- a/mongoengine/queryset/visitor.py +++ b/mongoengine/queryset/visitor.py @@ -13,17 +13,14 @@ def warn_empty_is_deprecated(): class QNodeVisitor: - """Base visitor class for visiting Q-object nodes in a query tree. - """ + """Base visitor class for visiting Q-object nodes in a query tree.""" def visit_combination(self, combination): - """Called by QCombination objects. - """ + """Called by QCombination objects.""" return combination def visit_query(self, query): - """Called by (New)Q objects. - """ + """Called by (New)Q objects.""" return query @@ -49,8 +46,7 @@ class SimplificationVisitor(QNodeVisitor): return combination def _query_conjunction(self, queries): - """Merges query dicts - effectively &ing them together. - """ + """Merges query dicts - effectively &ing them together.""" query_ops = set() combined_query = {} for query in queries: diff --git a/tests/document/test_class_methods.py b/tests/document/test_class_methods.py index 0276457c..7a9428df 100644 --- a/tests/document/test_class_methods.py +++ b/tests/document/test_class_methods.py @@ -26,16 +26,14 @@ class TestClassMethods(unittest.TestCase): self.db.drop_collection(collection) def test_definition(self): - """Ensure that document may be defined using fields. - """ + """Ensure that document may be defined using fields.""" assert ["_cls", "age", "id", "name"] == sorted(self.Person._fields.keys()) assert ["IntField", "ObjectIdField", "StringField", "StringField"] == sorted( [x.__class__.__name__ for x in self.Person._fields.values()] ) def test_get_db(self): - """Ensure that get_db returns the expected db. - """ + """Ensure that get_db returns the expected db.""" db = self.Person._get_db() assert self.db == db @@ -47,15 +45,13 @@ class TestClassMethods(unittest.TestCase): assert collection_name == self.Person._get_collection_name() def test_get_collection(self): - """Ensure that get_collection returns the expected collection. - """ + """Ensure that get_collection returns the expected collection.""" collection_name = "person" collection = self.Person._get_collection() assert self.db[collection_name] == collection def test_drop_collection(self): - """Ensure that the collection may be dropped from the database. - """ + """Ensure that the collection may be dropped from the database.""" collection_name = "person" self.Person(name="Test").save() assert collection_name in list_collection_names(self.db) @@ -77,7 +73,7 @@ class TestClassMethods(unittest.TestCase): assert self.Person._meta["delete_rules"] == {(Job, "employee"): NULLIFY} def test_compare_indexes(self): - """ Ensure that the indexes are properly created and that + """Ensure that the indexes are properly created and that compare_indexes identifies the missing/extra indexes """ @@ -110,7 +106,7 @@ class TestClassMethods(unittest.TestCase): } def test_compare_indexes_inheritance(self): - """ Ensure that the indexes are properly created and that + """Ensure that the indexes are properly created and that compare_indexes identifies the missing/extra indexes for subclassed documents (_cls included) """ @@ -150,7 +146,7 @@ class TestClassMethods(unittest.TestCase): } def test_compare_indexes_multiple_subclasses(self): - """ Ensure that compare_indexes behaves correctly if called from a + """Ensure that compare_indexes behaves correctly if called from a class, which base class has multiple subclasses """ @@ -203,7 +199,7 @@ class TestClassMethods(unittest.TestCase): assert actual == expected def test_list_indexes_inheritance(self): - """ ensure that all of the indexes are listed regardless of the super- + """ensure that all of the indexes are listed regardless of the super- or sub-class that we call it from """ @@ -260,8 +256,7 @@ class TestClassMethods(unittest.TestCase): assert Vaccine._meta["delete_rules"][(Cat, "vaccine_made")] == PULL def test_collection_naming(self): - """Ensure that a collection with a specified name may be used. - """ + """Ensure that a collection with a specified name may be used.""" class DefaultNamingTest(Document): pass @@ -316,8 +311,7 @@ class TestClassMethods(unittest.TestCase): assert "basedocument" == MyDocument._get_collection_name() def test_custom_collection_name_operations(self): - """Ensure that a collection with a specified name is used as expected. - """ + """Ensure that a collection with a specified name is used as expected.""" collection_name = "personCollTest" class Person(Document): @@ -337,8 +331,7 @@ class TestClassMethods(unittest.TestCase): assert collection_name not in list_collection_names(self.db) def test_collection_name_and_primary(self): - """Ensure that a collection with a specified name may be used. - """ + """Ensure that a collection with a specified name may be used.""" class Person(Document): name = StringField(primary_key=True) diff --git a/tests/document/test_delta.py b/tests/document/test_delta.py index ed3bb67b..2aae0af6 100644 --- a/tests/document/test_delta.py +++ b/tests/document/test_delta.py @@ -643,7 +643,10 @@ class TestDelta(MongoDBTestCase): doc.save() doc = doc.reload(10) - assert doc._delta() == ({}, {},) + assert doc._delta() == ( + {}, + {}, + ) del doc.embedded_field.list_field[2].list_field assert doc._delta() == ( {}, diff --git a/tests/document/test_indexes.py b/tests/document/test_indexes.py index 726eebe5..55a56931 100644 --- a/tests/document/test_indexes.py +++ b/tests/document/test_indexes.py @@ -171,8 +171,7 @@ class TestIndexes(unittest.TestCase): assert MyDoc._meta["index_specs"] == [{"fields": [("keywords", 1)]}] def test_embedded_document_index_meta(self): - """Ensure that embedded document indexes are created explicitly - """ + """Ensure that embedded document indexes are created explicitly""" class Rank(EmbeddedDocument): title = StringField(required=True) @@ -194,8 +193,7 @@ class TestIndexes(unittest.TestCase): assert [("rank.title", 1)] in info def test_explicit_geo2d_index(self): - """Ensure that geo2d indexes work when created via meta[indexes] - """ + """Ensure that geo2d indexes work when created via meta[indexes]""" class Place(Document): location = DictField() @@ -209,8 +207,7 @@ class TestIndexes(unittest.TestCase): assert [("location.point", "2d")] in info def test_explicit_geo2d_index_embedded(self): - """Ensure that geo2d indexes work when created via meta[indexes] - """ + """Ensure that geo2d indexes work when created via meta[indexes]""" class EmbeddedLocation(EmbeddedDocument): location = DictField() @@ -229,8 +226,7 @@ class TestIndexes(unittest.TestCase): assert [("current.location.point", "2d")] in info def test_explicit_geosphere_index(self): - """Ensure that geosphere indexes work when created via meta[indexes] - """ + """Ensure that geosphere indexes work when created via meta[indexes]""" class Place(Document): location = DictField() @@ -246,8 +242,7 @@ class TestIndexes(unittest.TestCase): assert [("location.point", "2dsphere")] in info def test_explicit_geohaystack_index(self): - """Ensure that geohaystack indexes work when created via meta[indexes] - """ + """Ensure that geohaystack indexes work when created via meta[indexes]""" pytest.skip( "GeoHaystack index creation is not supported for now" "from meta, as it requires a bucketSize parameter." @@ -268,8 +263,7 @@ class TestIndexes(unittest.TestCase): assert [("location.point", "geoHaystack")] in info def test_create_geohaystack_index(self): - """Ensure that geohaystack indexes can be created - """ + """Ensure that geohaystack indexes can be created""" class Place(Document): location = DictField() @@ -364,8 +358,7 @@ class TestIndexes(unittest.TestCase): assert sorted(info.keys()) == ["_cls_1_user_guid_1", "_id_"] def test_embedded_document_index(self): - """Tests settings an index on an embedded document - """ + """Tests settings an index on an embedded document""" class Date(EmbeddedDocument): year = IntField(db_field="yr") @@ -382,8 +375,7 @@ class TestIndexes(unittest.TestCase): assert sorted(info.keys()) == ["_id_", "date.yr_-1"] def test_list_embedded_document_index(self): - """Ensure list embedded documents can be indexed - """ + """Ensure list embedded documents can be indexed""" class Tag(EmbeddedDocument): name = StringField(db_field="tag") @@ -419,8 +411,7 @@ class TestIndexes(unittest.TestCase): assert sorted(info.keys()) == ["_cls_1", "_id_"] def test_covered_index(self): - """Ensure that covered indexes can be used - """ + """Ensure that covered indexes can be used""" class Test(Document): a = IntField() @@ -558,8 +549,7 @@ class TestIndexes(unittest.TestCase): assert [x.name for x in query_result] == sorted(names) def test_unique(self): - """Ensure that uniqueness constraints are applied to fields. - """ + """Ensure that uniqueness constraints are applied to fields.""" class BlogPost(Document): title = StringField() @@ -607,8 +597,7 @@ class TestIndexes(unittest.TestCase): ) def test_unique_with(self): - """Ensure that unique_with constraints are applied to fields. - """ + """Ensure that unique_with constraints are applied to fields.""" class Date(EmbeddedDocument): year = IntField(db_field="yr") @@ -633,8 +622,7 @@ class TestIndexes(unittest.TestCase): post3.save() def test_unique_embedded_document(self): - """Ensure that uniqueness constraints are applied to fields on embedded documents. - """ + """Ensure that uniqueness constraints are applied to fields on embedded documents.""" class SubDocument(EmbeddedDocument): year = IntField(db_field="yr") diff --git a/tests/document/test_inheritance.py b/tests/document/test_inheritance.py index e7901f05..bd694a1c 100644 --- a/tests/document/test_inheritance.py +++ b/tests/document/test_inheritance.py @@ -45,8 +45,7 @@ class TestInheritance(MongoDBTestCase): test_doc.delete() def test_superclasses(self): - """Ensure that the correct list of superclasses is assembled. - """ + """Ensure that the correct list of superclasses is assembled.""" class Animal(Document): meta = {"allow_inheritance": True} @@ -216,8 +215,7 @@ class TestInheritance(MongoDBTestCase): assert Pike._subclasses == ("Animal.Fish.Pike",) def test_inheritance_meta_data(self): - """Ensure that document may inherit fields from a superclass document. - """ + """Ensure that document may inherit fields from a superclass document.""" class Person(Document): name = StringField() @@ -234,8 +232,7 @@ class TestInheritance(MongoDBTestCase): assert Employee._get_collection_name() == Person._get_collection_name() def test_inheritance_to_mongo_keys(self): - """Ensure that document may inherit fields from a superclass document. - """ + """Ensure that document may inherit fields from a superclass document.""" class Person(Document): name = StringField() @@ -259,7 +256,7 @@ class TestInheritance(MongoDBTestCase): assert Employee._get_collection_name() == Person._get_collection_name() def test_indexes_and_multiple_inheritance(self): - """ Ensure that all of the indexes are created for a document with + """Ensure that all of the indexes are created for a document with multiple inheritance. """ @@ -289,8 +286,7 @@ class TestInheritance(MongoDBTestCase): ) def test_polymorphic_queries(self): - """Ensure that the correct subclasses are returned from a query - """ + """Ensure that the correct subclasses are returned from a query""" class Animal(Document): meta = {"allow_inheritance": True} @@ -347,8 +343,7 @@ class TestInheritance(MongoDBTestCase): assert "_cls" not in obj def test_cant_turn_off_inheritance_on_subclass(self): - """Ensure if inheritance is on in a subclass you cant turn it off. - """ + """Ensure if inheritance is on in a subclass you cant turn it off.""" class Animal(Document): name = StringField() @@ -498,8 +493,7 @@ class TestInheritance(MongoDBTestCase): assert "_cls" in doc.to_mongo() def test_document_inheritance(self): - """Ensure mutliple inheritance of abstract documents - """ + """Ensure mutliple inheritance of abstract documents""" class DateCreatedDocument(Document): meta = {"allow_inheritance": True, "abstract": True} diff --git a/tests/document/test_instance.py b/tests/document/test_instance.py index 42df3c48..a28cd472 100644 --- a/tests/document/test_instance.py +++ b/tests/document/test_instance.py @@ -160,8 +160,7 @@ class TestDocumentInstance(MongoDBTestCase): Log.objects def test_repr(self): - """Ensure that unicode representation works - """ + """Ensure that unicode representation works""" class Article(Document): title = StringField() @@ -1553,8 +1552,7 @@ class TestDocumentInstance(MongoDBTestCase): assert site.page.log_message == "Error: Dummy message" def test_update_list_field(self): - """Test update on `ListField` with $pull + $in. - """ + """Test update on `ListField` with $pull + $in.""" class Doc(Document): foo = ListField(StringField()) @@ -2816,15 +2814,13 @@ class TestDocumentInstance(MongoDBTestCase): register_connection("testdb-2", "mongoenginetest2") class A(Document): - """Uses default db_alias - """ + """Uses default db_alias""" name = StringField() meta = {"allow_inheritance": True} class B(A): - """Uses testdb-2 db_alias - """ + """Uses testdb-2 db_alias""" meta = {"db_alias": "testdb-2"} @@ -3612,8 +3608,7 @@ class TestDocumentInstance(MongoDBTestCase): assert u_from_db.height is None def test_not_saved_eq(self): - """Ensure we can compare documents not saved. - """ + """Ensure we can compare documents not saved.""" class Person(Document): pass diff --git a/tests/document/test_validation.py b/tests/document/test_validation.py index c4228a96..104eb693 100644 --- a/tests/document/test_validation.py +++ b/tests/document/test_validation.py @@ -9,8 +9,7 @@ from tests.utils import MongoDBTestCase class TestValidatorError(MongoDBTestCase): def test_to_dict(self): - """Ensure a ValidationError handles error to_dict correctly. - """ + """Ensure a ValidationError handles error to_dict correctly.""" error = ValidationError("root") assert error.to_dict() == {} @@ -90,8 +89,7 @@ class TestValidatorError(MongoDBTestCase): p.validate() def test_embedded_document_validation(self): - """Ensure that embedded documents may be validated. - """ + """Ensure that embedded documents may be validated.""" class Comment(EmbeddedDocument): date = DateTimeField() diff --git a/tests/fields/test_binary_field.py b/tests/fields/test_binary_field.py index 4f7af325..0f92d53b 100644 --- a/tests/fields/test_binary_field.py +++ b/tests/fields/test_binary_field.py @@ -13,8 +13,7 @@ BIN_VALUE = "\xa9\xf3\x8d(\xd7\x03\x84\xb4k[\x0f\xe3\xa2\x19\x85p[J\xa3\xd2>\xde class TestBinaryField(MongoDBTestCase): def test_binary_fields(self): - """Ensure that binary fields can be stored and retrieved. - """ + """Ensure that binary fields can be stored and retrieved.""" class Attachment(Document): content_type = StringField() @@ -33,8 +32,7 @@ class TestBinaryField(MongoDBTestCase): assert BLOB == bytes(attachment_1.blob) def test_validation_succeeds(self): - """Ensure that valid values can be assigned to binary fields. - """ + """Ensure that valid values can be assigned to binary fields.""" class AttachmentRequired(Document): blob = BinaryField(required=True) diff --git a/tests/fields/test_decimal_field.py b/tests/fields/test_decimal_field.py index a7cd09a2..519356e9 100644 --- a/tests/fields/test_decimal_field.py +++ b/tests/fields/test_decimal_field.py @@ -8,8 +8,7 @@ from tests.utils import MongoDBTestCase class TestDecimalField(MongoDBTestCase): def test_validation(self): - """Ensure that invalid values cannot be assigned to decimal fields. - """ + """Ensure that invalid values cannot be assigned to decimal fields.""" class Person(Document): height = DecimalField(min_value=Decimal("0.1"), max_value=Decimal("3.5")) diff --git a/tests/fields/test_fields.py b/tests/fields/test_fields.py index 344656c1..ff1fde98 100644 --- a/tests/fields/test_fields.py +++ b/tests/fields/test_fields.py @@ -544,8 +544,7 @@ class TestField(MongoDBTestCase): post.validate() def test_sorted_list_sorting(self): - """Ensure that a sorted list field properly sorts values. - """ + """Ensure that a sorted list field properly sorts values.""" class Comment(EmbeddedDocument): order = IntField() @@ -661,8 +660,7 @@ class TestField(MongoDBTestCase): ) def test_list_field_manipulative_operators(self): - """Ensure that ListField works with standard list operators that manipulate the list. - """ + """Ensure that ListField works with standard list operators that manipulate the list.""" class BlogPost(Document): ref = StringField() @@ -1372,8 +1370,7 @@ class TestField(MongoDBTestCase): assert bar.generic_ref == {"_ref": expected, "_cls": "Foo"} def test_list_item_dereference(self): - """Ensure that DBRef items in ListFields are dereferenced. - """ + """Ensure that DBRef items in ListFields are dereferenced.""" class User(Document): name = StringField() @@ -1398,8 +1395,7 @@ class TestField(MongoDBTestCase): assert group_obj.members[1].name == user2.name def test_recursive_reference(self): - """Ensure that ReferenceFields can reference their own documents. - """ + """Ensure that ReferenceFields can reference their own documents.""" class Employee(Document): name = StringField() @@ -1426,8 +1422,7 @@ class TestField(MongoDBTestCase): assert peter.friends == friends def test_recursive_embedding(self): - """Ensure that EmbeddedDocumentFields can contain their own documents. - """ + """Ensure that EmbeddedDocumentFields can contain their own documents.""" class TreeNode(EmbeddedDocument): name = StringField() @@ -1503,8 +1498,7 @@ class TestField(MongoDBTestCase): AbstractDoc.drop_collection() def test_reference_class_with_abstract_parent(self): - """Ensure that a class with an abstract parent can be referenced. - """ + """Ensure that a class with an abstract parent can be referenced.""" class Sibling(Document): name = StringField() @@ -1574,8 +1568,7 @@ class TestField(MongoDBTestCase): brother.save() def test_generic_reference(self): - """Ensure that a GenericReferenceField properly dereferences items. - """ + """Ensure that a GenericReferenceField properly dereferences items.""" class Link(Document): title = StringField() @@ -1614,8 +1607,7 @@ class TestField(MongoDBTestCase): assert isinstance(bm.bookmark_object, Link) def test_generic_reference_list(self): - """Ensure that a ListField properly dereferences generic references. - """ + """Ensure that a ListField properly dereferences generic references.""" class Link(Document): title = StringField() @@ -1718,8 +1710,7 @@ class TestField(MongoDBTestCase): assert bm.bookmark_object == post_1 def test_generic_reference_string_choices(self): - """Ensure that a GenericReferenceField can handle choices as strings - """ + """Ensure that a GenericReferenceField can handle choices as strings""" class Link(Document): title = StringField() @@ -1811,8 +1802,7 @@ class TestField(MongoDBTestCase): assert user.bookmarks == [post_1] def test_generic_reference_list_item_modification(self): - """Ensure that modifications of related documents (through generic reference) don't influence on querying - """ + """Ensure that modifications of related documents (through generic reference) don't influence on querying""" class Post(Document): title = StringField() @@ -1900,8 +1890,7 @@ class TestField(MongoDBTestCase): assert doc == doc2 def test_choices_allow_using_sets_as_choices(self): - """Ensure that sets can be used when setting choices - """ + """Ensure that sets can be used when setting choices""" class Shirt(Document): size = StringField(choices={"M", "L"}) @@ -1920,8 +1909,7 @@ class TestField(MongoDBTestCase): shirt.validate() def test_choices_validation_accept_possible_value(self): - """Ensure that value is in a container of allowed values. - """ + """Ensure that value is in a container of allowed values.""" class Shirt(Document): size = StringField(choices=("S", "M")) @@ -1930,8 +1918,7 @@ class TestField(MongoDBTestCase): shirt.validate() def test_choices_validation_reject_unknown_value(self): - """Ensure that unallowed value are rejected upon validation - """ + """Ensure that unallowed value are rejected upon validation""" class Shirt(Document): size = StringField(choices=("S", "M")) @@ -1989,8 +1976,7 @@ class TestField(MongoDBTestCase): shirt1.validate() def test_simple_choices_validation(self): - """Ensure that value is in a container of allowed values. - """ + """Ensure that value is in a container of allowed values.""" class Shirt(Document): size = StringField(max_length=3, choices=("S", "M", "L", "XL", "XXL")) @@ -2039,8 +2025,7 @@ class TestField(MongoDBTestCase): shirt.validate() def test_simple_choices_validation_invalid_value(self): - """Ensure that error messages are correct. - """ + """Ensure that error messages are correct.""" SIZES = ("S", "M", "L", "XL", "XXL") COLORS = (("R", "Red"), ("B", "Blue")) SIZE_MESSAGE = u"Value must be one of ('S', 'M', 'L', 'XL', 'XXL')" diff --git a/tests/fields/test_file_field.py b/tests/fields/test_file_field.py index 4f3f1d45..dc9354f0 100644 --- a/tests/fields/test_file_field.py +++ b/tests/fields/test_file_field.py @@ -48,8 +48,7 @@ class TestFileField(MongoDBTestCase): DemoFile.objects.create() def test_file_fields(self): - """Ensure that file fields can be written to and their data retrieved - """ + """Ensure that file fields can be written to and their data retrieved""" class PutFile(Document): the_file = FileField() @@ -91,8 +90,7 @@ class TestFileField(MongoDBTestCase): result.the_file.delete() def test_file_fields_stream(self): - """Ensure that file fields can be written to and their data retrieved - """ + """Ensure that file fields can be written to and their data retrieved""" class StreamFile(Document): the_file = FileField() @@ -228,8 +226,7 @@ class TestFileField(MongoDBTestCase): assert ["doc_b", "doc_e"] == grid_fs.list() def test_file_uniqueness(self): - """Ensure that each instance of a FileField is unique - """ + """Ensure that each instance of a FileField is unique""" class TestFile(Document): name = StringField() @@ -285,8 +282,7 @@ class TestFileField(MongoDBTestCase): assert test_file.the_file.get().length == 4971 def test_file_boolean(self): - """Ensure that a boolean test of a FileField indicates its presence - """ + """Ensure that a boolean test of a FileField indicates its presence""" class TestFile(Document): the_file = FileField() diff --git a/tests/fields/test_float_field.py b/tests/fields/test_float_field.py index 817dcfeb..913f009d 100644 --- a/tests/fields/test_float_field.py +++ b/tests/fields/test_float_field.py @@ -19,8 +19,7 @@ class TestFloatField(MongoDBTestCase): assert 1 == TestDocument.objects(float_fld__ne=1).count() def test_validation(self): - """Ensure that invalid values cannot be assigned to float fields. - """ + """Ensure that invalid values cannot be assigned to float fields.""" class Person(Document): height = FloatField(min_value=0.1, max_value=3.5) diff --git a/tests/fields/test_geo_fields.py b/tests/fields/test_geo_fields.py index 7960178e..a611be85 100644 --- a/tests/fields/test_geo_fields.py +++ b/tests/fields/test_geo_fields.py @@ -290,8 +290,7 @@ class TestGeoField(MongoDBTestCase): Location(loc=[[[[1, 2], [3, 4], [5, 6], [1, 2]]]]).validate() def test_indexes_geopoint(self): - """Ensure that indexes are created automatically for GeoPointFields. - """ + """Ensure that indexes are created automatically for GeoPointFields.""" class Event(Document): title = StringField() @@ -317,8 +316,7 @@ class TestGeoField(MongoDBTestCase): assert geo_indicies == [{"fields": [("venue.location", "2d")]}] def test_indexes_2dsphere(self): - """Ensure that indexes are created automatically for GeoPointFields. - """ + """Ensure that indexes are created automatically for GeoPointFields.""" class Event(Document): title = StringField() @@ -332,8 +330,7 @@ class TestGeoField(MongoDBTestCase): assert {"fields": [("point", "2dsphere")]} in geo_indicies def test_indexes_2dsphere_embedded(self): - """Ensure that indexes are created automatically for GeoPointFields. - """ + """Ensure that indexes are created automatically for GeoPointFields.""" class Venue(EmbeddedDocument): name = StringField() diff --git a/tests/fields/test_int_field.py b/tests/fields/test_int_field.py index 529ae4db..1f50b832 100644 --- a/tests/fields/test_int_field.py +++ b/tests/fields/test_int_field.py @@ -7,8 +7,7 @@ from tests.utils import MongoDBTestCase class TestIntField(MongoDBTestCase): def test_int_validation(self): - """Ensure that invalid values cannot be assigned to int fields. - """ + """Ensure that invalid values cannot be assigned to int fields.""" class Person(Document): age = IntField(min_value=0, max_value=110) diff --git a/tests/fields/test_long_field.py b/tests/fields/test_long_field.py index 330051c3..67fd0bce 100644 --- a/tests/fields/test_long_field.py +++ b/tests/fields/test_long_field.py @@ -25,8 +25,7 @@ class TestLongField(MongoDBTestCase): assert isinstance(doc.some_long, int) def test_long_validation(self): - """Ensure that invalid values cannot be assigned to long fields. - """ + """Ensure that invalid values cannot be assigned to long fields.""" class TestDocument(Document): value = LongField(min_value=0, max_value=110) diff --git a/tests/fields/test_reference_field.py b/tests/fields/test_reference_field.py index 24401ce0..e2c92034 100644 --- a/tests/fields/test_reference_field.py +++ b/tests/fields/test_reference_field.py @@ -107,8 +107,7 @@ class TestReferenceField(MongoDBTestCase): assert p.parent == p1 def test_undefined_reference(self): - """Ensure that ReferenceFields may reference undefined Documents. - """ + """Ensure that ReferenceFields may reference undefined Documents.""" class Product(Document): name = StringField() diff --git a/tests/fields/test_url_field.py b/tests/fields/test_url_field.py index 50845b90..eb639bfe 100644 --- a/tests/fields/test_url_field.py +++ b/tests/fields/test_url_field.py @@ -38,8 +38,7 @@ class TestURLField(MongoDBTestCase): ) def test_url_scheme_validation(self): - """Ensure that URLFields validate urls with specific schemes properly. - """ + """Ensure that URLFields validate urls with specific schemes properly.""" class Link(Document): url = URLField() diff --git a/tests/fields/test_uuid_field.py b/tests/fields/test_uuid_field.py index 0f3d2d84..ec81033b 100644 --- a/tests/fields/test_uuid_field.py +++ b/tests/fields/test_uuid_field.py @@ -17,8 +17,7 @@ class TestUUIDField(MongoDBTestCase): assert get_as_pymongo(person) == {"_id": person.id, "api_key": str(uid)} def test_field_string(self): - """Test UUID fields storing as String - """ + """Test UUID fields storing as String""" Person.drop_collection() uu = uuid.uuid4() diff --git a/tests/queryset/test_field_list.py b/tests/queryset/test_field_list.py index be7903fd..96bd804d 100644 --- a/tests/queryset/test_field_list.py +++ b/tests/queryset/test_field_list.py @@ -148,8 +148,7 @@ class TestOnlyExcludeAll(unittest.TestCase): assert qs._loaded_fields.as_dict() == {"c": {"$slice": 2}, "a": 1} def test_only(self): - """Ensure that QuerySet.only only returns the requested fields. - """ + """Ensure that QuerySet.only only returns the requested fields.""" person = self.Person(name="test", age=25) person.save() @@ -365,8 +364,7 @@ class TestOnlyExcludeAll(unittest.TestCase): Email.drop_collection() def test_slicing_fields(self): - """Ensure that query slicing an array works. - """ + """Ensure that query slicing an array works.""" class Numbers(Document): n = ListField(IntField()) @@ -401,8 +399,7 @@ class TestOnlyExcludeAll(unittest.TestCase): assert numbers.n == [-5, -4, -3, -2, -1] def test_slicing_nested_fields(self): - """Ensure that query slicing an embedded array works. - """ + """Ensure that query slicing an embedded array works.""" class EmbeddedNumber(EmbeddedDocument): n = ListField(IntField()) diff --git a/tests/queryset/test_queryset.py b/tests/queryset/test_queryset.py index a2440302..3f1b85d7 100644 --- a/tests/queryset/test_queryset.py +++ b/tests/queryset/test_queryset.py @@ -60,8 +60,7 @@ class TestQueryset(unittest.TestCase): self.mongodb_version = get_mongodb_version() def test_initialisation(self): - """Ensure that a QuerySet is correctly initialised by QuerySetManager. - """ + """Ensure that a QuerySet is correctly initialised by QuerySetManager.""" assert isinstance(self.Person.objects, QuerySet) assert ( self.Person.objects._collection.name == self.Person._get_collection_name() @@ -271,8 +270,7 @@ class TestQueryset(unittest.TestCase): ) def test_find_one(self): - """Ensure that a query using find_one returns a valid result. - """ + """Ensure that a query using find_one returns a valid result.""" person1 = self.Person(name="User A", age=20) person1.save() person2 = self.Person(name="User B", age=30) @@ -317,8 +315,7 @@ class TestQueryset(unittest.TestCase): self.Person.objects.get() def test_get_multiple_match_raises_multipleobjectsreturned(self): - """Ensure that a query using ``get`` returns at most one result. - """ + """Ensure that a query using ``get`` returns at most one result.""" assert self.Person.objects().count() == 0 person1 = self.Person(name="User A", age=20) @@ -351,8 +348,7 @@ class TestQueryset(unittest.TestCase): assert person == person3 def test_find_array_position(self): - """Ensure that query by array position works. - """ + """Ensure that query by array position works.""" class Comment(EmbeddedDocument): name = StringField() @@ -1141,8 +1137,7 @@ class TestQueryset(unittest.TestCase): assert q == 2 def test_repeated_iteration(self): - """Ensure that QuerySet rewinds itself one iteration finishes. - """ + """Ensure that QuerySet rewinds itself one iteration finishes.""" self.Person(name="Person 1").save() self.Person(name="Person 2").save() @@ -1191,8 +1186,7 @@ class TestQueryset(unittest.TestCase): assert ".. queryset mid-iteration .." == repr(docs) def test_regex_query_shortcuts(self): - """Ensure that contains, startswith, endswith, etc work. - """ + """Ensure that contains, startswith, endswith, etc work.""" person = self.Person(name="Guido van Rossum") person.save() @@ -1248,8 +1242,7 @@ class TestQueryset(unittest.TestCase): assert obj == person def test_not(self): - """Ensure that the __not operator works as expected. - """ + """Ensure that the __not operator works as expected.""" alice = self.Person(name="Alice", age=25) alice.save() @@ -1260,8 +1253,7 @@ class TestQueryset(unittest.TestCase): assert obj is None def test_filter_chaining(self): - """Ensure filters can be chained together. - """ + """Ensure filters can be chained together.""" class Blog(Document): id = StringField(primary_key=True) @@ -1337,8 +1329,7 @@ class TestQueryset(unittest.TestCase): assert qs[i] == expected[i] def test_ordering(self): - """Ensure default ordering is applied and can be overridden. - """ + """Ensure default ordering is applied and can be overridden.""" class BlogPost(Document): title = StringField() @@ -1408,8 +1399,7 @@ class TestQueryset(unittest.TestCase): assert ORDER_BY_KEY not in q.get_ops()[0][CMD_QUERY_KEY] def test_no_ordering_for_get(self): - """ Ensure that Doc.objects.get doesn't use any ordering. - """ + """Ensure that Doc.objects.get doesn't use any ordering.""" ORDER_BY_KEY, CMD_QUERY_KEY = get_key_compat(self.mongodb_version) class BlogPost(Document): @@ -1485,8 +1475,7 @@ class TestQueryset(unittest.TestCase): assert result.author is None def test_find_dict_item(self): - """Ensure that DictField items may be found. - """ + """Ensure that DictField items may be found.""" class BlogPost(Document): info = DictField() @@ -1502,8 +1491,7 @@ class TestQueryset(unittest.TestCase): BlogPost.drop_collection() def test_exec_js_query(self): - """Ensure that queries are properly formed for use in exec_js. - """ + """Ensure that queries are properly formed for use in exec_js.""" class BlogPost(Document): hits = IntField() @@ -1540,8 +1528,7 @@ class TestQueryset(unittest.TestCase): BlogPost.drop_collection() def test_exec_js_field_sub(self): - """Ensure that field substitutions occur properly in exec_js functions. - """ + """Ensure that field substitutions occur properly in exec_js functions.""" class Comment(EmbeddedDocument): content = StringField(db_field="body") @@ -1597,8 +1584,7 @@ class TestQueryset(unittest.TestCase): BlogPost.drop_collection() def test_delete(self): - """Ensure that documents are properly deleted from the database. - """ + """Ensure that documents are properly deleted from the database.""" self.Person(name="User A", age=20).save() self.Person(name="User B", age=30).save() self.Person(name="User C", age=40).save() @@ -1612,8 +1598,7 @@ class TestQueryset(unittest.TestCase): assert self.Person.objects.count() == 0 def test_reverse_delete_rule_cascade(self): - """Ensure cascading deletion of referring documents from the database. - """ + """Ensure cascading deletion of referring documents from the database.""" class BlogPost(Document): content = StringField() @@ -1745,8 +1730,7 @@ class TestQueryset(unittest.TestCase): assert 0 == Category.objects.count() def test_reverse_delete_rule_nullify(self): - """Ensure nullification of references to deleted documents. - """ + """Ensure nullification of references to deleted documents.""" class Category(Document): name = StringField() @@ -1842,8 +1826,7 @@ class TestQueryset(unittest.TestCase): self.Person.objects.delete() def test_reverse_delete_rule_pull(self): - """Ensure pulling of references to deleted documents. - """ + """Ensure pulling of references to deleted documents.""" class BlogPost(Document): content = StringField() @@ -1918,8 +1901,7 @@ class TestQueryset(unittest.TestCase): assert 8 == Log.objects.count() def test_delete_with_limit_handles_delete_rules(self): - """Ensure cascading deletion of referring documents from the database. - """ + """Ensure cascading deletion of referring documents from the database.""" class BlogPost(Document): content = StringField() @@ -1951,8 +1933,7 @@ class TestQueryset(unittest.TestCase): assert del_result is None def test_reference_field_find(self): - """Ensure cascading deletion of referring documents from the database. - """ + """Ensure cascading deletion of referring documents from the database.""" class BlogPost(Document): content = StringField() @@ -1973,8 +1954,7 @@ class TestQueryset(unittest.TestCase): assert 1 == BlogPost.objects(author__in=["%s" % me.pk]).count() def test_reference_field_find_dbref(self): - """Ensure cascading deletion of referring documents from the database. - """ + """Ensure cascading deletion of referring documents from the database.""" class BlogPost(Document): content = StringField() @@ -2058,8 +2038,7 @@ class TestQueryset(unittest.TestCase): BlogPost.objects.update_one(inc__review=0.1) # test with floats def test_update_listfield_operator(self): - """Ensure that atomic updates work properly. - """ + """Ensure that atomic updates work properly.""" class BlogPost(Document): tags = ListField(StringField()) @@ -2107,8 +2086,7 @@ class TestQueryset(unittest.TestCase): assert "title" not in pymongo_doc def test_update_push_with_position(self): - """Ensure that the 'push' update with position works properly. - """ + """Ensure that the 'push' update with position works properly.""" class BlogPost(Document): slug = StringField() @@ -2133,8 +2111,7 @@ class TestQueryset(unittest.TestCase): assert 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 - """ + """Ensure that the 'push' update operation works in the list of list""" class BlogPost(Document): slug = StringField() @@ -2149,8 +2126,7 @@ class TestQueryset(unittest.TestCase): assert post.tags == [["value1", 123]] def test_update_push_and_pull_add_to_set(self): - """Ensure that the 'pull' update operation works correctly. - """ + """Ensure that the 'pull' update operation works correctly.""" class BlogPost(Document): slug = StringField() @@ -2259,8 +2235,7 @@ class TestQueryset(unittest.TestCase): ) def test_pull_from_nested_embedded_using_in_nin(self): - """Ensure that the 'pull' update operation works on embedded documents using 'in' and 'nin' operators. - """ + """Ensure that the 'pull' update operation works on embedded documents using 'in' and 'nin' operators.""" class User(EmbeddedDocument): name = StringField() @@ -2491,8 +2466,7 @@ class TestQueryset(unittest.TestCase): assert doc.pk == doc.embedded[0]._instance.pk def test_order_by(self): - """Ensure that QuerySets may be ordered. - """ + """Ensure that QuerySets may be ordered.""" self.Person(name="User B", age=40).save() self.Person(name="User A", age=20).save() self.Person(name="User C", age=30).save() @@ -2560,8 +2534,7 @@ class TestQueryset(unittest.TestCase): self.assertSequence(qs, expected) def test_order_by_chaining(self): - """Ensure that an order_by query chains properly and allows .only() - """ + """Ensure that an order_by query chains properly and allows .only()""" self.Person(name="User B", age=40).save() self.Person(name="User A", age=20).save() self.Person(name="User C", age=30).save() @@ -2635,8 +2608,7 @@ class TestQueryset(unittest.TestCase): assert op[CMD_QUERY_KEY][COMMENT_KEY] == "looking for an adult" def test_map_reduce(self): - """Ensure map/reduce is both mapping and reducing. - """ + """Ensure map/reduce is both mapping and reducing.""" class BlogPost(Document): title = StringField() @@ -2988,8 +2960,7 @@ class TestQueryset(unittest.TestCase): Link.drop_collection() def test_item_frequencies(self): - """Ensure that item frequencies are properly generated from lists. - """ + """Ensure that item frequencies are properly generated from lists.""" class BlogPost(Document): hits = IntField() @@ -3057,8 +3028,7 @@ class TestQueryset(unittest.TestCase): BlogPost.drop_collection() def test_item_frequencies_on_embedded(self): - """Ensure that item frequencies are properly generated from lists. - """ + """Ensure that item frequencies are properly generated from lists.""" class Phone(EmbeddedDocument): number = StringField() @@ -3214,8 +3184,7 @@ class TestQueryset(unittest.TestCase): assert freqs == {1: 50.0 / 70, 2: 20.0 / 70} def test_average(self): - """Ensure that field can be averaged correctly. - """ + """Ensure that field can be averaged correctly.""" self.Person(name="person", age=0).save() assert int(self.Person.objects.average("age")) == 0 @@ -3255,8 +3224,7 @@ class TestQueryset(unittest.TestCase): assert self.Person.objects.filter(age__gte=50).average("age") == avg def test_sum(self): - """Ensure that field can be summed over correctly. - """ + """Ensure that field can be summed over correctly.""" ages = [23, 54, 12, 94, 27] for i, age in enumerate(ages): self.Person(name="test%s" % i, age=age).save() @@ -3406,8 +3374,7 @@ class TestQueryset(unittest.TestCase): assert Doc.objects.sum("values") == 1360 def test_distinct(self): - """Ensure that the QuerySet.distinct method works. - """ + """Ensure that the QuerySet.distinct method works.""" self.Person(name="Mr Orange", age=20).save() self.Person(name="Mr White", age=20).save() self.Person(name="Mr Orange", age=30).save() @@ -3547,8 +3514,7 @@ class TestQueryset(unittest.TestCase): assert Foo.objects.distinct("bar") == [bar] def test_distinct_handles_db_field(self): - """Ensure that distinct resolves field name to db_field as expected. - """ + """Ensure that distinct resolves field name to db_field as expected.""" class Product(Document): product_id = IntField(db_field="pid") @@ -3644,8 +3610,7 @@ class TestQueryset(unittest.TestCase): assert Foo.objects.distinct("bar_lst") == [bar_1, bar_2] def test_custom_manager(self): - """Ensure that custom QuerySetManager instances work as expected. - """ + """Ensure that custom QuerySetManager instances work as expected.""" class BlogPost(Document): tags = ListField(StringField()) @@ -3746,8 +3711,7 @@ class TestQueryset(unittest.TestCase): assert 1 == Bar.objects.count() def test_query_value_conversion(self): - """Ensure that query values are properly converted when necessary. - """ + """Ensure that query values are properly converted when necessary.""" class BlogPost(Document): author = ReferenceField(self.Person) @@ -3773,8 +3737,7 @@ class TestQueryset(unittest.TestCase): BlogPost.drop_collection() def test_update_value_conversion(self): - """Ensure that values used in updates are converted before use. - """ + """Ensure that values used in updates are converted before use.""" class Group(Document): members = ListField(ReferenceField(self.Person)) @@ -3799,8 +3762,7 @@ class TestQueryset(unittest.TestCase): Group.drop_collection() def test_bulk(self): - """Ensure bulk querying by object id returns a proper dict. - """ + """Ensure bulk querying by object id returns a proper dict.""" class BlogPost(Document): title = StringField() @@ -3838,8 +3800,7 @@ class TestQueryset(unittest.TestCase): self.Person.drop_collection() def test_custom_querysets(self): - """Ensure that custom QuerySet classes may be used. - """ + """Ensure that custom QuerySet classes may be used.""" class CustomQuerySet(QuerySet): def not_empty(self): @@ -3859,8 +3820,7 @@ class TestQueryset(unittest.TestCase): Post.drop_collection() def test_custom_querysets_set_manager_directly(self): - """Ensure that custom QuerySet classes may be used. - """ + """Ensure that custom QuerySet classes may be used.""" class CustomQuerySet(QuerySet): def not_empty(self): @@ -3883,8 +3843,7 @@ class TestQueryset(unittest.TestCase): Post.drop_collection() def test_custom_querysets_managers_directly(self): - """Ensure that custom QuerySet classes may be used. - """ + """Ensure that custom QuerySet classes may be used.""" class CustomQuerySetManager(QuerySetManager): @staticmethod @@ -3905,8 +3864,7 @@ class TestQueryset(unittest.TestCase): Post.drop_collection() def test_custom_querysets_inherited(self): - """Ensure that custom QuerySet classes may be used. - """ + """Ensure that custom QuerySet classes may be used.""" class CustomQuerySet(QuerySet): def not_empty(self): @@ -3928,8 +3886,7 @@ class TestQueryset(unittest.TestCase): Post.drop_collection() def test_custom_querysets_inherited_direct(self): - """Ensure that custom QuerySet classes may be used. - """ + """Ensure that custom QuerySet classes may be used.""" class CustomQuerySet(QuerySet): def not_empty(self): @@ -3990,8 +3947,7 @@ class TestQueryset(unittest.TestCase): assert A.objects(b=[{"c": "c"}]).count() == 0 def test_call_after_limits_set(self): - """Ensure that re-filtering after slicing works - """ + """Ensure that re-filtering after slicing works""" class Post(Document): title = StringField() @@ -4007,8 +3963,7 @@ class TestQueryset(unittest.TestCase): Post.drop_collection() def test_order_then_filter(self): - """Ensure that ordering still works after filtering. - """ + """Ensure that ordering still works after filtering.""" class Number(Document): n = IntField() @@ -4025,8 +3980,7 @@ class TestQueryset(unittest.TestCase): Number.drop_collection() def test_clone(self): - """Ensure that cloning clones complex querysets - """ + """Ensure that cloning clones complex querysets""" class Number(Document): n = IntField() @@ -4055,8 +4009,7 @@ class TestQueryset(unittest.TestCase): Number.drop_collection() def test_clone_retains_settings(self): - """Ensure that cloning retains the read_preference and read_concern - """ + """Ensure that cloning retains the read_preference and read_concern""" class Number(Document): n = IntField() @@ -4081,8 +4034,7 @@ class TestQueryset(unittest.TestCase): Number.drop_collection() def test_using(self): - """Ensure that switching databases for a queryset is possible - """ + """Ensure that switching databases for a queryset is possible""" class Number2(Document): n = IntField() @@ -4134,8 +4086,7 @@ class TestQueryset(unittest.TestCase): Number.drop_collection() def test_order_works_with_primary(self): - """Ensure that order_by and primary work. - """ + """Ensure that order_by and primary work.""" class Number(Document): n = IntField(primary_key=True) @@ -4154,8 +4105,7 @@ class TestQueryset(unittest.TestCase): Number.drop_collection() def test_ensure_index(self): - """Ensure that manual creation of indexes works. - """ + """Ensure that manual creation of indexes works.""" class Comment(Document): message = StringField() @@ -4171,8 +4121,7 @@ class TestQueryset(unittest.TestCase): assert ([("_cls", 1), ("message", 1)], False, False) in info def test_where(self): - """Ensure that where clauses work. - """ + """Ensure that where clauses work.""" class IntPair(Document): fielda = IntField() @@ -4451,8 +4400,7 @@ class TestQueryset(unittest.TestCase): assert list(val) == [("test", "test value")] def test_scalar_cursor_behaviour(self): - """Ensure that a query returns a valid set of results. - """ + """Ensure that a query returns a valid set of results.""" person1 = self.Person(name="User A", age=20) person1.save() person2 = self.Person(name="User B", age=30) @@ -4669,8 +4617,7 @@ class TestQueryset(unittest.TestCase): assert [b3] == ak def test_upsert_includes_cls(self): - """Upserts should include _cls information for inheritable classes - """ + """Upserts should include _cls information for inheritable classes""" class Test(Document): test = StringField() @@ -5366,8 +5313,7 @@ class TestQueryset(unittest.TestCase): assert obj.__class__ == C def test_query_generic_embedded_document(self): - """Ensure that querying sub field on generic_embedded_field works - """ + """Ensure that querying sub field on generic_embedded_field works""" class A(EmbeddedDocument): a_name = StringField() diff --git a/tests/queryset/test_transform.py b/tests/queryset/test_transform.py index f5d248af..872a9a5d 100644 --- a/tests/queryset/test_transform.py +++ b/tests/queryset/test_transform.py @@ -12,8 +12,7 @@ class TestTransform(unittest.TestCase): connect(db="mongoenginetest") def test_transform_query(self): - """Ensure that the _transform_query function operates correctly. - """ + """Ensure that the _transform_query function operates correctly.""" assert transform.query(name="test", age=30) == {"name": "test", "age": 30} assert transform.query(age__lt=30) == {"age": {"$lt": 30}} assert transform.query(age__gt=20, age__lt=50) == { @@ -88,8 +87,7 @@ class TestTransform(unittest.TestCase): assert update == {"$set": {"tags": ["mongo", "db"]}} def test_query_field_name(self): - """Ensure that the correct field name is used when querying. - """ + """Ensure that the correct field name is used when querying.""" class Comment(EmbeddedDocument): content = StringField(db_field="commentContent") diff --git a/tests/queryset/test_visitor.py b/tests/queryset/test_visitor.py index 81e0f253..5fb94901 100644 --- a/tests/queryset/test_visitor.py +++ b/tests/queryset/test_visitor.py @@ -23,8 +23,7 @@ class TestQ(unittest.TestCase): self.Person = Person def test_empty_q(self): - """Ensure that empty Q objects won't hurt. - """ + """Ensure that empty Q objects won't hurt.""" q1 = Q() q2 = Q(age__gte=18) q3 = Q() @@ -58,8 +57,7 @@ class TestQ(unittest.TestCase): assert Post.objects.filter(Q(created_user=user)).count() == 1 def test_and_combination(self): - """Ensure that Q-objects correctly AND together. - """ + """Ensure that Q-objects correctly AND together.""" class TestDoc(Document): x = IntField() @@ -89,8 +87,7 @@ class TestQ(unittest.TestCase): assert query.to_query(TestDoc) == mongo_query def test_or_combination(self): - """Ensure that Q-objects correctly OR together. - """ + """Ensure that Q-objects correctly OR together.""" class TestDoc(Document): x = IntField() @@ -101,8 +98,7 @@ class TestQ(unittest.TestCase): assert query == {"$or": [{"x": {"$lt": 3}}, {"x": {"$gt": 7}}]} def test_and_or_combination(self): - """Ensure that Q-objects handle ANDing ORed components. - """ + """Ensure that Q-objects handle ANDing ORed components.""" class TestDoc(Document): x = IntField() @@ -136,8 +132,7 @@ class TestQ(unittest.TestCase): assert 2 == TestDoc.objects(q1 & q2).count() def test_or_and_or_combination(self): - """Ensure that Q-objects handle ORing ANDed ORed components. :) - """ + """Ensure that Q-objects handle ORing ANDed ORed components. :)""" class TestDoc(Document): x = IntField() @@ -208,8 +203,7 @@ class TestQ(unittest.TestCase): assert test.count() == 3 def test_q(self): - """Ensure that Q objects may be used to query for documents. - """ + """Ensure that Q objects may be used to query for documents.""" class BlogPost(Document): title = StringField() @@ -286,8 +280,7 @@ class TestQ(unittest.TestCase): self.Person.objects.filter("user1") def test_q_regex(self): - """Ensure that Q objects can be queried using regexes. - """ + """Ensure that Q objects can be queried using regexes.""" person = self.Person(name="Guido van Rossum") person.save() @@ -320,8 +313,7 @@ class TestQ(unittest.TestCase): ) def test_q_lists(self): - """Ensure that Q objects query ListFields correctly. - """ + """Ensure that Q objects query ListFields correctly.""" class BlogPost(Document): tags = ListField(StringField()) diff --git a/tests/test_connection.py b/tests/test_connection.py index b57d4597..ab88ce0c 100644 --- a/tests/test_connection.py +++ b/tests/test_connection.py @@ -194,14 +194,12 @@ class ConnectionTest(unittest.TestCase): assert len(mongoengine.connection._connections) == 3 def test_connect_with_invalid_db_name(self): - """Ensure that connect() method fails fast if db name is invalid - """ + """Ensure that connect() method fails fast if db name is invalid""" with pytest.raises(InvalidName): connect("mongomock://localhost") def test_connect_with_db_name_external(self): - """Ensure that connect() works if db name is $external - """ + """Ensure that connect() works if db name is $external""" """Ensure that the connect() method works properly.""" connect("$external") @@ -217,16 +215,14 @@ class ConnectionTest(unittest.TestCase): assert isinstance(conn, pymongo.mongo_client.MongoClient) def test_connect_with_invalid_db_name_type(self): - """Ensure that connect() method fails fast if db name has invalid type - """ + """Ensure that connect() method fails fast if db name has invalid type""" with pytest.raises(TypeError): non_string_db_name = ["e. g. list instead of a string"] connect(non_string_db_name) @require_mongomock def test_connect_in_mocking(self): - """Ensure that the connect() method works properly in mocking. - """ + """Ensure that the connect() method works properly in mocking.""" connect("mongoenginetest", host="mongomock://localhost") conn = get_connection() assert isinstance(conn, mongomock.MongoClient) @@ -270,8 +266,7 @@ class ConnectionTest(unittest.TestCase): @require_mongomock def test_default_database_with_mocking(self): - """Ensure that the default database is correctly set when using mongomock. - """ + """Ensure that the default database is correctly set when using mongomock.""" disconnect_all() class SomeDocument(Document): @@ -452,8 +447,7 @@ class ConnectionTest(unittest.TestCase): disconnect_all() def test_sharing_connections(self): - """Ensure that connections are shared when the connection settings are exactly the same - """ + """Ensure that connections are shared when the connection settings are exactly the same""" connect("mongoenginetests", alias="testdb1") expected_connection = get_connection("testdb1") @@ -564,8 +558,7 @@ class ConnectionTest(unittest.TestCase): authd_conn.admin.system.users.delete_many({}) def test_register_connection(self): - """Ensure that connections with different aliases may be registered. - """ + """Ensure that connections with different aliases may be registered.""" register_connection("testdb", "mongoenginetest2") with pytest.raises(ConnectionFailure): @@ -578,8 +571,7 @@ class ConnectionTest(unittest.TestCase): assert db.name == "mongoenginetest2" def test_register_connection_defaults(self): - """Ensure that defaults are used when the host and port are None. - """ + """Ensure that defaults are used when the host and port are None.""" register_connection("testdb", "mongoenginetest", host=None, port=None) conn = get_connection("testdb") diff --git a/tests/test_context_managers.py b/tests/test_context_managers.py index a4864c40..6599c7f2 100644 --- a/tests/test_context_managers.py +++ b/tests/test_context_managers.py @@ -117,8 +117,7 @@ class TestContextManagers: assert 1 == Group.objects.count() def test_no_dereference_context_manager_object_id(self): - """Ensure that DBRef items in ListFields aren't dereferenced. - """ + """Ensure that DBRef items in ListFields aren't dereferenced.""" connect("mongoenginetest") class User(Document): @@ -155,8 +154,7 @@ class TestContextManagers: assert isinstance(group.generic, User) def test_no_dereference_context_manager_dbref(self): - """Ensure that DBRef items in ListFields aren't dereferenced. - """ + """Ensure that DBRef items in ListFields aren't dereferenced.""" connect("mongoenginetest") class User(Document): diff --git a/tests/test_dereference.py b/tests/test_dereference.py index c40cc0bd..88ea0033 100644 --- a/tests/test_dereference.py +++ b/tests/test_dereference.py @@ -16,8 +16,7 @@ class FieldTest(unittest.TestCase): cls.db.drop_database("mongoenginetest") def test_list_item_dereference(self): - """Ensure that DBRef items in ListFields are dereferenced. - """ + """Ensure that DBRef items in ListFields are dereferenced.""" class User(Document): name = StringField() @@ -75,8 +74,7 @@ class FieldTest(unittest.TestCase): Group.drop_collection() def test_list_item_dereference_dref_false(self): - """Ensure that DBRef items in ListFields are dereferenced. - """ + """Ensure that DBRef items in ListFields are dereferenced.""" class User(Document): name = StringField() @@ -132,8 +130,7 @@ class FieldTest(unittest.TestCase): assert q == 2 def test_list_item_dereference_orphan_dbref(self): - """Ensure that orphan DBRef items in ListFields are dereferenced. - """ + """Ensure that orphan DBRef items in ListFields are dereferenced.""" class User(Document): name = StringField() @@ -176,8 +173,7 @@ class FieldTest(unittest.TestCase): Group.drop_collection() def test_list_item_dereference_dref_false_stores_as_type(self): - """Ensure that DBRef items are stored as their type - """ + """Ensure that DBRef items are stored as their type""" class User(Document): my_id = IntField(primary_key=True) @@ -198,8 +194,7 @@ class FieldTest(unittest.TestCase): assert group.members == [user] def test_handle_old_style_references(self): - """Ensure that DBRef items in ListFields are dereferenced. - """ + """Ensure that DBRef items in ListFields are dereferenced.""" class User(Document): name = StringField() @@ -232,8 +227,7 @@ class FieldTest(unittest.TestCase): assert group.members[-1].name == "String!" def test_migrate_references(self): - """Example of migrating ReferenceField storage - """ + """Example of migrating ReferenceField storage""" # Create some sample data class User(Document): @@ -278,8 +272,7 @@ class FieldTest(unittest.TestCase): assert isinstance(raw_data["members"][0], ObjectId) def test_recursive_reference(self): - """Ensure that ReferenceFields can reference their own documents. - """ + """Ensure that ReferenceFields can reference their own documents.""" class Employee(Document): name = StringField() @@ -402,8 +395,7 @@ class FieldTest(unittest.TestCase): assert "[, ]" == "%s" % Person.objects() def test_circular_reference_on_self(self): - """Ensure you can handle circular references - """ + """Ensure you can handle circular references""" class Person(Document): name = StringField() @@ -430,8 +422,7 @@ class FieldTest(unittest.TestCase): assert "[, ]" == "%s" % Person.objects() def test_circular_tree_reference(self): - """Ensure you can handle circular references with more than one level - """ + """Ensure you can handle circular references with more than one level""" class Other(EmbeddedDocument): name = StringField() @@ -557,8 +548,7 @@ class FieldTest(unittest.TestCase): assert "User" in m.__class__.__name__ def test_generic_reference_orphan_dbref(self): - """Ensure that generic orphan DBRef items in ListFields are dereferenced. - """ + """Ensure that generic orphan DBRef items in ListFields are dereferenced.""" class UserA(Document): name = StringField() @@ -1168,8 +1158,7 @@ class FieldTest(unittest.TestCase): assert msg.author.name == "new-name" def test_list_lookup_not_checked_in_map(self): - """Ensure we dereference list data correctly - """ + """Ensure we dereference list data correctly""" class Comment(Document): id = IntField(primary_key=True) @@ -1191,8 +1180,7 @@ class FieldTest(unittest.TestCase): assert 1 == msg.comments[1].id def test_list_item_dereference_dref_false_save_doesnt_cause_extra_queries(self): - """Ensure that DBRef items in ListFields are dereferenced. - """ + """Ensure that DBRef items in ListFields are dereferenced.""" class User(Document): name = StringField() @@ -1221,8 +1209,7 @@ class FieldTest(unittest.TestCase): assert q == 2 def test_list_item_dereference_dref_true_save_doesnt_cause_extra_queries(self): - """Ensure that DBRef items in ListFields are dereferenced. - """ + """Ensure that DBRef items in ListFields are dereferenced.""" class User(Document): name = StringField() diff --git a/tests/test_replicaset_connection.py b/tests/test_replicaset_connection.py index 5d83da00..1fdfcb20 100644 --- a/tests/test_replicaset_connection.py +++ b/tests/test_replicaset_connection.py @@ -22,8 +22,7 @@ class ConnectionTest(unittest.TestCase): mongoengine.connection._dbs = {} def test_replicaset_uri_passes_read_preference(self): - """Requires a replica set called "rs" on port 27017 - """ + """Requires a replica set called "rs" on port 27017""" try: conn = mongoengine.connect( db="mongoenginetest", From eabb8f60f55f2fd48afdae0bfe2764cde0ec921a Mon Sep 17 00:00:00 2001 From: Bastien Gerard Date: Tue, 8 Dec 2020 23:14:33 +0100 Subject: [PATCH 3/6] autoformat with pyupgrade --- .pre-commit-config.yaml | 5 + docs/conf.py | 4 +- mongoengine/base/datastructures.py | 14 +-- mongoengine/base/document.py | 23 ++-- mongoengine/base/fields.py | 8 +- mongoengine/base/metaclasses.py | 4 +- mongoengine/connection.py | 8 +- mongoengine/dereference.py | 4 +- mongoengine/errors.py | 8 +- mongoengine/fields.py | 24 ++-- mongoengine/queryset/base.py | 12 +- tests/document/test_class_methods.py | 6 +- tests/document/test_delta.py | 2 +- tests/document/test_dynamic.py | 12 +- tests/document/test_inheritance.py | 4 +- tests/document/test_instance.py | 26 ++--- tests/fields/test_binary_field.py | 12 +- tests/fields/test_cached_reference_field.py | 12 +- tests/fields/test_email_field.py | 8 +- tests/fields/test_embedded_document_field.py | 8 +- tests/fields/test_fields.py | 26 ++--- tests/fields/test_file_field.py | 40 ++++--- tests/fields/test_geo_fields.py | 2 +- tests/fields/test_map_field.py | 6 +- tests/fields/test_reference_field.py | 2 +- tests/fields/test_url_field.py | 4 +- tests/fixtures.py | 2 +- tests/queryset/test_geo.py | 4 +- tests/queryset/test_pickable.py | 2 +- tests/queryset/test_queryset.py | 111 ++++++++++--------- tests/queryset/test_queryset_aggregation.py | 2 +- tests/queryset/test_transform.py | 2 +- tests/test_datastructures.py | 2 +- tests/test_dereference.py | 2 +- tests/test_utils.py | 6 +- tests/utils.py | 2 +- 36 files changed, 207 insertions(+), 212 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index cb68249a..025e3b9e 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -10,3 +10,8 @@ repos: - id: flake8 additional_dependencies: - flake8-import-order + - repo: https://github.com/asottile/pyupgrade + rev: v2.7.4 + hooks: + - id: pyupgrade + args: [--py36-plus] \ No newline at end of file diff --git a/docs/conf.py b/docs/conf.py index fdb5b61d..299959ee 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -41,8 +41,8 @@ source_suffix = ".rst" master_doc = "index" # General information about the project. -project = u"MongoEngine" -copyright = u"2009, MongoEngine Authors" +project = "MongoEngine" +copyright = "2009, MongoEngine Authors" # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index 2a8fde6d..0f2f8a49 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -67,11 +67,11 @@ class BaseDict(dict): if isinstance(value, EmbeddedDocument) and value._instance is None: value._instance = self._instance elif isinstance(value, dict) and not isinstance(value, BaseDict): - value = BaseDict(value, None, "{}.{}".format(self._name, key)) + value = BaseDict(value, None, f"{self._name}.{key}") super().__setitem__(key, value) value._instance = self._instance elif isinstance(value, list) and not isinstance(value, BaseList): - value = BaseList(value, None, "{}.{}".format(self._name, key)) + value = BaseList(value, None, f"{self._name}.{key}") super().__setitem__(key, value) value._instance = self._instance return value @@ -97,7 +97,7 @@ class BaseDict(dict): def _mark_as_changed(self, key=None): if hasattr(self._instance, "_mark_as_changed"): if key: - self._instance._mark_as_changed("{}.{}".format(self._name, key)) + self._instance._mark_as_changed(f"{self._name}.{key}") else: self._instance._mark_as_changed(self._name) @@ -133,12 +133,12 @@ class BaseList(list): value._instance = self._instance elif isinstance(value, dict) and not isinstance(value, BaseDict): # Replace dict by BaseDict - value = BaseDict(value, None, "{}.{}".format(self._name, key)) + value = BaseDict(value, None, f"{self._name}.{key}") super().__setitem__(key, value) value._instance = self._instance elif isinstance(value, list) and not isinstance(value, BaseList): # Replace list by BaseList - value = BaseList(value, None, "{}.{}".format(self._name, key)) + value = BaseList(value, None, f"{self._name}.{key}") super().__setitem__(key, value) value._instance = self._instance return value @@ -429,7 +429,7 @@ class StrictDict: def __repr__(self): return "{%s}" % ", ".join( - '"{!s}": {!r}'.format(k, v) for k, v in self.items() + f'"{k!s}": {v!r}' for k, v in self.items() ) cls._classes[allowed_keys] = SpecificStrictDict @@ -472,4 +472,4 @@ class LazyReference(DBRef): raise AttributeError() def __repr__(self): - return "".format(self.document_type, self.pk) + return f"" diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 32ad0adc..45acfa3d 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -275,7 +275,7 @@ class BaseDocument: except (UnicodeEncodeError, UnicodeDecodeError): u = "[Bad Unicode data]" repr_type = str if u is None else type(u) - return repr_type("<{}: {}>".format(self.__class__.__name__, u)) + return repr_type(f"<{self.__class__.__name__}: {u}>") def __str__(self): # TODO this could be simpler? @@ -431,7 +431,7 @@ class BaseDocument: pk = self.pk elif self._instance and hasattr(self._instance, "pk"): pk = self._instance.pk - message = "ValidationError ({}:{}) ".format(self._class_name, pk) + message = f"ValidationError ({self._class_name}:{pk}) " raise ValidationError(message, errors=errors) def to_json(self, *args, **kwargs): @@ -504,7 +504,7 @@ class BaseDocument: if "." in key: key, rest = key.split(".", 1) key = self._db_field_map.get(key, key) - key = "{}.{}".format(key, rest) + key = f"{key}.{rest}" else: key = self._db_field_map.get(key, key) @@ -600,7 +600,7 @@ class BaseDocument: iterator = data.items() for index_or_key, value in iterator: - item_key = "{}{}.".format(base_key, index_or_key) + item_key = f"{base_key}{index_or_key}." # don't check anything lower if this key is already marked # as changed. if item_key[:-1] in changed_fields: @@ -608,7 +608,7 @@ class BaseDocument: if hasattr(value, "_get_changed_fields"): changed = value._get_changed_fields() - changed_fields += ["{}{}".format(item_key, k) for k in changed if k] + changed_fields += [f"{item_key}{k}" for k in changed if k] elif isinstance(value, (list, tuple, dict)): BaseDocument._nestable_types_changed_fields( changed_fields, item_key, value @@ -640,7 +640,7 @@ class BaseDocument: if isinstance(data, EmbeddedDocument): # Find all embedded fields that have been changed changed = data._get_changed_fields() - changed_fields += ["{}{}".format(key, k) for k in changed if k] + changed_fields += [f"{key}{k}" for k in changed if k] elif isinstance(data, (list, tuple, dict)): if hasattr(field, "field") and isinstance( field.field, (ReferenceField, GenericReferenceField) @@ -792,9 +792,7 @@ class BaseDocument: errors_dict[field_name] = e if errors_dict: - errors = "\n".join( - ["Field '{}' - {}".format(k, v) for k, v in errors_dict.items()] - ) + errors = "\n".join([f"Field '{k}' - {v}" for k, v in errors_dict.items()]) msg = "Invalid data to create a `{}` instance.\n{}".format( cls._class_name, errors, @@ -965,10 +963,7 @@ class BaseDocument: unique_fields += unique_with # Add the new index to the list - fields = [ - ("{}{}".format(namespace, f), pymongo.ASCENDING) - for f in unique_fields - ] + fields = [(f"{namespace}{f}", pymongo.ASCENDING) for f in unique_fields] index = {"fields": fields, "unique": True, "sparse": sparse} unique_indexes.append(index) @@ -1024,7 +1019,7 @@ class BaseDocument: elif field._geo_index: field_name = field.db_field if parent_field: - field_name = "{}.{}".format(parent_field, field_name) + field_name = f"{parent_field}.{field_name}" geo_indices.append({"fields": [(field_name, field._geo_index)]}) return geo_indices diff --git a/mongoengine/base/fields.py b/mongoengine/base/fields.py index 8df3d089..61dde5d2 100644 --- a/mongoengine/base/fields.py +++ b/mongoengine/base/fields.py @@ -40,7 +40,7 @@ class BaseField: choices=None, null=False, sparse=False, - **kwargs + **kwargs, ): """ :param db_field: The database field to store this field in @@ -465,9 +465,7 @@ class ComplexBaseField(BaseField): if errors: field_class = self.field.__class__.__name__ - self.error( - "Invalid {} item ({})".format(field_class, value), errors=errors - ) + self.error(f"Invalid {field_class} item ({value})", errors=errors) # Don't allow empty values if required if self.required and not value: self.error("Field is required and cannot be empty") @@ -537,7 +535,7 @@ class GeoJsonBaseField(BaseField): if isinstance(value, dict): if set(value.keys()) == {"type", "coordinates"}: if value["type"] != self._type: - self.error('{} type must be "{}"'.format(self._name, self._type)) + self.error(f'{self._name} type must be "{self._type}"') return self.validate(value["coordinates"]) else: self.error( diff --git a/mongoengine/base/metaclasses.py b/mongoengine/base/metaclasses.py index b4479b97..67a5f112 100644 --- a/mongoengine/base/metaclasses.py +++ b/mongoengine/base/metaclasses.py @@ -439,8 +439,8 @@ class TopLevelDocumentMetaclass(DocumentMetaclass): id_basename, id_db_basename, i = ("auto_id", "_auto_id", 0) for i in itertools.count(): - id_name = "{}_{}".format(id_basename, i) - id_db_name = "{}_{}".format(id_db_basename, i) + id_name = f"{id_basename}_{i}" + id_db_name = f"{id_db_basename}_{i}" if id_name not in existing_fields and id_db_name not in existing_db_fields: return id_name, id_db_name diff --git a/mongoengine/connection.py b/mongoengine/connection.py index 9253d556..f181cf61 100644 --- a/mongoengine/connection.py +++ b/mongoengine/connection.py @@ -54,7 +54,7 @@ def _get_connection_settings( password=None, authentication_source=None, authentication_mechanism=None, - **kwargs + **kwargs, ): """Get the connection settings as a dict @@ -177,7 +177,7 @@ def register_connection( password=None, authentication_source=None, authentication_mechanism=None, - **kwargs + **kwargs, ): """Register the connection settings. @@ -210,7 +210,7 @@ def register_connection( password=password, authentication_source=authentication_source, authentication_mechanism=authentication_mechanism, - **kwargs + **kwargs, ) _connection_settings[alias] = conn_settings @@ -313,7 +313,7 @@ def _create_connection(alias, connection_class, **connection_settings): try: return connection_class(**connection_settings) except Exception as e: - raise ConnectionFailure("Cannot connect to database {} :\n{}".format(alias, e)) + raise ConnectionFailure(f"Cannot connect to database {alias} :\n{e}") def _find_existing_connection(connection_settings): diff --git a/mongoengine/dereference.py b/mongoengine/dereference.py index a89bc15a..3cd200ea 100644 --- a/mongoengine/dereference.py +++ b/mongoengine/dereference.py @@ -271,12 +271,12 @@ class DeReference: (v["_ref"].collection, v["_ref"].id), v ) elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth: - item_name = "{}.{}.{}".format(name, k, field_name) + item_name = f"{name}.{k}.{field_name}" data[k]._data[field_name] = self._attach_objects( v, depth, instance=instance, name=item_name ) elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth: - item_name = "{}.{}".format(name, k) if name else name + item_name = f"{name}.{k}" if name else name data[k] = self._attach_objects( v, depth - 1, instance=instance, name=item_name ) diff --git a/mongoengine/errors.py b/mongoengine/errors.py index 95564ff9..2b3d2014 100644 --- a/mongoengine/errors.py +++ b/mongoengine/errors.py @@ -94,7 +94,7 @@ class ValidationError(AssertionError): return str(self.message) def __repr__(self): - return "{}({},)".format(self.__class__.__name__, self.message) + return f"{self.__class__.__name__}({self.message},)" def __getattribute__(self, name): message = super().__getattribute__(name) @@ -102,7 +102,7 @@ class ValidationError(AssertionError): if self.field_name: message = "%s" % message if self.errors: - message = "{}({})".format(message, self._format_errors()) + message = f"{message}({self._format_errors()})" return message def _get_message(self): @@ -147,13 +147,13 @@ class ValidationError(AssertionError): elif isinstance(value, dict): value = " ".join([generate_key(v, k) for k, v in value.items()]) - results = "{}.{}".format(prefix, value) if prefix else value + results = f"{prefix}.{value}" if prefix else value return results error_dict = defaultdict(list) for k, v in self.to_dict().items(): error_dict[generate_key(v)].append(k) - return " ".join(["{}: {}".format(k, v) for k, v in error_dict.items()]) + return " ".join([f"{k}: {v}" for k, v in error_dict.items()]) class DeprecatedError(Exception): diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 4ef5dafc..f1d854af 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -189,11 +189,11 @@ class URLField(StringField): # Check first if the scheme is valid scheme = value.split("://")[0].lower() if scheme not in self.schemes: - self.error("Invalid scheme {} in URL: {}".format(scheme, value)) + self.error(f"Invalid scheme {scheme} in URL: {value}") # Then check full URL if not self.url_regex.match(value): - self.error("Invalid URL: {}".format(value)) + self.error(f"Invalid URL: {value}") class EmailField(StringField): @@ -233,7 +233,7 @@ class EmailField(StringField): allow_utf8_user=False, allow_ip_domain=False, *args, - **kwargs + **kwargs, ): """ :param domain_whitelist: (optional) list of valid domain names applied during validation @@ -440,7 +440,7 @@ class DecimalField(BaseField): force_string=False, precision=2, rounding=decimal.ROUND_HALF_UP, - **kwargs + **kwargs, ): """ :param min_value: (optional) A min value that will be applied during validation @@ -1337,7 +1337,7 @@ class CachedReferenceField(BaseField): return None update_kwargs = { - "set__{}__{}".format(self.name, key): val + f"set__{self.name}__{key}": val for key, val in document._delta()[0].items() if key in self.fields } @@ -1739,12 +1739,12 @@ class GridFSProxy: return self.__copy__() def __repr__(self): - return "<{}: {}>".format(self.__class__.__name__, self.grid_id) + return f"<{self.__class__.__name__}: {self.grid_id}>" def __str__(self): gridout = self.get() filename = getattr(gridout, "filename") if gridout else "" - return "<{}: {} ({})>".format(self.__class__.__name__, filename, self.grid_id) + return f"<{self.__class__.__name__}: {filename} ({self.grid_id})>" def __eq__(self, other): if isinstance(other, GridFSProxy): @@ -2120,7 +2120,7 @@ class SequenceField(BaseField): sequence_name=None, value_decorator=None, *args, - **kwargs + **kwargs, ): self.collection_name = collection_name or self.COLLECTION_NAME self.db_alias = db_alias or DEFAULT_CONNECTION_NAME @@ -2135,7 +2135,7 @@ class SequenceField(BaseField): Generate and Increment the counter """ sequence_name = self.get_sequence_name() - sequence_id = "{}.{}".format(sequence_name, self.name) + sequence_id = f"{sequence_name}.{self.name}" collection = get_db(alias=self.db_alias)[self.collection_name] counter = collection.find_one_and_update( @@ -2149,7 +2149,7 @@ class SequenceField(BaseField): def set_next_value(self, value): """Helper method to set the next sequence value""" sequence_name = self.get_sequence_name() - sequence_id = "{}.{}".format(sequence_name, self.name) + sequence_id = f"{sequence_name}.{self.name}" collection = get_db(alias=self.db_alias)[self.collection_name] counter = collection.find_one_and_update( filter={"_id": sequence_id}, @@ -2166,7 +2166,7 @@ class SequenceField(BaseField): as it is only fixed on set. """ sequence_name = self.get_sequence_name() - sequence_id = "{}.{}".format(sequence_name, self.name) + sequence_id = f"{sequence_name}.{self.name}" collection = get_db(alias=self.db_alias)[self.collection_name] data = collection.find_one({"_id": sequence_id}) @@ -2427,7 +2427,7 @@ class LazyReferenceField(BaseField): passthrough=False, dbref=False, reverse_delete_rule=DO_NOTHING, - **kwargs + **kwargs, ): """Initialises the Reference Field. diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 43e03ef8..1f29cdf7 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -422,7 +422,7 @@ class BaseQuerySet: count = count_documents( collection=self._cursor.collection, filter=self._cursor._Cursor__spec, - **kwargs + **kwargs, ) self._cursor_obj = None @@ -526,7 +526,7 @@ class BaseQuerySet: write_concern=None, read_concern=None, full_result=False, - **update + **update, ): """Perform an atomic update on the fields matched by the query. @@ -603,7 +603,7 @@ class BaseQuerySet: write_concern=write_concern, read_concern=read_concern, full_result=True, - **update + **update, ) if atomic_update.raw_result["updatedExisting"]: @@ -634,7 +634,7 @@ class BaseQuerySet: multi=False, write_concern=write_concern, full_result=full_result, - **update + **update, ) def modify( @@ -692,7 +692,7 @@ class BaseQuerySet: upsert=upsert, sort=sort, return_document=return_doc, - **self._cursor_args + **self._cursor_args, ) except pymongo.errors.DuplicateKeyError as err: raise NotUniqueError("Update failed (%s)" % err) @@ -1194,7 +1194,7 @@ class BaseQuerySet: preference. """ if read_concern is not None and not isinstance(read_concern, Mapping): - raise TypeError("%r is not a valid read concern." % (read_concern,)) + raise TypeError(f"{read_concern!r} is not a valid read concern.") queryset = self.clone() queryset._read_concern = ( diff --git a/tests/document/test_class_methods.py b/tests/document/test_class_methods.py index 7a9428df..e20a5802 100644 --- a/tests/document/test_class_methods.py +++ b/tests/document/test_class_methods.py @@ -231,7 +231,7 @@ class TestClassMethods(unittest.TestCase): assert BlogPost.list_indexes() == [ [("_cls", 1), ("author", 1), ("tags", 1)], [("_cls", 1), ("author", 1), ("tags", 1), ("extra_text", 1)], - [(u"_id", 1)], + [("_id", 1)], [("_cls", 1)], ] @@ -288,7 +288,7 @@ class TestClassMethods(unittest.TestCase): assert "wibble" == InheritedAbstractNamingTest._get_collection_name() # Mixin tests - class BaseMixin(object): + class BaseMixin: meta = {"collection": lambda c: c.__name__.lower()} class OldMixinNamingConvention(Document, BaseMixin): @@ -299,7 +299,7 @@ class TestClassMethods(unittest.TestCase): == OldMixinNamingConvention._get_collection_name() ) - class BaseMixin(object): + class BaseMixin: meta = {"collection": lambda c: c.__name__.lower()} class BaseDocument(Document, BaseMixin): diff --git a/tests/document/test_delta.py b/tests/document/test_delta.py index 2aae0af6..817bc40e 100644 --- a/tests/document/test_delta.py +++ b/tests/document/test_delta.py @@ -8,7 +8,7 @@ from tests.utils import MongoDBTestCase class TestDelta(MongoDBTestCase): def setUp(self): - super(TestDelta, self).setUp() + super().setUp() class Person(Document): name = StringField() diff --git a/tests/document/test_dynamic.py b/tests/document/test_dynamic.py index dc7ecb8b..909c6f79 100644 --- a/tests/document/test_dynamic.py +++ b/tests/document/test_dynamic.py @@ -10,7 +10,7 @@ __all__ = ("TestDynamicDocument",) class TestDynamicDocument(MongoDBTestCase): def setUp(self): - super(TestDynamicDocument, self).setUp() + super().setUp() class Person(DynamicDocument): name = StringField() @@ -118,17 +118,17 @@ class TestDynamicDocument(MongoDBTestCase): p.save() raw_p = Person.objects.as_pymongo().get(id=p.id) - assert raw_p == {"_cls": u"Person", "_id": p.id, "name": u"Dean"} + assert raw_p == {"_cls": "Person", "_id": p.id, "name": "Dean"} p.name = "OldDean" p.newattr = "garbage" p.save() raw_p = Person.objects.as_pymongo().get(id=p.id) assert raw_p == { - "_cls": u"Person", + "_cls": "Person", "_id": p.id, "name": "OldDean", - "newattr": u"garbage", + "newattr": "garbage", } def test_fields_containing_underscore(self): @@ -144,14 +144,14 @@ class TestDynamicDocument(MongoDBTestCase): p.save() raw_p = WeirdPerson.objects.as_pymongo().get(id=p.id) - assert raw_p == {"_id": p.id, "_name": u"Dean", "name": u"Dean"} + assert raw_p == {"_id": p.id, "_name": "Dean", "name": "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) - assert raw_p == {"_id": p.id, "_name": u"NewDean", "name": u"OldDean"} + assert raw_p == {"_id": p.id, "_name": "NewDean", "name": "OldDean"} def test_dynamic_document_queries(self): """Ensure we can query dynamic fields""" diff --git a/tests/document/test_inheritance.py b/tests/document/test_inheritance.py index bd694a1c..fdeb4052 100644 --- a/tests/document/test_inheritance.py +++ b/tests/document/test_inheritance.py @@ -281,9 +281,7 @@ class TestInheritance(MongoDBTestCase): assert sorted( [idx["key"] for idx in C._get_collection().index_information().values()] - ) == sorted( - [[(u"_cls", 1), (u"b", 1)], [(u"_id", 1)], [(u"_cls", 1), (u"a", 1)]] - ) + ) == sorted([[("_cls", 1), ("b", 1)], [("_id", 1)], [("_cls", 1), ("a", 1)]]) def test_polymorphic_queries(self): """Ensure that the correct subclasses are returned from a query""" diff --git a/tests/document/test_instance.py b/tests/document/test_instance.py index a28cd472..17b99983 100644 --- a/tests/document/test_instance.py +++ b/tests/document/test_instance.py @@ -168,7 +168,7 @@ class TestDocumentInstance(MongoDBTestCase): def __unicode__(self): return self.title - doc = Article(title=u"привет мир") + doc = Article(title="привет мир") assert "" == repr(doc) @@ -181,7 +181,7 @@ class TestDocumentInstance(MongoDBTestCase): def __str__(self): return None - doc = Article(title=u"привет мир") + doc = Article(title="привет мир") assert "" == repr(doc) def test_queryset_resurrects_dropped_collection(self): @@ -521,9 +521,9 @@ class TestDocumentInstance(MongoDBTestCase): query_op = q.db.system.profile.find({"ns": "mongoenginetest.animal"})[0] assert query_op["op"] == "update" if mongo_db <= MONGODB_34: - assert set(query_op["query"].keys()) == set(["_id", "is_mammal"]) + assert set(query_op["query"].keys()) == {"_id", "is_mammal"} else: - assert set(query_op["command"]["q"].keys()) == set(["_id", "is_mammal"]) + assert set(query_op["command"]["q"].keys()) == {"_id", "is_mammal"} Animal.drop_collection() @@ -546,7 +546,7 @@ class TestDocumentInstance(MongoDBTestCase): query_op = q.db.system.profile.find({"ns": "mongoenginetest.animal"})[0] assert query_op["op"] == "command" assert query_op["command"]["findAndModify"] == "animal" - assert set(query_op["command"]["query"].keys()) == set(["_id", "is_mammal"]) + assert set(query_op["command"]["query"].keys()) == {"_id", "is_mammal"} Animal.drop_collection() @@ -1428,11 +1428,11 @@ class TestDocumentInstance(MongoDBTestCase): coll = self.Person._get_collection() doc = self.Person(name="John").save() raw_doc = coll.find_one({"_id": doc.pk}) - assert set(raw_doc.keys()) == set(["_id", "_cls", "name"]) + assert set(raw_doc.keys()) == {"_id", "_cls", "name"} doc.update(rename__name="first_name") raw_doc = coll.find_one({"_id": doc.pk}) - assert set(raw_doc.keys()) == set(["_id", "_cls", "first_name"]) + assert set(raw_doc.keys()) == {"_id", "_cls", "first_name"} assert raw_doc["first_name"] == "John" def test_inserts_if_you_set_the_pk(self): @@ -2041,7 +2041,7 @@ class TestDocumentInstance(MongoDBTestCase): assert promoted_employee.details is None def test_object_mixins(self): - class NameMixin(object): + class NameMixin: name = StringField() class Foo(EmbeddedDocument, NameMixin): @@ -2055,7 +2055,7 @@ class TestDocumentInstance(MongoDBTestCase): assert ["id", "name", "widgets"] == sorted(Bar._fields.keys()) def test_mixin_inheritance(self): - class BaseMixIn(object): + class BaseMixIn: count = IntField() data = StringField() @@ -2929,7 +2929,7 @@ class TestDocumentInstance(MongoDBTestCase): # $Where assert ( - u",".join( + ",".join( [ str(b) for b in Book.objects.filter( @@ -3303,7 +3303,7 @@ class TestDocumentInstance(MongoDBTestCase): for node_name, node in self.nodes.items(): node.expand() node.save(*args, **kwargs) - super(NodesSystem, self).save(*args, **kwargs) + super().save(*args, **kwargs) NodesSystem.drop_collection() Node.drop_collection() @@ -3752,7 +3752,7 @@ class TestDocumentInstance(MongoDBTestCase): _ = list(Jedi.objects) # Ensure a proper document loads without errors # Forces a document with a wrong shape (may occur in case of migration) - value = u"I_should_be_a_dict" + value = "I_should_be_a_dict" coll.insert_one({"light_saber": value}) with pytest.raises(InvalidDocumentError) as exc_info: @@ -3819,7 +3819,7 @@ class ObjectKeyTestCase(MongoDBTestCase): class DBFieldMappingTest(MongoDBTestCase): def setUp(self): - class Fields(object): + class Fields: w1 = BooleanField(db_field="w2") x1 = BooleanField(db_field="x2") diff --git a/tests/fields/test_binary_field.py b/tests/fields/test_binary_field.py index 0f92d53b..8dfcdb54 100644 --- a/tests/fields/test_binary_field.py +++ b/tests/fields/test_binary_field.py @@ -19,7 +19,7 @@ class TestBinaryField(MongoDBTestCase): content_type = StringField() blob = BinaryField() - BLOB = "\xe6\x00\xc4\xff\x07".encode("latin-1") + BLOB = b"\xe6\x00\xc4\xff\x07" MIME_TYPE = "application/octet-stream" Attachment.drop_collection() @@ -43,11 +43,11 @@ class TestBinaryField(MongoDBTestCase): attachment_required = AttachmentRequired() with pytest.raises(ValidationError): attachment_required.validate() - attachment_required.blob = Binary("\xe6\x00\xc4\xff\x07".encode("latin-1")) + attachment_required.blob = Binary(b"\xe6\x00\xc4\xff\x07") attachment_required.validate() - _5_BYTES = "\xe6\x00\xc4\xff\x07".encode("latin-1") - _4_BYTES = "\xe6\x00\xc4\xff".encode("latin-1") + _5_BYTES = b"\xe6\x00\xc4\xff\x07" + _4_BYTES = b"\xe6\x00\xc4\xff" with pytest.raises(ValidationError): AttachmentSizeLimit(blob=_5_BYTES).validate() AttachmentSizeLimit(blob=_4_BYTES).validate() @@ -58,7 +58,7 @@ class TestBinaryField(MongoDBTestCase): class Attachment(Document): blob = BinaryField() - for invalid_data in (2, u"Im_a_unicode", ["some_str"]): + for invalid_data in (2, "Im_a_unicode", ["some_str"]): with pytest.raises(ValidationError): Attachment(blob=invalid_data).validate() @@ -129,7 +129,7 @@ class TestBinaryField(MongoDBTestCase): MyDocument.drop_collection() - bin_data = "\xe6\x00\xc4\xff\x07".encode("latin-1") + bin_data = b"\xe6\x00\xc4\xff\x07" doc = MyDocument(bin_field=bin_data).save() n_updated = MyDocument.objects(bin_field=bin_data).update_one( diff --git a/tests/fields/test_cached_reference_field.py b/tests/fields/test_cached_reference_field.py index dd804b38..7a96bc06 100644 --- a/tests/fields/test_cached_reference_field.py +++ b/tests/fields/test_cached_reference_field.py @@ -190,9 +190,9 @@ class TestCachedReferenceField(MongoDBTestCase): assert dict(a2.to_mongo()) == { "_id": a2.pk, - "name": u"Wilson Junior", - "tp": u"pf", - "father": {"_id": a1.pk, "tp": u"pj"}, + "name": "Wilson Junior", + "tp": "pf", + "father": {"_id": a1.pk, "tp": "pj"}, } assert Person.objects(father=a1)._query == {"father._id": a1.pk} @@ -204,9 +204,9 @@ class TestCachedReferenceField(MongoDBTestCase): a2.reload() assert dict(a2.to_mongo()) == { "_id": a2.pk, - "name": u"Wilson Junior", - "tp": u"pf", - "father": {"_id": a1.pk, "tp": u"pf"}, + "name": "Wilson Junior", + "tp": "pf", + "father": {"_id": a1.pk, "tp": "pf"}, } def test_cached_reference_fields_on_embedded_documents(self): diff --git a/tests/fields/test_email_field.py b/tests/fields/test_email_field.py index 893180a4..974360ef 100644 --- a/tests/fields/test_email_field.py +++ b/tests/fields/test_email_field.py @@ -30,11 +30,11 @@ class TestEmailField(MongoDBTestCase): user.validate() # unicode domain - user = User(email=u"user@пример.рф") + user = User(email="user@пример.рф") user.validate() # invalid unicode domain - user = User(email=u"user@пример") + user = User(email="user@пример") with pytest.raises(ValidationError): user.validate() @@ -48,7 +48,7 @@ class TestEmailField(MongoDBTestCase): email = EmailField() # unicode user shouldn't validate by default... - user = User(email=u"Dörte@Sörensen.example.com") + user = User(email="Dörte@Sörensen.example.com") with pytest.raises(ValidationError): user.validate() @@ -56,7 +56,7 @@ class TestEmailField(MongoDBTestCase): class User(Document): email = EmailField(allow_utf8_user=True) - user = User(email=u"Dörte@Sörensen.example.com") + user = User(email="Dörte@Sörensen.example.com") user.validate() def test_email_field_domain_whitelist(self): diff --git a/tests/fields/test_embedded_document_field.py b/tests/fields/test_embedded_document_field.py index e116dc0d..480bec20 100644 --- a/tests/fields/test_embedded_document_field.py +++ b/tests/fields/test_embedded_document_field.py @@ -74,7 +74,7 @@ class TestEmbeddedDocumentField(MongoDBTestCase): # Test non exiting attribute with pytest.raises(InvalidQueryError) as exc_info: Person.objects(settings__notexist="bar").first() - assert str(exc_info.value) == u'Cannot resolve field "notexist"' + assert str(exc_info.value) == 'Cannot resolve field "notexist"' with pytest.raises(LookUpError): Person.objects.only("settings.notexist") @@ -110,7 +110,7 @@ class TestEmbeddedDocumentField(MongoDBTestCase): # Test non exiting attribute with pytest.raises(InvalidQueryError) as exc_info: assert Person.objects(settings__notexist="bar").first().id == p.id - assert str(exc_info.value) == u'Cannot resolve field "notexist"' + assert str(exc_info.value) == 'Cannot resolve field "notexist"' # Test existing attribute assert Person.objects(settings__base_foo="basefoo").first().id == p.id @@ -318,7 +318,7 @@ class TestGenericEmbeddedDocumentField(MongoDBTestCase): # Test non exiting attribute with pytest.raises(InvalidQueryError) as exc_info: Person.objects(settings__notexist="bar").first() - assert str(exc_info.value) == u'Cannot resolve field "notexist"' + assert str(exc_info.value) == 'Cannot resolve field "notexist"' with pytest.raises(LookUpError): Person.objects.only("settings.notexist") @@ -346,7 +346,7 @@ class TestGenericEmbeddedDocumentField(MongoDBTestCase): # Test non exiting attribute with pytest.raises(InvalidQueryError) as exc_info: assert Person.objects(settings__notexist="bar").first().id == p.id - assert str(exc_info.value) == u'Cannot resolve field "notexist"' + assert str(exc_info.value) == 'Cannot resolve field "notexist"' # Test existing attribute assert Person.objects(settings__base_foo="basefoo").first().id == p.id diff --git a/tests/fields/test_fields.py b/tests/fields/test_fields.py index ff1fde98..ce16a904 100644 --- a/tests/fields/test_fields.py +++ b/tests/fields/test_fields.py @@ -292,7 +292,7 @@ class TestField(MongoDBTestCase): HandleNoneFields.drop_collection() doc = HandleNoneFields() - doc.str_fld = u"spam ham egg" + doc.str_fld = "spam ham egg" doc.int_fld = 42 doc.flt_fld = 4.2 doc.com_dt_fld = datetime.datetime.utcnow() @@ -328,7 +328,7 @@ class TestField(MongoDBTestCase): HandleNoneFields.drop_collection() doc = HandleNoneFields() - doc.str_fld = u"spam ham egg" + doc.str_fld = "spam ham egg" doc.int_fld = 42 doc.flt_fld = 4.2 doc.comp_dt_fld = datetime.datetime.utcnow() @@ -426,9 +426,9 @@ class TestField(MongoDBTestCase): def test_list_validation(self): """Ensure that a list field only accepts lists with valid elements.""" access_level_choices = ( - ("a", u"Administration"), - ("b", u"Manager"), - ("c", u"Staff"), + ("a", "Administration"), + ("b", "Manager"), + ("c", "Staff"), ) class User(Document): @@ -476,7 +476,7 @@ class TestField(MongoDBTestCase): post.access_list = ["a", "b"] post.validate() - assert post.get_access_list_display() == u"Administration, Manager" + assert post.get_access_list_display() == "Administration, Manager" post.comments = ["a"] with pytest.raises(ValidationError): @@ -2028,8 +2028,8 @@ class TestField(MongoDBTestCase): """Ensure that error messages are correct.""" SIZES = ("S", "M", "L", "XL", "XXL") COLORS = (("R", "Red"), ("B", "Blue")) - SIZE_MESSAGE = u"Value must be one of ('S', 'M', 'L', 'XL', 'XXL')" - COLOR_MESSAGE = u"Value must be one of ['R', 'B']" + SIZE_MESSAGE = "Value must be one of ('S', 'M', 'L', 'XL', 'XXL')" + COLOR_MESSAGE = "Value must be one of ['R', 'B']" class Shirt(Document): size = StringField(max_length=3, choices=SIZES) @@ -2092,7 +2092,7 @@ class TestField(MongoDBTestCase): assert "comments" in error_dict assert 1 in error_dict["comments"] assert "content" in error_dict["comments"][1] - assert error_dict["comments"][1]["content"] == u"Field is required" + assert error_dict["comments"][1]["content"] == "Field is required" post.comments[1].content = "here we go" post.validate() @@ -2104,7 +2104,7 @@ class TestField(MongoDBTestCase): class EnumField(BaseField): def __init__(self, **kwargs): - super(EnumField, self).__init__(**kwargs) + super().__init__(**kwargs) def to_mongo(self, value): return value @@ -2606,11 +2606,11 @@ class TestEmbeddedDocumentListField(MongoDBTestCase): """ post = self.BlogPost( comments=[ - self.Comments(author="user1", message=u"сообщение"), - self.Comments(author="user2", message=u"хабарлама"), + self.Comments(author="user1", message="сообщение"), + self.Comments(author="user2", message="хабарлама"), ] ).save() - assert post.comments.get(message=u"сообщение").author == "user1" + assert post.comments.get(message="сообщение").author == "user1" def test_save(self): """ diff --git a/tests/fields/test_file_field.py b/tests/fields/test_file_field.py index dc9354f0..9a20c917 100644 --- a/tests/fields/test_file_field.py +++ b/tests/fields/test_file_field.py @@ -55,7 +55,7 @@ class TestFileField(MongoDBTestCase): PutFile.drop_collection() - text = "Hello, World!".encode("latin-1") + text = b"Hello, World!" content_type = "text/plain" putfile = PutFile() @@ -97,8 +97,8 @@ class TestFileField(MongoDBTestCase): StreamFile.drop_collection() - text = "Hello, World!".encode("latin-1") - more_text = "Foo Bar".encode("latin-1") + text = b"Hello, World!" + more_text = b"Foo Bar" content_type = "text/plain" streamfile = StreamFile() @@ -133,8 +133,8 @@ class TestFileField(MongoDBTestCase): StreamFile.drop_collection() - text = "Hello, World!".encode("latin-1") - more_text = "Foo Bar".encode("latin-1") + text = b"Hello, World!" + more_text = b"Foo Bar" streamfile = StreamFile() streamfile.save() @@ -163,8 +163,8 @@ class TestFileField(MongoDBTestCase): class SetFile(Document): the_file = FileField() - text = "Hello, World!".encode("latin-1") - more_text = "Foo Bar".encode("latin-1") + text = b"Hello, World!" + more_text = b"Foo Bar" SetFile.drop_collection() @@ -192,7 +192,7 @@ class TestFileField(MongoDBTestCase): GridDocument.drop_collection() with tempfile.TemporaryFile() as f: - f.write("Hello World!".encode("latin-1")) + f.write(b"Hello World!") f.flush() # Test without default @@ -209,7 +209,7 @@ class TestFileField(MongoDBTestCase): assert doc_b.the_file.grid_id == doc_c.the_file.grid_id # Test with default - doc_d = GridDocument(the_file="".encode("latin-1")) + doc_d = GridDocument(the_file=b"") doc_d.save() doc_e = GridDocument.objects.with_id(doc_d.id) @@ -235,7 +235,7 @@ class TestFileField(MongoDBTestCase): # First instance test_file = TestFile() test_file.name = "Hello, World!" - test_file.the_file.put("Hello, World!".encode("latin-1")) + test_file.the_file.put(b"Hello, World!") test_file.save() # Second instance @@ -291,9 +291,7 @@ class TestFileField(MongoDBTestCase): test_file = TestFile() assert not bool(test_file.the_file) - test_file.the_file.put( - "Hello, World!".encode("latin-1"), content_type="text/plain" - ) + test_file.the_file.put(b"Hello, World!", content_type="text/plain") test_file.save() assert bool(test_file.the_file) @@ -315,7 +313,7 @@ class TestFileField(MongoDBTestCase): class TestFile(Document): the_file = FileField() - text = "Hello, World!".encode("latin-1") + text = b"Hello, World!" content_type = "text/plain" testfile = TestFile() @@ -359,7 +357,7 @@ class TestFileField(MongoDBTestCase): testfile.the_file.put(text, content_type=content_type, filename="hello") testfile.save() - text = "Bonjour, World!".encode("latin-1") + text = b"Bonjour, World!" testfile.the_file.replace(text, content_type=content_type, filename="hello") testfile.save() @@ -383,7 +381,7 @@ class TestFileField(MongoDBTestCase): TestImage.drop_collection() with tempfile.TemporaryFile() as f: - f.write("Hello World!".encode("latin-1")) + f.write(b"Hello World!") f.flush() t = TestImage() @@ -499,21 +497,21 @@ class TestFileField(MongoDBTestCase): # First instance test_file = TestFile() test_file.name = "Hello, World!" - test_file.the_file.put("Hello, World!".encode("latin-1"), name="hello.txt") + test_file.the_file.put(b"Hello, World!", name="hello.txt") test_file.save() data = get_db("test_files").macumba.files.find_one() assert data.get("name") == "hello.txt" test_file = TestFile.objects.first() - assert test_file.the_file.read() == "Hello, World!".encode("latin-1") + assert test_file.the_file.read() == b"Hello, World!" test_file = TestFile.objects.first() - test_file.the_file = "Hello, World!".encode("latin-1") + test_file.the_file = b"Hello, World!" test_file.save() test_file = TestFile.objects.first() - assert test_file.the_file.read() == "Hello, World!".encode("latin-1") + assert test_file.the_file.read() == b"Hello, World!" def test_copyable(self): class PutFile(Document): @@ -521,7 +519,7 @@ class TestFileField(MongoDBTestCase): PutFile.drop_collection() - text = "Hello, World!".encode("latin-1") + text = b"Hello, World!" content_type = "text/plain" putfile = PutFile() diff --git a/tests/fields/test_geo_fields.py b/tests/fields/test_geo_fields.py index a611be85..3c63b168 100644 --- a/tests/fields/test_geo_fields.py +++ b/tests/fields/test_geo_fields.py @@ -8,7 +8,7 @@ class TestGeoField(MongoDBTestCase): def _test_for_expected_error(self, Cls, loc, expected): try: Cls(loc=loc).validate() - self.fail("Should not validate the location {0}".format(loc)) + self.fail(f"Should not validate the location {loc}") except ValidationError as e: assert expected == e.to_dict()["loc"] diff --git a/tests/fields/test_map_field.py b/tests/fields/test_map_field.py index ea60e34d..eb747ef2 100644 --- a/tests/fields/test_map_field.py +++ b/tests/fields/test_map_field.py @@ -135,11 +135,11 @@ class TestMapField(MongoDBTestCase): BlogPost.drop_collection() - tree = BlogPost(info_dict={u"éééé": {"description": u"VALUE: éééé"}}) + tree = BlogPost(info_dict={"éééé": {"description": "VALUE: éééé"}}) tree.save() assert ( - BlogPost.objects.get(id=tree.id).info_dict[u"éééé"].description - == u"VALUE: éééé" + BlogPost.objects.get(id=tree.id).info_dict["éééé"].description + == "VALUE: éééé" ) diff --git a/tests/fields/test_reference_field.py b/tests/fields/test_reference_field.py index e2c92034..275e3fe1 100644 --- a/tests/fields/test_reference_field.py +++ b/tests/fields/test_reference_field.py @@ -87,7 +87,7 @@ class TestReferenceField(MongoDBTestCase): parent = ReferenceField("self", dbref=False) p = Person(name="Steve", parent=DBRef("person", "abcdefghijklmnop")) - assert p.to_mongo() == SON([("name", u"Steve"), ("parent", "abcdefghijklmnop")]) + assert p.to_mongo() == SON([("name", "Steve"), ("parent", "abcdefghijklmnop")]) def test_objectid_reference_fields(self): class Person(Document): diff --git a/tests/fields/test_url_field.py b/tests/fields/test_url_field.py index eb639bfe..7639eb6e 100644 --- a/tests/fields/test_url_field.py +++ b/tests/fields/test_url_field.py @@ -26,7 +26,7 @@ class TestURLField(MongoDBTestCase): url = URLField() link = Link() - link.url = u"http://привет.com" + link.url = "http://привет.com" # TODO fix URL validation - this *IS* a valid URL # For now we just want to make sure that the error message is correct @@ -34,7 +34,7 @@ class TestURLField(MongoDBTestCase): link.validate() assert ( str(exc_info.value) - == u"ValidationError (Link:None) (Invalid URL: http://\u043f\u0440\u0438\u0432\u0435\u0442.com: ['url'])" + == "ValidationError (Link:None) (Invalid URL: http://\u043f\u0440\u0438\u0432\u0435\u0442.com: ['url'])" ) def test_url_scheme_validation(self): diff --git a/tests/fixtures.py b/tests/fixtures.py index 59fc3bf3..ef82c22a 100644 --- a/tests/fixtures.py +++ b/tests/fixtures.py @@ -53,7 +53,7 @@ signals.post_save.connect(PickleSignalsTest.post_save, sender=PickleSignalsTest) signals.post_delete.connect(PickleSignalsTest.post_delete, sender=PickleSignalsTest) -class Mixin(object): +class Mixin: name = StringField() diff --git a/tests/queryset/test_geo.py b/tests/queryset/test_geo.py index a546fdb6..81ade092 100644 --- a/tests/queryset/test_geo.py +++ b/tests/queryset/test_geo.py @@ -496,8 +496,8 @@ class TestGeoQueries(MongoDBTestCase): p.save() qs = Place.objects().only("location") assert qs.as_pymongo()[0]["location"] == { - u"type": u"Point", - u"coordinates": [24.946861267089844, 60.16311983618494], + "type": "Point", + "coordinates": [24.946861267089844, 60.16311983618494], } def test_2dsphere_point_sets_correctly(self): diff --git a/tests/queryset/test_pickable.py b/tests/queryset/test_pickable.py index d41f56df..d20db32e 100644 --- a/tests/queryset/test_pickable.py +++ b/tests/queryset/test_pickable.py @@ -18,7 +18,7 @@ class TestQuerysetPickable(MongoDBTestCase): """ def setUp(self): - super(TestQuerysetPickable, self).setUp() + super().setUp() self.john = Person.objects.create(name="John", age=21) def test_picke_simple_qs(self): diff --git a/tests/queryset/test_queryset.py b/tests/queryset/test_queryset.py index 3f1b85d7..c75f2f10 100644 --- a/tests/queryset/test_queryset.py +++ b/tests/queryset/test_queryset.py @@ -113,7 +113,7 @@ class TestQueryset(unittest.TestCase): def test_slicing_sets_empty_limit_skip(self): self.Person.objects.insert( - [self.Person(name="User {}".format(i), age=i) for i in range(5)], + [self.Person(name=f"User {i}", age=i) for i in range(5)], load_bulk=False, ) @@ -1570,9 +1570,9 @@ class TestQueryset(unittest.TestCase): results = BlogPost.objects.exec_js(code) expected_results = [ - {u"comment": u"cool", u"document": u"post1"}, - {u"comment": u"yay", u"document": u"post1"}, - {u"comment": u"nice stuff", u"document": u"post2"}, + {"comment": "cool", "document": "post1"}, + {"comment": "yay", "document": "post1"}, + {"comment": "nice stuff", "document": "post2"}, ] assert results == expected_results @@ -2721,10 +2721,10 @@ class TestQueryset(unittest.TestCase): f1.save() # persons of first family - Person(id=1, family=f1, name=u"Wilson Jr", age=21).save() - Person(id=2, family=f1, name=u"Wilson Father", age=45).save() - Person(id=3, family=f1, name=u"Eliana Costa", age=40).save() - Person(id=4, family=f1, name=u"Tayza Mariana", age=17).save() + Person(id=1, family=f1, name="Wilson Jr", age=21).save() + Person(id=2, family=f1, name="Wilson Father", age=45).save() + Person(id=3, family=f1, name="Eliana Costa", age=40).save() + Person(id=4, family=f1, name="Tayza Mariana", age=17).save() # creating second family f2 = Family(id=2, log="Av prof frasc brunno") @@ -2802,10 +2802,10 @@ class TestQueryset(unittest.TestCase): "_id": 1, "value": { "persons": [ - {"age": 21, "name": u"Wilson Jr"}, - {"age": 45, "name": u"Wilson Father"}, - {"age": 40, "name": u"Eliana Costa"}, - {"age": 17, "name": u"Tayza Mariana"}, + {"age": 21, "name": "Wilson Jr"}, + {"age": 45, "name": "Wilson Father"}, + {"age": 40, "name": "Eliana Costa"}, + {"age": 17, "name": "Tayza Mariana"}, ], "totalAge": 123, }, @@ -2815,9 +2815,9 @@ class TestQueryset(unittest.TestCase): "_id": 2, "value": { "persons": [ - {"age": 16, "name": u"Isabella Luanna"}, - {"age": 36, "name": u"Sandra Mara"}, - {"age": 10, "name": u"Igor Gabriel"}, + {"age": 16, "name": "Isabella Luanna"}, + {"age": 36, "name": "Sandra Mara"}, + {"age": 10, "name": "Igor Gabriel"}, ], "totalAge": 62, }, @@ -2827,8 +2827,8 @@ class TestQueryset(unittest.TestCase): "_id": 3, "value": { "persons": [ - {"age": 30, "name": u"Arthur WA"}, - {"age": 25, "name": u"Paula Leonel"}, + {"age": 30, "name": "Arthur WA"}, + {"age": 25, "name": "Paula Leonel"}, ], "totalAge": 55, }, @@ -2974,7 +2974,7 @@ class TestQueryset(unittest.TestCase): def test_assertions(f): f = {key: int(val) for key, val in f.items()} - assert set(["music", "film", "actors", "watch"]) == set(f.keys()) + assert {"music", "film", "actors", "watch"} == set(f.keys()) assert f["music"] == 3 assert f["actors"] == 2 assert f["watch"] == 2 @@ -2988,7 +2988,7 @@ class TestQueryset(unittest.TestCase): # Ensure query is taken into account def test_assertions(f): f = {key: int(val) for key, val in f.items()} - assert set(["music", "actors", "watch"]) == set(f.keys()) + assert {"music", "actors", "watch"} == set(f.keys()) assert f["music"] == 2 assert f["actors"] == 1 assert f["watch"] == 1 @@ -3016,7 +3016,7 @@ class TestQueryset(unittest.TestCase): # Check item_frequencies works for non-list fields def test_assertions(f): - assert set([1, 2]) == set(f.keys()) + assert {1, 2} == set(f.keys()) assert f[1] == 1 assert f[2] == 2 @@ -3053,7 +3053,7 @@ class TestQueryset(unittest.TestCase): def test_assertions(f): f = {key: int(val) for key, val in f.items()} - assert set(["62-3331-1656", "62-3332-1656"]) == set(f.keys()) + assert {"62-3331-1656", "62-3332-1656"} == set(f.keys()) assert f["62-3331-1656"] == 2 assert f["62-3332-1656"] == 1 @@ -3065,7 +3065,7 @@ class TestQueryset(unittest.TestCase): # Ensure query is taken into account def test_assertions(f): f = {key: int(val) for key, val in f.items()} - assert set(["62-3331-1656"]) == set(f.keys()) + assert {"62-3331-1656"} == set(f.keys()) assert f["62-3331-1656"] == 2 exec_js = Person.objects(phone__number="62-3331-1656").item_frequencies( @@ -3132,10 +3132,10 @@ class TestQueryset(unittest.TestCase): p.save() ot = Person.objects.item_frequencies("extra.tag", map_reduce=False) - assert ot == {None: 1.0, u"friend": 1.0} + assert ot == {None: 1.0, "friend": 1.0} ot = Person.objects.item_frequencies("extra.tag", map_reduce=True) - assert ot == {None: 1.0, u"friend": 1.0} + assert ot == {None: 1.0, "friend": 1.0} def test_item_frequencies_with_0_values(self): class Test(Document): @@ -3379,13 +3379,16 @@ class TestQueryset(unittest.TestCase): self.Person(name="Mr White", age=20).save() self.Person(name="Mr Orange", age=30).save() self.Person(name="Mr Pink", age=30).save() - assert set(self.Person.objects.distinct("name")) == set( - ["Mr Orange", "Mr White", "Mr Pink"] - ) - assert set(self.Person.objects.distinct("age")) == set([20, 30]) - assert set(self.Person.objects(age=30).distinct("name")) == set( - ["Mr Orange", "Mr Pink"] - ) + assert set(self.Person.objects.distinct("name")) == { + "Mr Orange", + "Mr White", + "Mr Pink", + } + assert set(self.Person.objects.distinct("age")) == {20, 30} + assert set(self.Person.objects(age=30).distinct("name")) == { + "Mr Orange", + "Mr Pink", + } def test_distinct_handles_references(self): class Foo(Document): @@ -3446,8 +3449,8 @@ class TestQueryset(unittest.TestCase): assert count == 1 News( - title=u"As eleições no Brasil já estão em planejamento", - content=u"A candidata dilma roussef já começa o teu planejamento", + title="As eleições no Brasil já estão em planejamento", + content="A candidata dilma roussef já começa o teu planejamento", is_active=False, ).save() @@ -3525,8 +3528,8 @@ class TestQueryset(unittest.TestCase): Product(product_id=2).save() Product(product_id=1).save() - assert set(Product.objects.distinct("product_id")) == set([1, 2]) - assert set(Product.objects.distinct("pid")) == set([1, 2]) + assert set(Product.objects.distinct("product_id")) == {1, 2} + assert set(Product.objects.distinct("pid")) == {1, 2} Product.drop_collection() @@ -4222,15 +4225,15 @@ class TestQueryset(unittest.TestCase): ulist = list(UserDoc.objects.scalar("name", "age")) assert ulist == [ - (u"Wilson Jr", 19), - (u"Wilson", 43), - (u"Eliana", 37), - (u"Tayza", 15), + ("Wilson Jr", 19), + ("Wilson", 43), + ("Eliana", 37), + ("Tayza", 15), ] ulist = list(UserDoc.objects.scalar("name").order_by("age")) - assert ulist == [(u"Tayza"), (u"Wilson Jr"), (u"Eliana"), (u"Wilson")] + assert ulist == [("Tayza"), ("Wilson Jr"), ("Eliana"), ("Wilson")] def test_scalar_embedded(self): class Profile(EmbeddedDocument): @@ -4269,7 +4272,7 @@ class TestQueryset(unittest.TestCase): assert list( Person.objects.order_by("profile__age").scalar("profile__name") - ) == [u"Wilson Jr", u"Gabriel Falcao", u"Lincoln de souza", u"Walter cruz"] + ) == ["Wilson Jr", "Gabriel Falcao", "Lincoln de souza", "Walter cruz"] ulist = list( Person.objects.order_by("locale.city").scalar( @@ -4277,10 +4280,10 @@ class TestQueryset(unittest.TestCase): ) ) assert ulist == [ - (u"Lincoln de souza", 28, u"Belo Horizonte"), - (u"Walter cruz", 30, u"Brasilia"), - (u"Wilson Jr", 19, u"Corumba-GO"), - (u"Gabriel Falcao", 23, u"New York"), + ("Lincoln de souza", 28, "Belo Horizonte"), + ("Walter cruz", 30, "Brasilia"), + ("Wilson Jr", 19, "Corumba-GO"), + ("Gabriel Falcao", 23, "New York"), ] def test_scalar_decimal(self): @@ -4294,7 +4297,7 @@ class TestQueryset(unittest.TestCase): Person(name="Wilson Jr", rating=Decimal("1.0")).save() ulist = list(Person.objects.scalar("name", "rating")) - assert ulist == [(u"Wilson Jr", Decimal("1.0"))] + assert ulist == [("Wilson Jr", Decimal("1.0"))] def test_scalar_reference_field(self): class State(Document): @@ -4313,7 +4316,7 @@ class TestQueryset(unittest.TestCase): Person(name="Wilson JR", state=s1).save() plist = list(Person.objects.scalar("name", "state")) - assert plist == [(u"Wilson JR", s1)] + assert plist == [("Wilson JR", s1)] def test_scalar_generic_reference_field(self): class State(Document): @@ -4332,7 +4335,7 @@ class TestQueryset(unittest.TestCase): Person(name="Wilson JR", state=s1).save() plist = list(Person.objects.scalar("name", "state")) - assert plist == [(u"Wilson JR", s1)] + assert plist == [("Wilson JR", s1)] def test_generic_reference_field_with_only_and_as_pymongo(self): class TestPerson(Document): @@ -4863,13 +4866,11 @@ class TestQueryset(unittest.TestCase): ) results = User.objects.as_pymongo() - assert set(results[0].keys()) == set(["_id", "name", "age", "price"]) - assert set(results[1].keys()) == set( - ["_id", "name", "age", "price", "last_login"] - ) + assert set(results[0].keys()) == {"_id", "name", "age", "price"} + assert set(results[1].keys()) == {"_id", "name", "age", "price", "last_login"} results = User.objects.only("id", "name").as_pymongo() - assert set(results[0].keys()) == set(["_id", "name"]) + assert set(results[0].keys()) == {"_id", "name"} users = User.objects.only("name", "price").as_pymongo() results = list(users) @@ -5501,12 +5502,12 @@ class TestQueryset(unittest.TestCase): assert Person.objects._has_data(), "Cursor has data and returned False" def test_delete_count(self): - [self.Person(name="User {0}".format(i), age=i * 10).save() for i in range(1, 4)] + [self.Person(name=f"User {i}", age=i * 10).save() for i in range(1, 4)] assert ( self.Person.objects().delete() == 3 ) # test ordinary QuerySey delete count - [self.Person(name="User {0}".format(i), age=i * 10).save() for i in range(1, 4)] + [self.Person(name=f"User {i}", age=i * 10).save() for i in range(1, 4)] assert ( self.Person.objects().skip(1).delete() == 2 diff --git a/tests/queryset/test_queryset_aggregation.py b/tests/queryset/test_queryset_aggregation.py index 146501d0..a9c042de 100644 --- a/tests/queryset/test_queryset_aggregation.py +++ b/tests/queryset/test_queryset_aggregation.py @@ -64,7 +64,7 @@ class TestQuerysetAggregate(MongoDBTestCase): pipeline = [{"$match": {"name": "Isabella Luanna"}}] data = Person.objects().aggregate(pipeline) - assert list(data) == [{u"_id": p1.pk, u"age": 16, u"name": u"Isabella Luanna"}] + assert list(data) == [{"_id": p1.pk, "age": 16, "name": "Isabella Luanna"}] def test_queryset_aggregation_with_skip(self): class Person(Document): diff --git a/tests/queryset/test_transform.py b/tests/queryset/test_transform.py index 872a9a5d..e51683ae 100644 --- a/tests/queryset/test_transform.py +++ b/tests/queryset/test_transform.py @@ -328,7 +328,7 @@ class TestTransform(unittest.TestCase): word = Word(word="abc", index=1) update = transform.update(MainDoc, pull__content__text=word) assert update == { - "$pull": {"content.text": SON([("word", u"abc"), ("index", 1)])} + "$pull": {"content.text": SON([("word", "abc"), ("index", 1)])} } update = transform.update(MainDoc, pull__content__heading="xyz") diff --git a/tests/test_datastructures.py b/tests/test_datastructures.py index f4b63f05..1db5975d 100644 --- a/tests/test_datastructures.py +++ b/tests/test_datastructures.py @@ -6,7 +6,7 @@ from mongoengine import Document from mongoengine.base.datastructures import BaseDict, BaseList, StrictDict -class DocumentStub(object): +class DocumentStub: def __init__(self): self._changed_fields = [] self._unset_fields = [] diff --git a/tests/test_dereference.py b/tests/test_dereference.py index 88ea0033..640aed36 100644 --- a/tests/test_dereference.py +++ b/tests/test_dereference.py @@ -1321,7 +1321,7 @@ class FieldTest(unittest.TestCase): BrandGroup.drop_collection() brand1 = Brand(title="Moschino").save() - brand2 = Brand(title=u"Денис Симачёв").save() + brand2 = Brand(title="Денис Симачёв").save() BrandGroup(title="top_brands", brands=[brand1, brand2]).save() brand_groups = BrandGroup.objects().all() diff --git a/tests/test_utils.py b/tests/test_utils.py index dd178273..ca7defad 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -10,7 +10,7 @@ signal_output = [] class TestLazyRegexCompiler: def test_lazy_regex_compiler_verify_laziness_of_descriptor(self): - class UserEmail(object): + class UserEmail: EMAIL_REGEX = LazyRegexCompiler("@", flags=32) descriptor = UserEmail.__dict__["EMAIL_REGEX"] @@ -24,7 +24,7 @@ class TestLazyRegexCompiler: assert user_email.EMAIL_REGEX is UserEmail.EMAIL_REGEX def test_lazy_regex_compiler_verify_cannot_set_descriptor_on_instance(self): - class UserEmail(object): + class UserEmail: EMAIL_REGEX = LazyRegexCompiler("@") user_email = UserEmail() @@ -32,7 +32,7 @@ class TestLazyRegexCompiler: user_email.EMAIL_REGEX = re.compile("@") def test_lazy_regex_compiler_verify_can_override_class_attr(self): - class UserEmail(object): + class UserEmail: EMAIL_REGEX = LazyRegexCompiler("@") UserEmail.EMAIL_REGEX = re.compile("cookies") diff --git a/tests/utils.py b/tests/utils.py index 195b9dba..0899c208 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -59,7 +59,7 @@ def _decorated_with_ver_requirement(func, mongo_version_req, oper): return func(*args, **kwargs) pretty_version = ".".join(str(n) for n in mongo_version_req) - pytest.skip("Needs MongoDB v{}+".format(pretty_version)) + pytest.skip(f"Needs MongoDB v{pretty_version}+") _inner.__name__ = func.__name__ _inner.__doc__ = func.__doc__ From 8a1a68ea7c8e37aa225212f569ddd97fe51936c6 Mon Sep 17 00:00:00 2001 From: Bastien Gerard Date: Tue, 8 Dec 2020 23:52:47 +0100 Subject: [PATCH 4/6] fix flake8 warnings --- .pre-commit-config.yaml | 30 +++--- benchmarks/test_basic_doc_ops.py | 2 +- docs/conf.py | 2 +- mongoengine/__init__.py | 12 +-- mongoengine/base/datastructures.py | 4 +- mongoengine/base/document.py | 14 +-- mongoengine/base/metaclasses.py | 2 +- mongoengine/dereference.py | 4 +- mongoengine/fields.py | 2 +- setup.cfg | 2 +- setup.py | 2 +- tests/document/test_class_methods.py | 2 +- tests/document/test_inheritance.py | 13 +-- tests/document/test_validation.py | 5 +- tests/fields/test_complex_datetime_field.py | 2 +- tests/fields/test_email_field.py | 4 +- tests/fields/test_fields.py | 4 +- tests/fields/test_file_field.py | 2 +- tests/fields/test_sequence_field.py | 4 +- tests/queryset/test_pickable.py | 5 - tests/queryset/test_queryset.py | 17 ++-- tests/test_common.py | 2 - tests/test_context_managers.py | 4 +- tests/test_datastructures.py | 2 +- tests/test_dereference.py | 102 ++++++++++---------- tests/test_utils.py | 1 - 26 files changed, 110 insertions(+), 135 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 025e3b9e..730fcb2b 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,17 +1,17 @@ fail_fast: false repos: - - repo: https://github.com/ambv/black - rev: 20.8b1 - hooks: - - id: black - - repo: https://gitlab.com/pycqa/flake8 - rev: 3.8.0a2 - hooks: - - id: flake8 - additional_dependencies: - - flake8-import-order - - repo: https://github.com/asottile/pyupgrade - rev: v2.7.4 - hooks: - - id: pyupgrade - args: [--py36-plus] \ No newline at end of file + - repo: https://github.com/ambv/black + rev: 20.8b1 + hooks: + - id: black + - repo: https://gitlab.com/pycqa/flake8 + rev: 3.8.0a2 + hooks: + - id: flake8 + additional_dependencies: + - flake8-import-order + - repo: https://github.com/asottile/pyupgrade + rev: v2.7.4 + hooks: + - id: pyupgrade + args: [--py36-plus] diff --git a/benchmarks/test_basic_doc_ops.py b/benchmarks/test_basic_doc_ops.py index e840f97a..91efc7e3 100644 --- a/benchmarks/test_basic_doc_ops.py +++ b/benchmarks/test_basic_doc_ops.py @@ -45,7 +45,7 @@ def test_basic(): print( "Doc setattr: %.3fus" - % (timeit(lambda: setattr(b, "name", "New name"), 10000) * 10 ** 6) + % (timeit(lambda: setattr(b, "name", "New name"), 10000) * 10 ** 6) # noqa B010 ) print("Doc to mongo: %.3fus" % (timeit(b.to_mongo, 1000) * 10 ** 6)) diff --git a/docs/conf.py b/docs/conf.py index 299959ee..f8a4999a 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -42,7 +42,7 @@ master_doc = "index" # General information about the project. project = "MongoEngine" -copyright = "2009, MongoEngine Authors" +copyright = "2009, MongoEngine Authors" # noqa: A001 # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the diff --git a/mongoengine/__init__.py b/mongoengine/__init__.py index d0a0f1f4..93b0edd0 100644 --- a/mongoengine/__init__.py +++ b/mongoengine/__init__.py @@ -10,12 +10,12 @@ from mongoengine import signals # mongoengine, e.g. instead of `from mongoengine.connection import connect`, # users can simply use `from mongoengine import connect`, or even # `from mongoengine import *` and then `connect('testdb')`. -from mongoengine.connection import * -from mongoengine.document import * -from mongoengine.errors import * -from mongoengine.fields import * -from mongoengine.queryset import * -from mongoengine.signals import * +from mongoengine.connection import * # noqa: F401 +from mongoengine.document import * # noqa: F401 +from mongoengine.errors import * # noqa: F401 +from mongoengine.fields import * # noqa: F401 +from mongoengine.queryset import * # noqa: F401 +from mongoengine.signals import * # noqa: F401 __all__ = ( diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index 0f2f8a49..a32f6040 100644 --- a/mongoengine/base/datastructures.py +++ b/mongoengine/base/datastructures.py @@ -180,9 +180,7 @@ class BaseList(list): def _mark_as_changed(self, key=None): if hasattr(self._instance, "_mark_as_changed"): if key is not None: - self._instance._mark_as_changed( - "{}.{}".format(self._name, key % len(self)) - ) + self._instance._mark_as_changed(f"{self._name}.{key % len(self)}") else: self._instance._mark_as_changed(self._name) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index 45acfa3d..f64b578b 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -89,9 +89,7 @@ class BaseDocument: list(self._fields.keys()) + ["id", "pk", "_cls", "_text_score"] ) if _undefined_fields: - msg = ('The fields "{}" do not exist on the document "{}"').format( - _undefined_fields, self._class_name - ) + msg = f'The fields "{_undefined_fields}" do not exist on the document "{self._class_name}"' raise FieldDoesNotExist(msg) if self.STRICT and not self._dynamic: @@ -231,10 +229,10 @@ class BaseDocument: setattr(self, k, data[k]) if "_fields_ordered" in data: if self._dynamic: - setattr(self, "_fields_ordered", data["_fields_ordered"]) + self._fields_ordered = data["_fields_ordered"] else: _super_fields_ordered = type(self)._fields_ordered - setattr(self, "_fields_ordered", _super_fields_ordered) + self._fields_ordered = _super_fields_ordered dynamic_fields = data.get("_dynamic_fields") or SON() for k in dynamic_fields.keys(): @@ -576,7 +574,7 @@ class BaseDocument: else: iterator = data.items() - for index_or_key, value in iterator: + for _index_or_key, value in iterator: if hasattr(value, "_get_changed_fields") and not isinstance( value, Document ): # don't follow references @@ -999,9 +997,7 @@ class BaseDocument: "PolygonField", ) - geo_field_types = tuple( - [_import_class(field) for field in geo_field_type_names] - ) + geo_field_types = tuple(_import_class(field) for field in geo_field_type_names) for field in cls._fields.values(): if not isinstance(field, geo_field_types): diff --git a/mongoengine/base/metaclasses.py b/mongoengine/base/metaclasses.py index 67a5f112..f3a6903d 100644 --- a/mongoengine/base/metaclasses.py +++ b/mongoengine/base/metaclasses.py @@ -337,7 +337,7 @@ class TopLevelDocumentMetaclass(DocumentMetaclass): # allow_inheritance to False. If the base Document allows inheritance, # none of its subclasses can override allow_inheritance to False. simple_class = all( - [b._meta.get("abstract") for b in flattened_bases if hasattr(b, "_meta")] + b._meta.get("abstract") for b in flattened_bases if hasattr(b, "_meta") ) if ( not simple_class diff --git a/mongoengine/dereference.py b/mongoengine/dereference.py index 3cd200ea..d63e24fd 100644 --- a/mongoengine/dereference.py +++ b/mongoengine/dereference.py @@ -51,10 +51,10 @@ class DeReference: doc_type = doc_type.document_type is_list = not hasattr(items, "items") - if is_list and all([i.__class__ == doc_type for i in items]): + if is_list and all(i.__class__ == doc_type for i in items): return items elif not is_list and all( - [i.__class__ == doc_type for i in items.values()] + i.__class__ == doc_type for i in items.values() ): return items elif not field.dbref: diff --git a/mongoengine/fields.py b/mongoengine/fields.py index f1d854af..abfe262c 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -1743,7 +1743,7 @@ class GridFSProxy: def __str__(self): gridout = self.get() - filename = getattr(gridout, "filename") if gridout else "" + filename = gridout.filename if gridout else "" return f"<{self.__class__.__name__}: {filename} ({self.grid_id})>" def __eq__(self, other): diff --git a/setup.cfg b/setup.cfg index ae1b4f7e..216e3dfe 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,5 +1,5 @@ [flake8] -ignore=E501,F401,F403,F405,I201,I202,W504, W605, W503 +ignore=E501,F403,F405,I201,I202,W504,W605,W503,B007 exclude=build,dist,docs,venv,venv3,.tox,.eggs,tests max-complexity=47 application-import-names=mongoengine,tests diff --git a/setup.py b/setup.py index 80819b13..a07e0e58 100644 --- a/setup.py +++ b/setup.py @@ -7,7 +7,7 @@ from setuptools.command.test import test as TestCommand # Hack to silence atexit traceback in newer python versions try: - import multiprocessing + import multiprocessing # noqa: F401 except ImportError: pass diff --git a/tests/document/test_class_methods.py b/tests/document/test_class_methods.py index e20a5802..4c35b796 100644 --- a/tests/document/test_class_methods.py +++ b/tests/document/test_class_methods.py @@ -29,7 +29,7 @@ class TestClassMethods(unittest.TestCase): """Ensure that document may be defined using fields.""" assert ["_cls", "age", "id", "name"] == sorted(self.Person._fields.keys()) assert ["IntField", "ObjectIdField", "StringField", "StringField"] == sorted( - [x.__class__.__name__ for x in self.Person._fields.values()] + x.__class__.__name__ for x in self.Person._fields.values() ) def test_get_db(self): diff --git a/tests/document/test_inheritance.py b/tests/document/test_inheritance.py index fdeb4052..550a4bdf 100644 --- a/tests/document/test_inheritance.py +++ b/tests/document/test_inheritance.py @@ -280,7 +280,7 @@ class TestInheritance(MongoDBTestCase): C.ensure_indexes() assert sorted( - [idx["key"] for idx in C._get_collection().index_information().values()] + idx["key"] for idx in C._get_collection().index_information().values() ) == sorted([[("_cls", 1), ("b", 1)], [("_id", 1)], [("_cls", 1), ("a", 1)]]) def test_polymorphic_queries(self): @@ -467,7 +467,7 @@ class TestInheritance(MongoDBTestCase): assert city.pk is None # TODO: expected error? Shouldn't we create a new error type? with pytest.raises(KeyError): - setattr(city, "pk", 1) + city.pk = 1 def test_allow_inheritance_embedded_document(self): """Ensure embedded documents respect inheritance.""" @@ -499,13 +499,8 @@ class TestInheritance(MongoDBTestCase): class DateUpdatedDocument(Document): meta = {"allow_inheritance": True, "abstract": True} - try: - - class MyDocument(DateCreatedDocument, DateUpdatedDocument): - pass - - except Exception: - assert False, "Couldn't create MyDocument class" + class MyDocument(DateCreatedDocument, DateUpdatedDocument): + pass def test_abstract_documents(self): """Ensure that a document superclass can be marked as abstract diff --git a/tests/document/test_validation.py b/tests/document/test_validation.py index 104eb693..40134348 100644 --- a/tests/document/test_validation.py +++ b/tests/document/test_validation.py @@ -210,10 +210,7 @@ class TestValidatorError(MongoDBTestCase): child.reference = parent # Saving the child should not raise a ValidationError - try: - child.save() - except ValidationError as e: - self.fail("ValidationError raised: %s" % e.message) + child.save() if __name__ == "__main__": diff --git a/tests/fields/test_complex_datetime_field.py b/tests/fields/test_complex_datetime_field.py index d8ae9175..aa1624d1 100644 --- a/tests/fields/test_complex_datetime_field.py +++ b/tests/fields/test_complex_datetime_field.py @@ -60,7 +60,7 @@ class ComplexDateTimeFieldTest(MongoDBTestCase): assert log == log1 # Test string padding - microsecond = map(int, [math.pow(10, x) for x in range(6)]) + 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): diff --git a/tests/fields/test_email_field.py b/tests/fields/test_email_field.py index 974360ef..762e06d6 100644 --- a/tests/fields/test_email_field.py +++ b/tests/fields/test_email_field.py @@ -1,8 +1,6 @@ -import sys - import pytest -from mongoengine import * +from mongoengine import Document, EmailField, ValidationError from tests.utils import MongoDBTestCase diff --git a/tests/fields/test_fields.py b/tests/fields/test_fields.py index ce16a904..266d0e9d 100644 --- a/tests/fields/test_fields.py +++ b/tests/fields/test_fields.py @@ -1357,9 +1357,9 @@ class TestField(MongoDBTestCase): foo.delete() bar = Bar.objects.get() with pytest.raises(DoesNotExist): - getattr(bar, "ref") + bar.ref with pytest.raises(DoesNotExist): - getattr(bar, "generic_ref") + bar.generic_ref # When auto_dereference is disabled, there is no trouble returning DBRef bar = Bar.objects.get() diff --git a/tests/fields/test_file_field.py b/tests/fields/test_file_field.py index 9a20c917..b45db3f9 100644 --- a/tests/fields/test_file_field.py +++ b/tests/fields/test_file_field.py @@ -11,7 +11,7 @@ from mongoengine import * from mongoengine.connection import get_db try: - from PIL import Image + from PIL import Image # noqa: F401 HAS_PIL = True except ImportError: diff --git a/tests/fields/test_sequence_field.py b/tests/fields/test_sequence_field.py index b6b2917f..53e69f7b 100644 --- a/tests/fields/test_sequence_field.py +++ b/tests/fields/test_sequence_field.py @@ -166,8 +166,8 @@ class TestSequenceField(MongoDBTestCase): ids = [i.id for i in Person.objects] assert ids == list(range(1, 11)) - id = [i.id for i in Animal.objects] - assert id == list(range(1, 11)) + _id = [i.id for i in Animal.objects] + assert _id == list(range(1, 11)) c = self.db["mongoengine.counters"].find_one({"_id": "person.id"}) assert c["next"] == 10 diff --git a/tests/queryset/test_pickable.py b/tests/queryset/test_pickable.py index d20db32e..7aa244e5 100644 --- a/tests/queryset/test_pickable.py +++ b/tests/queryset/test_pickable.py @@ -1,8 +1,6 @@ import pickle -import unittest from mongoengine import Document, IntField, StringField -from mongoengine.connection import connect from tests.utils import MongoDBTestCase @@ -22,14 +20,11 @@ class TestQuerysetPickable(MongoDBTestCase): self.john = Person.objects.create(name="John", age=21) def test_picke_simple_qs(self): - qs = Person.objects.all() - pickle.dumps(qs) def _get_loaded(self, qs): s = pickle.dumps(qs) - return pickle.loads(s) def test_unpickle(self): diff --git a/tests/queryset/test_queryset.py b/tests/queryset/test_queryset.py index c75f2f10..079447bc 100644 --- a/tests/queryset/test_queryset.py +++ b/tests/queryset/test_queryset.py @@ -5,7 +5,6 @@ from decimal import Decimal from bson import DBRef, ObjectId import pymongo -from pymongo.read_concern import ReadConcern from pymongo.read_preferences import ReadPreference from pymongo.results import UpdateResult import pytest @@ -449,7 +448,7 @@ class TestQueryset(unittest.TestCase): # test iterating over the result set cnt = 0 - for a in A.objects.batch_size(10): + for _ in A.objects.batch_size(10): cnt += 1 assert cnt == 100 @@ -457,7 +456,7 @@ class TestQueryset(unittest.TestCase): qs = A.objects.all() qs = qs.limit(10).batch_size(20).skip(91) cnt = 0 - for a in qs: + for _ in qs: cnt += 1 assert cnt == 9 @@ -1146,7 +1145,7 @@ class TestQueryset(unittest.TestCase): people2 = [person for person in queryset] # Check that it still works even if iteration is interrupted. - for person in queryset: + for _person in queryset: break people3 = [person for person in queryset] @@ -1182,7 +1181,7 @@ class TestQueryset(unittest.TestCase): assert "[, , ]" == "%s" % docs assert docs.count(with_limit_and_skip=True) == 3 - for doc in docs: + for _ in docs: assert ".. queryset mid-iteration .." == repr(docs) def test_regex_query_shortcuts(self): @@ -3171,10 +3170,10 @@ class TestQueryset(unittest.TestCase): Test.drop_collection() - for i in range(50): + for _ in range(50): Test(val=1).save() - for i in range(20): + for _ in range(20): Test(val=2).save() freqs = Test.objects.item_frequencies("val", map_reduce=False, normalize=True) @@ -3207,7 +3206,7 @@ class TestQueryset(unittest.TestCase): for i, weight in enumerate(ages): self.Person( - name="test meta%i", person_meta=self.PersonMeta(weight=weight) + name=f"test meta{i}", person_meta=self.PersonMeta(weight=weight) ).save() assert ( @@ -3246,7 +3245,7 @@ class TestQueryset(unittest.TestCase): # test summing over a filtered queryset assert self.Person.objects.filter(age__gte=50).sum("age") == sum( - [a for a in ages if a >= 50] + a for a in ages if a >= 50 ) def test_sum_over_db_field(self): diff --git a/tests/test_common.py b/tests/test_common.py index 1779a91b..d4122863 100644 --- a/tests/test_common.py +++ b/tests/test_common.py @@ -1,5 +1,3 @@ -import unittest - import pytest from mongoengine import Document diff --git a/tests/test_context_managers.py b/tests/test_context_managers.py index 6599c7f2..4ea7fa5a 100644 --- a/tests/test_context_managers.py +++ b/tests/test_context_managers.py @@ -180,11 +180,11 @@ class TestContextManagers: with no_dereference(Group) as Group: group = Group.objects.first() - assert all([not isinstance(m, User) for m in group.members]) + assert all(not isinstance(m, User) for m in group.members) assert not isinstance(group.ref, User) assert not isinstance(group.generic, User) - assert all([isinstance(m, User) for m in group.members]) + assert all(isinstance(m, User) for m in group.members) assert isinstance(group.ref, User) assert isinstance(group.generic, User) diff --git a/tests/test_datastructures.py b/tests/test_datastructures.py index 1db5975d..931a1f6e 100644 --- a/tests/test_datastructures.py +++ b/tests/test_datastructures.py @@ -421,7 +421,7 @@ class TestStrictDict(unittest.TestCase): d.a = 1 assert d.a == 1 with pytest.raises(AttributeError): - getattr(d, "b") + d.b def test_setattr_raises_on_nonexisting_attr(self): d = self.dtype() diff --git a/tests/test_dereference.py b/tests/test_dereference.py index 640aed36..bddcc543 100644 --- a/tests/test_dereference.py +++ b/tests/test_dereference.py @@ -49,7 +49,7 @@ class FieldTest(unittest.TestCase): len(group_obj.members) assert q == 2 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 # Document select_related @@ -58,7 +58,7 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first().select_related() assert q == 2 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 # Queryset select_related @@ -67,7 +67,7 @@ class FieldTest(unittest.TestCase): group_objs = Group.objects.select_related() assert q == 2 for group_obj in group_objs: - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 User.drop_collection() @@ -99,14 +99,14 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 assert group_obj._data["members"]._dereferenced # verifies that no additional queries gets executed # if we re-iterate over the ListField once it is # dereferenced - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 assert group_obj._data["members"]._dereferenced @@ -117,7 +117,7 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first().select_related() assert q == 2 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 # Queryset select_related @@ -126,7 +126,7 @@ class FieldTest(unittest.TestCase): group_objs = Group.objects.select_related() assert q == 2 for group_obj in group_objs: - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 def test_list_item_dereference_orphan_dbref(self): @@ -158,14 +158,14 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 assert group_obj._data["members"]._dereferenced # verifies that no additional queries gets executed # if we re-iterate over the ListField once it is # dereferenced - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 assert group_obj._data["members"]._dereferenced @@ -505,10 +505,10 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 for m in group_obj.members: @@ -521,10 +521,10 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first().select_related() assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 for m in group_obj.members: @@ -538,10 +538,10 @@ class FieldTest(unittest.TestCase): assert q == 4 for group_obj in group_objs: - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 for m in group_obj.members: @@ -592,11 +592,11 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 assert group_obj._data["members"]._dereferenced - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 assert group_obj._data["members"]._dereferenced @@ -648,10 +648,10 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 for m in group_obj.members: @@ -664,10 +664,10 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first().select_related() assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 for m in group_obj.members: @@ -681,10 +681,10 @@ class FieldTest(unittest.TestCase): assert q == 4 for group_obj in group_objs: - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 for m in group_obj.members: @@ -723,10 +723,10 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 - for k, m in group_obj.members.items(): + for _, m in group_obj.members.items(): assert isinstance(m, User) # Document select_related @@ -736,7 +736,7 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first().select_related() assert q == 2 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 for k, m in group_obj.members.items(): @@ -750,7 +750,7 @@ class FieldTest(unittest.TestCase): assert q == 2 for group_obj in group_objs: - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 for k, m in group_obj.members.items(): @@ -801,10 +801,10 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 for k, m in group_obj.members.items(): @@ -817,10 +817,10 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first().select_related() assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 for k, m in group_obj.members.items(): @@ -834,10 +834,10 @@ class FieldTest(unittest.TestCase): assert q == 4 for group_obj in group_objs: - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 for k, m in group_obj.members.items(): @@ -852,7 +852,7 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 1 assert group_obj.members == {} @@ -891,10 +891,10 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 for k, m in group_obj.members.items(): @@ -907,10 +907,10 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first().select_related() assert q == 2 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 for k, m in group_obj.members.items(): @@ -924,13 +924,13 @@ class FieldTest(unittest.TestCase): assert q == 2 for group_obj in group_objs: - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 2 - for k, m in group_obj.members.items(): + for _, m in group_obj.members.items(): assert isinstance(m, UserA) UserA.drop_collection() @@ -978,13 +978,13 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - for k, m in group_obj.members.items(): + for _, m in group_obj.members.items(): assert "User" in m.__class__.__name__ # Document select_related @@ -994,13 +994,13 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first().select_related() assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - for k, m in group_obj.members.items(): + for _, m in group_obj.members.items(): assert "User" in m.__class__.__name__ # Queryset select_related @@ -1011,13 +1011,13 @@ class FieldTest(unittest.TestCase): assert q == 4 for group_obj in group_objs: - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 4 - for k, m in group_obj.members.items(): + for _, m in group_obj.members.items(): assert "User" in m.__class__.__name__ Group.objects.delete() @@ -1029,7 +1029,7 @@ class FieldTest(unittest.TestCase): group_obj = Group.objects.first() assert q == 1 - [m for m in group_obj.members] + _ = [m for m in group_obj.members] assert q == 1 UserA.drop_collection() diff --git a/tests/test_utils.py b/tests/test_utils.py index ca7defad..a97645ae 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,5 +1,4 @@ import re -import unittest import pytest From bf12621ce9ee0006a7d3a2d5d18cac8a26dbc88b Mon Sep 17 00:00:00 2001 From: Bastien Gerard Date: Sat, 12 Dec 2020 22:33:48 +0100 Subject: [PATCH 5/6] update flake8 version in pre-commit --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 730fcb2b..066385a2 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -5,7 +5,7 @@ repos: hooks: - id: black - repo: https://gitlab.com/pycqa/flake8 - rev: 3.8.0a2 + rev: 3.8.4 hooks: - id: flake8 additional_dependencies: From 149fb953e70808602a0235c1039691f8ff09755f Mon Sep 17 00:00:00 2001 From: Bastien Gerard Date: Sun, 13 Dec 2020 00:16:10 +0100 Subject: [PATCH 6/6] fix recent update not aligned with latest black --- mongoengine/base/fields.py | 3 +-- mongoengine/fields.py | 16 +++++----------- mongoengine/queryset/base.py | 6 ++---- mongoengine/queryset/queryset.py | 9 +++------ 4 files changed, 11 insertions(+), 23 deletions(-) diff --git a/mongoengine/base/fields.py b/mongoengine/base/fields.py index 61dde5d2..ca01d00d 100644 --- a/mongoengine/base/fields.py +++ b/mongoengine/base/fields.py @@ -514,8 +514,7 @@ class ObjectIdField(BaseField): class GeoJsonBaseField(BaseField): - """A geo json field storing a geojson style object. - """ + """A geo json field storing a geojson style object.""" _geo_index = pymongo.GEOSPHERE _type = "GeoBase" diff --git a/mongoengine/fields.py b/mongoengine/fields.py index abfe262c..e29f55ab 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -197,9 +197,7 @@ class URLField(StringField): class EmailField(StringField): - """A field that validates input as an email address. - - """ + """A field that validates input as an email address.""" USER_REGEX = LazyRegexCompiler( # `dot-atom` defined in RFC 5322 Section 3.2.3. @@ -1299,8 +1297,7 @@ class ReferenceField(BaseField): class CachedReferenceField(BaseField): - """A referencefield with cache fields to purpose pseudo-joins - """ + """A referencefield with cache fields to purpose pseudo-joins""" def __init__(self, document_type, fields=None, auto_sync=True, **kwargs): """Initialises the Cached Reference Field. @@ -1680,8 +1677,7 @@ class GridFSError(Exception): class GridFSProxy: - """Proxy object to handle writing and reading of files to and from GridFS - """ + """Proxy object to handle writing and reading of files to and from GridFS""" _fs = None @@ -1843,8 +1839,7 @@ class GridFSProxy: class FileField(BaseField): - """A GridFS storage field. - """ + """A GridFS storage field.""" proxy_class = GridFSProxy @@ -2219,8 +2214,7 @@ class SequenceField(BaseField): class UUIDField(BaseField): - """A UUID field. - """ + """A UUID field.""" _binary = None diff --git a/mongoengine/queryset/base.py b/mongoengine/queryset/base.py index 1f29cdf7..66a4c37a 100644 --- a/mongoengine/queryset/base.py +++ b/mongoengine/queryset/base.py @@ -281,8 +281,7 @@ class BaseQuerySet: ) def create(self, **kwargs): - """Create new object. Returns the saved object instance. - """ + """Create new object. Returns the saved object instance.""" return self._document(**kwargs).save(force_insert=True) def first(self): @@ -1579,8 +1578,7 @@ class BaseQuerySet: return doc def rewind(self): - """Rewind the cursor to its unevaluated state. - """ + """Rewind the cursor to its unevaluated state.""" self._iter = False self._cursor.rewind() diff --git a/mongoengine/queryset/queryset.py b/mongoengine/queryset/queryset.py index 397fe464..49f2724c 100644 --- a/mongoengine/queryset/queryset.py +++ b/mongoengine/queryset/queryset.py @@ -150,8 +150,7 @@ class QuerySet(BaseQuerySet): return self._len def no_cache(self): - """Convert to a non-caching queryset - """ + """Convert to a non-caching queryset""" if self._result_cache is not None: raise OperationError("QuerySet already cached") @@ -162,13 +161,11 @@ class QuerySetNoCache(BaseQuerySet): """A non caching QuerySet""" def cache(self): - """Convert to a caching queryset - """ + """Convert to a caching queryset""" return self._clone_into(QuerySet(self._document, self._collection)) def __repr__(self): - """Provides the string representation of the QuerySet - """ + """Provides the string representation of the QuerySet""" if self._iter: return ".. queryset mid-iteration .."