ruff --fix-only --select ALL --fixable ALL --target-version py37 --line-length=100 --unfixable COM812,D400,D415,ERA001,RUF100,SIM108,D211,D212,SIM105,SIM,PT,ANN204,EM bson/*.py pymongo/*.py gridfs/*.py test/*.py test/*/*.py

Author: ShaneHarvey

bson/__init__.py

@@ -237,8 +237,8 @@ def get_data_and_view(data: Any) -> Tuple[Any, memoryview]:
 def _raise_unknown_type(element_type: int, element_name: str) -> NoReturn:
     """Unknown type helper."""
     raise InvalidBSON(
-        "Detected unknown BSON type %r for fieldname '%s'. Are "
-        "you using the latest driver version?" % (chr(element_type).encode(), element_name)
+        "Detected unknown BSON type {!r} for fieldname '{}'. Are "
+        "you using the latest driver version?".format(chr(element_type).encode(), element_name)
     )
 
 

bson/_helpers.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 """Setstate and getstate functions for objects with __slots__, allowing
-    compatibility with default pickling protocol
+compatibility with default pickling protocol
 """
 from typing import Any, Mapping
 
@@ -33,7 +33,7 @@ def _mangle_name(name: str, prefix: str) -> str:
 
 def _getstate_slots(self: Any) -> Mapping[Any, Any]:
     prefix = self.__class__.__name__
-    ret = dict()
+    ret = {}
     for name in self.__slots__:
         mangled_name = _mangle_name(name, prefix)
         if hasattr(self, mangled_name):

bson/binary.py

@@ -330,8 +330,7 @@ def as_uuid(self, uuid_representation: int = UuidRepresentation.STANDARD) -> UUI
                 return UUID(bytes=self)
 
         raise ValueError(
-            "cannot decode subtype %s to %s"
-            % (self.subtype, UUID_REPRESENTATION_NAMES[uuid_representation])
+            f"cannot decode subtype {self.subtype} to {UUID_REPRESENTATION_NAMES[uuid_representation]}"
         )
 
     @property

bson/code.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Tools for representing JavaScript code in BSON.
-"""
+"""Tools for representing JavaScript code in BSON."""
 
 from collections.abc import Mapping as _Mapping
 from typing import Any, Mapping, Optional, Type, Union

bson/codec_options.py

@@ -63,12 +63,10 @@ class TypeEncoder(abc.ABC):
     @abc.abstractproperty
     def python_type(self) -> Any:
         """The Python type to be converted into something serializable."""
-        pass
 
     @abc.abstractmethod
     def transform_python(self, value: Any) -> Any:
         """Convert the given Python object into something serializable."""
-        pass
 
 
 class TypeDecoder(abc.ABC):
@@ -84,12 +82,10 @@ class TypeDecoder(abc.ABC):
     @abc.abstractproperty
     def bson_type(self) -> Any:
         """The BSON type to be converted into our own type."""
-        pass
 
     @abc.abstractmethod
     def transform_bson(self, value: Any) -> Any:
         """Convert the given BSON value into our own type."""
-        pass
 
 
 class TypeCodec(TypeEncoder, TypeDecoder):
@@ -105,8 +101,6 @@ class TypeCodec(TypeEncoder, TypeDecoder):
     See :ref:`custom-type-type-codec` documentation for an example.
     """
 
-    pass
-
 
 _Codec = Union[TypeEncoder, TypeDecoder, TypeCodec]
 _Fallback = Callable[[Any], Any]
