From b234aa48e4c17ac056afde75e43f06ef8f8200a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bastien=20G=C3=A9rard?= Date: Wed, 11 Mar 2020 23:21:38 +0100 Subject: [PATCH] run pyupgrade --- mongoengine/base/datastructures.py | 18 ++++++++++-------- mongoengine/base/document.py | 26 +++++++++++++------------- mongoengine/base/fields.py | 6 ++++-- mongoengine/base/metaclasses.py | 21 ++------------------- mongoengine/connection.py | 2 +- mongoengine/dereference.py | 4 ++-- mongoengine/document.py | 2 +- mongoengine/errors.py | 8 ++++---- mongoengine/fields.py | 20 ++++++++++++-------- mongoengine/queryset/field_list.py | 2 +- mongoengine/queryset/transform.py | 4 +++- setup.py | 6 +----- 12 files changed, 54 insertions(+), 65 deletions(-) diff --git a/mongoengine/base/datastructures.py b/mongoengine/base/datastructures.py index bb70089e..86fde15e 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, "%s.%s" % (self._name, key)) + value = BaseDict(value, None, "{}.{}".format(self._name, key)) super(BaseDict, self).__setitem__(key, value) value._instance = self._instance elif isinstance(value, list) and not isinstance(value, BaseList): - value = BaseList(value, None, "%s.%s" % (self._name, key)) + value = BaseList(value, None, "{}.{}".format(self._name, key)) super(BaseDict, self).__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("%s.%s" % (self._name, key)) + self._instance._mark_as_changed("{}.{}".format(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, "%s.%s" % (self._name, key)) + value = BaseDict(value, None, "{}.{}".format(self._name, key)) super(BaseList, self).__setitem__(key, value) value._instance = self._instance elif isinstance(value, list) and not isinstance(value, BaseList): # Replace list by BaseList - value = BaseList(value, None, "%s.%s" % (self._name, key)) + value = BaseList(value, None, "{}.{}".format(self._name, key)) super(BaseList, self).__setitem__(key, value) value._instance = self._instance return value @@ -181,7 +181,9 @@ class BaseList(list): def _mark_as_changed(self, key=None): if hasattr(self._instance, "_mark_as_changed"): 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: self._instance._mark_as_changed(self._name) @@ -428,7 +430,7 @@ class StrictDict(object): def __repr__(self): 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 @@ -473,4 +475,4 @@ class LazyReference(DBRef): raise AttributeError() def __repr__(self): - return "" % (self.document_type, self.pk) + return "".format(self.document_type, self.pk) diff --git a/mongoengine/base/document.py b/mongoengine/base/document.py index dff759a7..83c12a96 100644 --- a/mongoengine/base/document.py +++ b/mongoengine/base/document.py @@ -93,7 +93,7 @@ class BaseDocument(object): list(self._fields.keys()) + ["id", "pk", "_cls", "_text_score"] ) 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 ) raise FieldDoesNotExist(msg) @@ -286,7 +286,7 @@ class BaseDocument(object): except (UnicodeEncodeError, UnicodeDecodeError): u = "[Bad Unicode data]" 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): # TODO this could be simpler? @@ -441,7 +441,7 @@ class BaseDocument(object): pk = self.pk elif self._instance and hasattr(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) def to_json(self, *args, **kwargs): @@ -514,7 +514,7 @@ class BaseDocument(object): if "." in key: key, rest = key.split(".", 1) key = self._db_field_map.get(key, key) - key = "%s.%s" % (key, rest) + key = "{}.{}".format(key, rest) else: key = self._db_field_map.get(key, key) @@ -576,7 +576,7 @@ class BaseDocument(object): iterator = data.items() 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 # as changed. if item_key[:-1] in changed_fields: @@ -584,7 +584,7 @@ class BaseDocument(object): if hasattr(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)): self._nestable_types_changed_fields(changed_fields, item_key, value) @@ -615,7 +615,7 @@ class BaseDocument(object): if isinstance(data, EmbeddedDocument): # Find all embedded fields that have been changed 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)): if hasattr(field, "field") and isinstance( field.field, (ReferenceField, GenericReferenceField) @@ -769,11 +769,10 @@ class BaseDocument(object): if errors_dict: 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" % ( - cls._class_name, - errors, + msg = "Invalid data to create a `{}` instance.\n{}".format( + cls._class_name, errors, ) raise InvalidDocumentError(msg) @@ -944,7 +943,8 @@ class BaseDocument(object): # Add the new index to the list 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} unique_indexes.append(index) @@ -1001,7 +1001,7 @@ class BaseDocument(object): elif field._geo_index: field_name = field.db_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)]}) return geo_indices diff --git a/mongoengine/base/fields.py b/mongoengine/base/fields.py index ac894d91..2fadcfe1 100644 --- a/mongoengine/base/fields.py +++ b/mongoengine/base/fields.py @@ -474,7 +474,9 @@ class ComplexBaseField(BaseField): if errors: 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 if self.required and not value: self.error("Field is required and cannot be empty") @@ -546,7 +548,7 @@ class GeoJsonBaseField(BaseField): if isinstance(value, dict): if set(value.keys()) == {"type", "coordinates"}: 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"]) else: self.error( diff --git a/mongoengine/base/metaclasses.py b/mongoengine/base/metaclasses.py index 30a6fbab..473e6b18 100644 --- a/mongoengine/base/metaclasses.py +++ b/mongoengine/base/metaclasses.py @@ -168,23 +168,6 @@ class DocumentMetaclass(type): # Add class to the _document_registry _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 for field in new_class._fields.values(): f = field @@ -458,8 +441,8 @@ class TopLevelDocumentMetaclass(DocumentMetaclass): id_basename, id_db_basename, i = ("auto_id", "_auto_id", 0) for i in itertools.count(): - id_name = "{0}_{1}".format(id_basename, i) - id_db_name = "{0}_{1}".format(id_db_basename, i) + id_name = "{}_{}".format(id_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: return id_name, id_db_name diff --git a/mongoengine/connection.py b/mongoengine/connection.py index 3f754619..b03e0b1d 100644 --- a/mongoengine/connection.py +++ b/mongoengine/connection.py @@ -317,7 +317,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 %s :\n%s" % (alias, e)) + raise ConnectionFailure("Cannot connect to database {} :\n{}".format(alias, e)) def _find_existing_connection(connection_settings): diff --git a/mongoengine/dereference.py b/mongoengine/dereference.py index d0e6c527..3756d84a 100644 --- a/mongoengine/dereference.py +++ b/mongoengine/dereference.py @@ -272,12 +272,12 @@ class DeReference(object): (v["_ref"].collection, v["_ref"].id), v ) 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( v, depth, instance=instance, name=item_name ) 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( v, depth - 1, instance=instance, name=item_name ) diff --git a/mongoengine/document.py b/mongoengine/document.py index 4ac979d1..e13918c2 100644 --- a/mongoengine/document.py +++ b/mongoengine/document.py @@ -555,7 +555,7 @@ class Document(BaseDocument, metaclass=TopLevelDocumentMetaclass): if not getattr(ref, "_changed_fields", True): 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: _refs.append(ref_id) kwargs["_refs"] = _refs diff --git a/mongoengine/errors.py b/mongoengine/errors.py index 7045145c..76c25773 100644 --- a/mongoengine/errors.py +++ b/mongoengine/errors.py @@ -94,7 +94,7 @@ class ValidationError(AssertionError): return str(self.message) def __repr__(self): - return "%s(%s,)" % (self.__class__.__name__, self.message) + return "{}({},)".format(self.__class__.__name__, self.message) def __getattribute__(self, name): message = super(ValidationError, self).__getattribute__(name) @@ -102,7 +102,7 @@ class ValidationError(AssertionError): if self.field_name: message = "%s" % message if self.errors: - message = "%s(%s)" % (message, self._format_errors()) + message = "{}({})".format(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 = "%s.%s" % (prefix, value) if prefix else value + results = "{}.{}".format(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(["%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): diff --git a/mongoengine/fields.py b/mongoengine/fields.py index 391ad37b..91f85d26 100644 --- a/mongoengine/fields.py +++ b/mongoengine/fields.py @@ -292,12 +292,16 @@ class EmailField(StringField): domain_part = domain_part.encode("idna").decode("ascii") except UnicodeError: self.error( - "%s %s" % (self.error_msg % value, "(domain failed IDN encoding)") + "{} {}".format( + self.error_msg % value, "(domain failed IDN encoding)" + ) ) else: if not self.validate_domain_part(domain_part): 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 update_kwargs = { - "set__%s__%s" % (self.name, key): val + "set__{}__{}".format(self.name, key): val for key, val in document._delta()[0].items() if key in self.fields } @@ -1688,12 +1692,12 @@ class GridFSProxy(object): return self.__copy__() def __repr__(self): - return "<%s: %s>" % (self.__class__.__name__, self.grid_id) + return "<{}: {}>".format(self.__class__.__name__, self.grid_id) def __str__(self): gridout = self.get() filename = getattr(gridout, "filename") if gridout else "" - return "<%s: %s (%s)>" % (self.__class__.__name__, filename, self.grid_id) + return "<{}: {} ({})>".format(self.__class__.__name__, filename, self.grid_id) def __eq__(self, other): if isinstance(other, GridFSProxy): @@ -2097,7 +2101,7 @@ class SequenceField(BaseField): Generate and Increment the counter """ 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] counter = collection.find_one_and_update( @@ -2111,7 +2115,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 = "%s.%s" % (sequence_name, self.name) + sequence_id = "{}.{}".format(sequence_name, self.name) collection = get_db(alias=self.db_alias)[self.collection_name] counter = collection.find_one_and_update( filter={"_id": sequence_id}, @@ -2128,7 +2132,7 @@ class SequenceField(BaseField): as it is only fixed on set. """ 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] data = collection.find_one({"_id": sequence_id}) diff --git a/mongoengine/queryset/field_list.py b/mongoengine/queryset/field_list.py index c2618ebd..e0d8e322 100644 --- a/mongoengine/queryset/field_list.py +++ b/mongoengine/queryset/field_list.py @@ -78,7 +78,7 @@ class QueryFieldList(object): return field_list def reset(self): - self.fields = set([]) + self.fields = set() self.slice = {} self.value = self.ONLY diff --git a/mongoengine/queryset/transform.py b/mongoengine/queryset/transform.py index 1202ec45..3f1db8fa 100644 --- a/mongoengine/queryset/transform.py +++ b/mongoengine/queryset/transform.py @@ -433,7 +433,9 @@ def _geo_operator(field, op, value): value = {"$near": _infer_geometry(value)} else: 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 diff --git a/setup.py b/setup.py index b60188c7..fe3253ae 100644 --- a/setup.py +++ b/setup.py @@ -108,9 +108,6 @@ CLASSIFIERS = [ "Topic :: Software Development :: Libraries :: Python Modules", ] -PYTHON_VERSION = sys.version_info[0] -PY3 = PYTHON_VERSION == 3 - extra_opts = { "packages": find_packages(exclude=["tests", "tests.*"]), "tests_require": [ @@ -118,8 +115,7 @@ extra_opts = { "pytest-cov", "coverage<5.0", # recent coverage switched to sqlite format for the .coverage file which isn't handled properly by coveralls "blinker", - "Pillow>=2.0.0, <7.0.0", # 7.0.0 dropped Python2 support - "zipp<2.0.0", # (dependency of pytest) dropped python2 support + "Pillow>=2.0.0", ], }