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

run pyupgrade

Browse Source
This commit is contained in:
Bastien Gérard 2020-03-11 23:21:38 +01:00
parent 8086576677
commit b234aa48e4
12 changed files with 54 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
mongoengine/base/datastructures.py
View File

@ -67,11 +67,11 @@ class BaseDict(dict):
if isinstance(value, EmbeddedDocument) and value._instance is None: if isinstance(value, EmbeddedDocument) and value._instance is None:
value._instance = self._instance value._instance = self._instance
elif isinstance(value, dict) and not isinstance(value, BaseDict): elif isinstance(value, dict) and not isinstance(value, BaseDict):
value = BaseDict(value, None, "%s.%s" % (self._name, key)) value = BaseDict(value, None, "{}.{}".format(self._name, key))
super(BaseDict, self).__setitem__(key, value) super(BaseDict, self).__setitem__(key, value)
value._instance = self._instance value._instance = self._instance
elif isinstance(value, list) and not isinstance(value, BaseList): elif isinstance(value, list) and not isinstance(value, BaseList):
value = BaseList(value, None, "%s.%s" % (self._name, key)) value = BaseList(value, None, "{}.{}".format(self._name, key))
super(BaseDict, self).__setitem__(key, value) super(BaseDict, self).__setitem__(key, value)
value._instance = self._instance value._instance = self._instance
return value return value
@ -97,7 +97,7 @@ class BaseDict(dict):
def _mark_as_changed(self, key=None): def _mark_as_changed(self, key=None):
if hasattr(self._instance, "_mark_as_changed"): if hasattr(self._instance, "_mark_as_changed"):
if key: if key:
self._instance._mark_as_changed("%s.%s" % (self._name, key)) self._instance._mark_as_changed("{}.{}".format(self._name, key))
else: else:
self._instance._mark_as_changed(self._name) self._instance._mark_as_changed(self._name)
@ -133,12 +133,12 @@ class BaseList(list):
value._instance = self._instance value._instance = self._instance
elif isinstance(value, dict) and not isinstance(value, BaseDict): elif isinstance(value, dict) and not isinstance(value, BaseDict):
# Replace dict by BaseDict # Replace dict by BaseDict
value = BaseDict(value, None, "%s.%s" % (self._name, key)) value = BaseDict(value, None, "{}.{}".format(self._name, key))
super(BaseList, self).__setitem__(key, value) super(BaseList, self).__setitem__(key, value)
value._instance = self._instance value._instance = self._instance
elif isinstance(value, list) and not isinstance(value, BaseList): elif isinstance(value, list) and not isinstance(value, BaseList):
# Replace list by BaseList # Replace list by BaseList
value = BaseList(value, None, "%s.%s" % (self._name, key)) value = BaseList(value, None, "{}.{}".format(self._name, key))
super(BaseList, self).__setitem__(key, value) super(BaseList, self).__setitem__(key, value)
value._instance = self._instance value._instance = self._instance
return value return value
@ -181,7 +181,9 @@ class BaseList(list):
def _mark_as_changed(self, key=None): def _mark_as_changed(self, key=None):
if hasattr(self._instance, "_mark_as_changed"): if hasattr(self._instance, "_mark_as_changed"):
if key: if key:
self._instance._mark_as_changed("%s.%s" % (self._name, key % len(self))) self._instance._mark_as_changed(
"{}.{}".format(self._name, key % len(self))
)
else: else:
self._instance._mark_as_changed(self._name) self._instance._mark_as_changed(self._name)
@ -428,7 +430,7 @@ class StrictDict(object):
def __repr__(self): def __repr__(self):
return "{%s}" % ", ".join( return "{%s}" % ", ".join(
'"{0!s}": {1!r}'.format(k, v) for k, v in self.items() '"{!s}": {!r}'.format(k, v) for k, v in self.items()
) )
cls._classes[allowed_keys] = SpecificStrictDict cls._classes[allowed_keys] = SpecificStrictDict
@ -473,4 +475,4 @@ class LazyReference(DBRef):
raise AttributeError() raise AttributeError()
def __repr__(self): def __repr__(self):
return "<LazyReference(%s, %r)>" % (self.document_type, self.pk) return "<LazyReference({}, {!r})>".format(self.document_type, self.pk)

26
mongoengine/base/document.py
View File