@@ -164,8 +158,7 @@ def __init__(
                 self._decoder_map[codec.bson_type] = codec.transform_bson
             if not is_valid_codec:
                 raise TypeError(
-                    "Expected an instance of %s, %s, or %s, got %r instead"
-                    % (TypeEncoder.__name__, TypeDecoder.__name__, TypeCodec.__name__, codec)
+                    f"Expected an instance of {TypeEncoder.__name__}, {TypeDecoder.__name__}, or {TypeCodec.__name__}, got {codec!r} instead"
                 )
 
     def _validate_type_encoder(self, codec: _Codec) -> None:
@@ -175,7 +168,7 @@ def _validate_type_encoder(self, codec: _Codec) -> None:
             if issubclass(cast(TypeCodec, codec).python_type, pytype):
                 err_msg = (
                     "TypeEncoders cannot change how built-in types are "
-                    "encoded (encoder %s transforms type %s)" % (codec, pytype)
+                    "encoded (encoder {} transforms type {})".format(codec, pytype)
                 )
                 raise TypeError(err_msg)
 
@@ -446,10 +439,9 @@ def _arguments_repr(self) -> str:
             )
 
             return (
-                "document_class=%s, tz_aware=%r, uuid_representation=%s, "
-                "unicode_decode_error_handler=%r, tzinfo=%r, "
-                "type_registry=%r, datetime_conversion=%s"
-                % (
+                "document_class={}, tz_aware={!r}, uuid_representation={}, "
+                "unicode_decode_error_handler={!r}, tzinfo={!r}, "
+                "type_registry={!r}, datetime_conversion={}".format(
                     document_class_repr,
                     self.tz_aware,
                     uuid_rep_repr,

bson/json_util.py

@@ -350,10 +350,9 @@ def __new__(
 
     def _arguments_repr(self) -> str:
         return (
-            "strict_number_long=%r, "
-            "datetime_representation=%r, "
-            "strict_uuid=%r, json_mode=%r, %s"
-            % (
+            "strict_number_long={!r}, "
+            "datetime_representation={!r}, "
+            "strict_uuid={!r}, json_mode={!r}, {}".format(
                 self.strict_number_long,
                 self.datetime_representation,
                 self.strict_uuid,
@@ -492,7 +491,7 @@ def _json_convert(obj: Any, json_options: JSONOptions = DEFAULT_JSON_OPTIONS) ->
     if hasattr(obj, "items"):
         return SON(((k, _json_convert(v, json_options)) for k, v in obj.items()))
     elif hasattr(obj, "__iter__") and not isinstance(obj, (str, bytes)):
-        return list(_json_convert(v, json_options) for v in obj)
+        return [_json_convert(v, json_options) for v in obj]
     try:
         return default(obj, json_options)
     except TypeError:
@@ -720,7 +719,7 @@ def _parse_canonical_regex(doc: Any) -> Regex:
     if len(regex) != 2:
         raise TypeError(
             'Bad $regularExpression must include only "pattern"'
-            'and "options" components: %s' % (doc,)
+            'and "options" components: {}'.format(doc)
         )
     opts = regex["options"]
     if not isinstance(opts, str):

bson/max_key.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Representation for the MongoDB internal MaxKey type.
-"""
+"""Representation for the MongoDB internal MaxKey type."""
 from typing import Any
 
 

bson/min_key.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Representation for the MongoDB internal MinKey type.
-"""
+"""Representation for the MongoDB internal MinKey type."""
 from typing import Any
 
 

bson/objectid.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Tools for working with MongoDB ObjectIds.
-"""
+"""Tools for working with MongoDB ObjectIds."""
 
 import binascii
 import calendar
@@ -166,7 +165,6 @@ def _random(cls) -> bytes:
 
     def __generate(self) -> None:
         """Generate a new value for this ObjectId."""
-
         # 4 bytes current time
         oid = struct.pack(">I", int(time.time()))
 
@@ -222,13 +220,13 @@ def generation_time(self) -> datetime.datetime:
         return datetime.datetime.fromtimestamp(timestamp, utc)
 
     def __getstate__(self) -> bytes:
-        """return value of object for pickling.
+        """Return value of object for pickling.
         needed explicitly because __slots__() defined.
         """
         return self.__id
 
     def __setstate__(self, value: Any) -> None:
-        """explicit state set from pickling"""
+        """Explicit state set from pickling"""
         # Provide backwards compatibility with OIDs
         # pickled with pymongo-1.9 or older.
         if isinstance(value, dict):

bson/raw_bson.py

@@ -131,7 +131,7 @@ class from the standard library so it can be used like a read-only
         elif not issubclass(codec_options.document_class, RawBSONDocument):
             raise TypeError(
                 "RawBSONDocument cannot use CodecOptions with document "
-                "class %s" % (codec_options.document_class,)
+                "class {}".format(codec_options.document_class)
             )
         self.__codec_options = codec_options
         # Validate the bson object size.