pub/mongoengine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

autoformat with pyupgrade

Browse Source
This commit is contained in:
Bastien Gerard 2020-12-08 23:14:33 +01:00
parent c00a378776
commit eabb8f60f5
36 changed files with 207 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.pre-commit-config.yaml
View File

@ -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]

4
docs/conf.py
View File

@ -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

14
mongoengine/base/datastructures.py
View File

@ -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 "<LazyReference({}, {!r})>".format(self.document_type, self.pk)
return f"<LazyReference({self.document_type}, {self.pk!r})>"

23
mongoengine/base/document.py
View File

@ -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

8
mongoengine/base/fields.py
View File

@ -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(

4
mongoengine/base/metaclasses.py
View File

@ -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

8
mongoengine/connection.py
View File

@ -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):

4
mongoengine/dereference.py
View File

@ -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
)

8
mongoengine/errors.py
View File

@ -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):

24
mongoengine/fields.py
View File

@ -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 "<no file>"
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.

12
mongoengine/queryset/base.py
View File

@ -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 = (

6
tests/document/test_class_methods.py
View File

@ -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):

2
tests/document/test_delta.py
View File

@ -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()

12
tests/document/test_dynamic.py
View File

@ -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"""

4
tests/document/test_inheritance.py
View File

@ -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"""

26
tests/document/test_instance.py
View File

@ -168,7 +168,7 @@ class TestDocumentInstance(MongoDBTestCase):
def __unicode__(self):
return self.title
doc = Article(title=u"привет мир")
doc = Article(title="привет мир")
assert "<Article: привет мир>" == repr(doc)
@ -181,7 +181,7 @@ class TestDocumentInstance(MongoDBTestCase):
def __str__(self):
return None
doc = Article(title=u"привет мир")
doc = Article(title="привет мир")
assert "<Article: None>" == 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")

12
tests/fields/test_binary_field.py
View File

@ -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(

12
tests/fields/test_cached_reference_field.py
View File

@ -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):

8
tests/fields/test_email_field.py
View File

@ -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):

8
tests/fields/test_embedded_document_field.py
View File

@ -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

26
tests/fields/test_fields.py
View File

@ -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):
"""

40
tests/fields/test_file_field.py
View File

@ -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()

2
tests/fields/test_geo_fields.py
View File

@ -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"]

6
tests/fields/test_map_field.py
View File

@ -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: éééé"
)

2
tests/fields/test_reference_field.py
View File

@ -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):

4
tests/fields/test_url_field.py
View File

@ -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):

2
tests/fixtures.py
View File

@ -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()

4
tests/queryset/test_geo.py
View File

@ -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):

2
tests/queryset/test_pickable.py
View File

@ -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):

111
tests/queryset/test_queryset.py
View File

@ -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

2
tests/queryset/test_queryset_aggregation.py
View File

@ -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):

2
tests/queryset/test_transform.py
View File

@ -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")

2
tests/test_datastructures.py
View File

@ -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 = []

2
tests/test_dereference.py
View File

@ -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()

6
tests/test_utils.py
View File

@ -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")

2
tests/utils.py
View File

@ -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__