@ -93,7 +93,7 @@ class BaseDocument(object):
list(self._fields.keys()) + ["id", "pk", "_cls", "_text_score"] list(self._fields.keys()) + ["id", "pk", "_cls", "_text_score"]
) )
if _undefined_fields: if _undefined_fields:
msg = ('The fields "{0}" do not exist on the document "{1}"').format( msg = ('The fields "{}" do not exist on the document "{}"').format(
_undefined_fields, self._class_name _undefined_fields, self._class_name
) )
raise FieldDoesNotExist(msg) raise FieldDoesNotExist(msg)
@ -286,7 +286,7 @@ class BaseDocument(object):
except (UnicodeEncodeError, UnicodeDecodeError): except (UnicodeEncodeError, UnicodeDecodeError):
u = "[Bad Unicode data]" u = "[Bad Unicode data]"
repr_type = str if u is None else type(u) repr_type = str if u is None else type(u)
return repr_type("<%s: %s>" % (self.__class__.__name__, u)) return repr_type("<{}: {}>".format(self.__class__.__name__, u))
def __str__(self): def __str__(self):
# TODO this could be simpler? # TODO this could be simpler?
@ -441,7 +441,7 @@ class BaseDocument(object):
pk = self.pk pk = self.pk
elif self._instance and hasattr(self._instance, "pk"): elif self._instance and hasattr(self._instance, "pk"):
pk = self._instance.pk pk = self._instance.pk
message = "ValidationError (%s:%s) " % (self._class_name, pk) message = "ValidationError ({}:{}) ".format(self._class_name, pk)
raise ValidationError(message, errors=errors) raise ValidationError(message, errors=errors)
def to_json(self, *args, **kwargs): def to_json(self, *args, **kwargs):
@ -514,7 +514,7 @@ class BaseDocument(object):
if "." in key: if "." in key:
key, rest = key.split(".", 1) key, rest = key.split(".", 1)
key = self._db_field_map.get(key, key) key = self._db_field_map.get(key, key)
key = "%s.%s" % (key, rest) key = "{}.{}".format(key, rest)
else: else:
key = self._db_field_map.get(key, key) key = self._db_field_map.get(key, key)
@ -576,7 +576,7 @@ class BaseDocument(object):
iterator = data.items() iterator = data.items()
for index_or_key, value in iterator: for index_or_key, value in iterator:
item_key = "%s%s." % (base_key, index_or_key) item_key = "{}{}.".format(base_key, index_or_key)
# don't check anything lower if this key is already marked # don't check anything lower if this key is already marked
# as changed. # as changed.
if item_key[:-1] in changed_fields: if item_key[:-1] in changed_fields:
@ -584,7 +584,7 @@ class BaseDocument(object):
if hasattr(value, "_get_changed_fields"): if hasattr(value, "_get_changed_fields"):
changed = value._get_changed_fields() changed = value._get_changed_fields()
changed_fields += ["%s%s" % (item_key, k) for k in changed if k] changed_fields += ["{}{}".format(item_key, k) for k in changed if k]
elif isinstance(value, (list, tuple, dict)): elif isinstance(value, (list, tuple, dict)):
self._nestable_types_changed_fields(changed_fields, item_key, value) self._nestable_types_changed_fields(changed_fields, item_key, value)
@ -615,7 +615,7 @@ class BaseDocument(object):
if isinstance(data, EmbeddedDocument): if isinstance(data, EmbeddedDocument):
# Find all embedded fields that have been changed # Find all embedded fields that have been changed
changed = data._get_changed_fields() changed = data._get_changed_fields()
changed_fields += ["%s%s" % (key, k) for k in changed if k] changed_fields += ["{}{}".format(key, k) for k in changed if k]
elif isinstance(data, (list, tuple, dict)): elif isinstance(data, (list, tuple, dict)):
if hasattr(field, "field") and isinstance( if hasattr(field, "field") and isinstance(
field.field, (ReferenceField, GenericReferenceField) field.field, (ReferenceField, GenericReferenceField)
@ -769,11 +769,10 @@ class BaseDocument(object):
if errors_dict: if errors_dict:
errors = "\n".join( errors = "\n".join(
["Field '%s' - %s" % (k, v) for k, v in errors_dict.items()] ["Field '{}' - {}".format(k, v) for k, v in errors_dict.items()]
) )
msg = "Invalid data to create a `%s` instance.\n%s" % ( msg = "Invalid data to create a `{}` instance.\n{}".format(
cls._class_name, cls._class_name, errors,
errors,
) )
raise InvalidDocumentError(msg) raise InvalidDocumentError(msg)
@ -944,7 +943,8 @@ class BaseDocument(object):
# Add the new index to the list # Add the new index to the list
fields = [ fields = [
("%s%s" % (namespace, f), pymongo.ASCENDING) for f in unique_fields ("{}{}".format(namespace, f), pymongo.ASCENDING)
for f in unique_fields
] ]
index = {"fields": fields, "unique": True, "sparse": sparse} index = {"fields": fields, "unique": True, "sparse": sparse}
unique_indexes.append(index) unique_indexes.append(index)
@ -1001,7 +1001,7 @@ class BaseDocument(object):
elif field._geo_index: elif field._geo_index:
field_name = field.db_field field_name = field.db_field
if parent_field: if parent_field:
field_name = "%s.%s" % (parent_field, field_name) field_name = "{}.{}".format(parent_field, field_name)
geo_indices.append({"fields": [(field_name, field._geo_index)]}) geo_indices.append({"fields": [(field_name, field._geo_index)]})
return geo_indices return geo_indices

6
mongoengine/base/fields.py
View File

@ -474,7 +474,9 @@ class ComplexBaseField(BaseField):
if errors: if errors:
field_class = self.field.__class__.__name__ field_class = self.field.__class__.__name__
self.error("Invalid %s item (%s)" % (field_class, value), errors=errors) self.error(
"Invalid {} item ({})".format(field_class, value), errors=errors
)
# Don't allow empty values if required # Don't allow empty values if required
if self.required and not value: if self.required and not value:
self.error("Field is required and cannot be empty") self.error("Field is required and cannot be empty")
@ -546,7 +548,7 @@ class GeoJsonBaseField(BaseField):
if isinstance(value, dict): if isinstance(value, dict):
if set(value.keys()) == {"type", "coordinates"}: if set(value.keys()) == {"type", "coordinates"}:
if value["type"] != self._type: if value["type"] != self._type:
self.error('%s type must be "%s"' % (self._name, self._type)) self.error('{} type must be "{}"'.format(self._name, self._type))
return self.validate(value["coordinates"]) return self.validate(value["coordinates"])
else: else:
self.error( self.error(

21
mongoengine/base/metaclasses.py
View File

@ -168,23 +168,6 @@ class DocumentMetaclass(type):
# Add class to the _document_registry # Add class to the _document_registry
_document_registry[new_class._class_name] = new_class _document_registry[new_class._class_name] = new_class
# In Python 2, User-defined methods objects have special read-only
# attributes 'im_func' and 'im_self' which contain the function obj
# and class instance object respectively. With Python 3 these special
# attributes have been replaced by __func__ and __self__. The Blinker
# module continues to use im_func and im_self, so the code below
# copies __func__ into im_func and __self__ into im_self for
# classmethod objects in Document derived classes.
#
# Relates to https://github.com/MongoEngine/mongoengine/issues/1107
# for val in new_class.__dict__.values():
# if isinstance(val, classmethod):
# f = val.__get__(new_class)
# if hasattr(f, "__func__") and not hasattr(f, "im_func"):
# f.__dict__.update({"im_func": getattr(f, "__func__")})
# if hasattr(f, "__self__") and not hasattr(f, "im_self"):
# f.__dict__.update({"im_self": getattr(f, "__self__")})
# Handle delete rules # Handle delete rules
for field in new_class._fields.values(): for field in new_class._fields.values():
f = field f = field
@ -458,8 +441,8 @@ class TopLevelDocumentMetaclass(DocumentMetaclass):
id_basename, id_db_basename, i = ("auto_id", "_auto_id", 0) id_basename, id_db_basename, i = ("auto_id", "_auto_id", 0)
for i in itertools.count(): for i in itertools.count():
id_name = "{0}_{1}".format(id_basename, i) id_name = "{}_{}".format(id_basename, i)
id_db_name = "{0}_{1}".format(id_db_basename, i) id_db_name = "{}_{}".format(id_db_basename, i)
if id_name not in existing_fields and id_db_name not in existing_db_fields: if id_name not in existing_fields and id_db_name not in existing_db_fields:
return id_name, id_db_name return id_name, id_db_name

2
mongoengine/connection.py
View File

@ -317,7 +317,7 @@ def _create_connection(alias, connection_class, **connection_settings):
try: try:
return connection_class(**connection_settings) return connection_class(**connection_settings)
except Exception as e: except Exception as e:
raise ConnectionFailure("Cannot connect to database %s :\n%s" % (alias, e)) raise ConnectionFailure("Cannot connect to database {} :\n{}".format(alias, e))
def _find_existing_connection(connection_settings): def _find_existing_connection(connection_settings):

4
mongoengine/dereference.py
View File

@ -272,12 +272,12 @@ class DeReference(object):
(v["_ref"].collection, v["_ref"].id), v (v["_ref"].collection, v["_ref"].id), v
) )
elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth: elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth:
item_name = "{0}.{1}.{2}".format(name, k, field_name) item_name = "{}.{}.{}".format(name, k, field_name)
data[k]._data[field_name] = self._attach_objects( data[k]._data[field_name] = self._attach_objects(
v, depth, instance=instance, name=item_name v, depth, instance=instance, name=item_name
) )
elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth: elif isinstance(v, (dict, list, tuple)) and depth <= self.max_depth:
item_name = "%s.%s" % (name, k) if name else name item_name = "{}.{}".format(name, k) if name else name
data[k] = self._attach_objects( data[k] = self._attach_objects(
v, depth - 1, instance=instance, name=item_name v, depth - 1, instance=instance, name=item_name
) )

2
mongoengine/document.py
View File

@ -555,7 +555,7 @@ class Document(BaseDocument, metaclass=TopLevelDocumentMetaclass):
if not getattr(ref, "_changed_fields", True): if not getattr(ref, "_changed_fields", True):
continue continue
ref_id = "%s,%s" % (ref.__class__.__name__, str(ref._data)) ref_id = "{},{}".format(ref.__class__.__name__, str(ref._data))
if ref and ref_id not in _refs: if ref and ref_id not in _refs:
_refs.append(ref_id) _refs.append(ref_id)
kwargs["_refs"] = _refs kwargs["_refs"] = _refs

8
mongoengine/errors.py
View File

@ -94,7 +94,7 @@ class ValidationError(AssertionError):
return str(self.message) return str(self.message)
def __repr__(self): def __repr__(self):
return "%s(%s,)" % (self.__class__.__name__, self.message) return "{}({},)".format(self.__class__.__name__, self.message)
def __getattribute__(self, name): def __getattribute__(self, name):
message = super(ValidationError, self).__getattribute__(name) message = super(ValidationError, self).__getattribute__(name)
@ -102,7 +102,7 @@ class ValidationError(AssertionError):
if self.field_name: if self.field_name:
message = "%s" % message message = "%s" % message
if self.errors: if self.errors:
message = "%s(%s)" % (message, self._format_errors()) message = "{}({})".format(message, self._format_errors())
return message return message
def _get_message(self): def _get_message(self):
@ -147,13 +147,13 @@ class ValidationError(AssertionError):
elif isinstance(value, dict): elif isinstance(value, dict):
value = " ".join([generate_key(v, k) for k, v in value.items()]) value = " ".join([generate_key(v, k) for k, v in value.items()])
results = "%s.%s" % (prefix, value) if prefix else value results = "{}.{}".format(prefix, value) if prefix else value
return results return results
error_dict = defaultdict(list) error_dict = defaultdict(list)
for k, v in self.to_dict().items(): for k, v in self.to_dict().items():
error_dict[generate_key(v)].append(k) error_dict[generate_key(v)].append(k)
return " ".join(["%s: %s" % (k, v) for k, v in error_dict.items()]) return " ".join(["{}: {}".format(k, v) for k, v in error_dict.items()])
class DeprecatedError(Exception): class DeprecatedError(Exception):

20
mongoengine/fields.py
View File

@ -292,12 +292,16 @@ class EmailField(StringField):
domain_part = domain_part.encode("idna").decode("ascii") domain_part = domain_part.encode("idna").decode("ascii")
except UnicodeError: except UnicodeError:
self.error( self.error(
"%s %s" % (self.error_msg % value, "(domain failed IDN encoding)") "{} {}".format(
self.error_msg % value, "(domain failed IDN encoding)"
)
) )
else: else:
if not self.validate_domain_part(domain_part): if not self.validate_domain_part(domain_part):
self.error( self.error(
"%s %s" % (self.error_msg % value, "(domain validation failed)") "{} {}".format(
self.error_msg % value, "(domain validation failed)"
)
) )
@ -1344,7 +1348,7 @@ class CachedReferenceField(BaseField):
return None return None
update_kwargs = { update_kwargs = {
"set__%s__%s" % (self.name, key): val "set__{}__{}".format(self.name, key): val
for key, val in document._delta()[0].items() for key, val in document._delta()[0].items()
if key in self.fields if key in self.fields
} }
@ -1688,12 +1692,12 @@ class GridFSProxy(object):
return self.__copy__() return self.__copy__()
def __repr__(self): def __repr__(self):
return "<%s: %s>" % (self.__class__.__name__, self.grid_id) return "<{}: {}>".format(self.__class__.__name__, self.grid_id)
def __str__(self): def __str__(self):
gridout = self.get() gridout = self.get()
filename = getattr(gridout, "filename") if gridout else "<no file>" filename = getattr(gridout, "filename") if gridout else "<no file>"
return "<%s: %s (%s)>" % (self.__class__.__name__, filename, self.grid_id) return "<{}: {} ({})>".format(self.__class__.__name__, filename, self.grid_id)
def __eq__(self, other): def __eq__(self, other):
if isinstance(other, GridFSProxy): if isinstance(other, GridFSProxy):
@ -2097,7 +2101,7 @@ class SequenceField(BaseField):
Generate and Increment the counter Generate and Increment the counter
""" """
sequence_name = self.get_sequence_name() sequence_name = self.get_sequence_name()
sequence_id = "%s.%s" % (sequence_name, self.name) sequence_id = "{}.{}".format(sequence_name, self.name)
collection = get_db(alias=self.db_alias)[self.collection_name] collection = get_db(alias=self.db_alias)[self.collection_name]
counter = collection.find_one_and_update( counter = collection.find_one_and_update(
@ -2111,7 +2115,7 @@ class SequenceField(BaseField):
def set_next_value(self, value): def set_next_value(self, value):
"""Helper method to set the next sequence value""" """Helper method to set the next sequence value"""
sequence_name = self.get_sequence_name() sequence_name = self.get_sequence_name()
sequence_id = "%s.%s" % (sequence_name, self.name) sequence_id = "{}.{}".format(sequence_name, self.name)
collection = get_db(alias=self.db_alias)[self.collection_name] collection = get_db(alias=self.db_alias)[self.collection_name]
counter = collection.find_one_and_update( counter = collection.find_one_and_update(
filter={"_id": sequence_id}, filter={"_id": sequence_id},
@ -2128,7 +2132,7 @@ class SequenceField(BaseField):
as it is only fixed on set. as it is only fixed on set.
""" """
sequence_name = self.get_sequence_name() sequence_name = self.get_sequence_name()
sequence_id = "%s.%s" % (sequence_name, self.name) sequence_id = "{}.{}".format(sequence_name, self.name)
collection = get_db(alias=self.db_alias)[self.collection_name] collection = get_db(alias=self.db_alias)[self.collection_name]
data = collection.find_one({"_id": sequence_id}) data = collection.find_one({"_id": sequence_id})

2
mongoengine/queryset/field_list.py
View File

@ -78,7 +78,7 @@ class QueryFieldList(object):
return field_list return field_list
def reset(self): def reset(self):
self.fields = set([]) self.fields = set()
self.slice = {} self.slice = {}
self.value = self.ONLY self.value = self.ONLY

4
mongoengine/queryset/transform.py
View File

@ -433,7 +433,9 @@ def _geo_operator(field, op, value):
value = {"$near": _infer_geometry(value)} value = {"$near": _infer_geometry(value)}
else: else:
raise NotImplementedError( raise NotImplementedError(
'Geo method "%s" has not been implemented for a %s ' % (op, field._name) 'Geo method "{}" has not been implemented for a {} '.format(
op, field._name
)
) )
return value return value

6
setup.py
View File

@ -108,9 +108,6 @@ CLASSIFIERS = [
"Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Software Development :: Libraries :: Python Modules",
] ]
PYTHON_VERSION = sys.version_info[0]
PY3 = PYTHON_VERSION == 3
extra_opts = { extra_opts = {
"packages": find_packages(exclude=["tests", "tests.*"]), "packages": find_packages(exclude=["tests", "tests.*"]),
"tests_require": [ "tests_require": [
@ -118,8 +115,7 @@ extra_opts = {
"pytest-cov", "pytest-cov",
"coverage<5.0", # recent coverage switched to sqlite format for the .coverage file which isn't handled properly by coveralls "coverage<5.0", # recent coverage switched to sqlite format for the .coverage file which isn't handled properly by coveralls
"blinker", "blinker",
"Pillow>=2.0.0, <7.0.0", # 7.0.0 dropped Python2 support "Pillow>=2.0.0",
"zipp<2.0.0", # (dependency of pytest) dropped python2 support
], ],
} }