PYTHON-2504 Run 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 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
@@ -360,5 +359,5 @@ def __hash__(self) -> int:
     def __ne__(self, other: Any) -> bool:
         return not self == other
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"Binary({bytes.__repr__(self)}, {self.__subtype})"

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
@@ -87,7 +86,7 @@ def scope(self) -> Optional[Mapping[str, Any]]:
         """Scope dictionary for this instance or ``None``."""
         return self.__scope
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"Code({str.__repr__(self)}, {self.__scope!r})"
 
     def __eq__(self, other: Any) -> bool:

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,11 +168,11 @@ 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)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "{}(type_codecs={!r}, fallback_encoder={!r})".format(
             self.__class__.__name__,
             self.__type_codecs,
@@ -293,7 +286,7 @@ def _replace(self, **kwargs: Any) -> "CodecOptions[_DocumentType]":
     class CodecOptions(_BaseCodecOptions):
         """Encapsulates options used encoding and / or decoding BSON."""
 
-        def __init__(self, *args, **kwargs):
+        def __init__(self, *args, **kwargs) -> None:
             """Encapsulates options used encoding and / or decoding BSON.
 
             The `document_class` option is used to define a custom type for use
@@ -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,
@@ -473,7 +465,7 @@ def _options_dict(self) -> Dict[str, Any]:
                 "datetime_conversion": self.datetime_conversion,
             }
 
-        def __repr__(self):
+        def __repr__(self) -> str:
             return f"{self.__class__.__name__}({self._arguments_repr()})"
 
         def with_options(self, **kwargs: Any) -> "CodecOptions":

bson/datetime_ms.py

@@ -34,7 +34,7 @@ class DatetimeMS:
 
     __slots__ = ("_value",)
 
-    def __init__(self, value: Union[int, datetime.datetime]):
+    def __init__(self, value: Union[int, datetime.datetime]) -> None:
         """Represents a BSON UTC datetime.
 
         BSON UTC datetimes are defined as an int64 of milliseconds since the

bson/dbref.py

@@ -101,7 +101,7 @@ def as_doc(self) -> SON[str, Any]:
         doc.update(self.__kwargs)
         return doc
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         extra = "".join([f", {k}={v!r}" for k, v in self.__kwargs.items()])
         if self.database is None:
             return f"DBRef({self.collection!r}, {self.id!r}{extra})"

bson/decimal128.py

@@ -296,7 +296,7 @@ def __str__(self) -> str:
             return "NaN"
         return str(dec)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"Decimal128('{str(self)}')"
 
     def __setstate__(self, value: Tuple[int, int]) -> None:

bson/json_util.py

@@ -224,7 +224,7 @@ class JSONOptions(CodecOptions):
     datetime_representation: int
     strict_uuid: bool
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         """Encapsulates JSON options for :func:`dumps` and :func:`loads`.
 
         :Parameters:
@@ -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
 
 
@@ -51,5 +50,5 @@ def __ge__(self, dummy: Any) -> bool:
     def __gt__(self, other: Any) -> bool:
         return not isinstance(other, MaxKey)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "MaxKey()"

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
 
 
@@ -51,5 +50,5 @@ def __ge__(self, other: Any) -> bool:
     def __gt__(self, dummy: Any) -> bool:
         return False
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "MinKey()"

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 compatability with OIDs
         # pickled with pymongo-1.9 or older.
         if isinstance(value, dict):
@@ -246,7 +244,7 @@ def __setstate__(self, value: Any) -> None:
     def __str__(self) -> str:
         return binascii.hexlify(self.__id).decode()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"ObjectId('{str(self)}')"
 
     def __eq__(self, other: Any) -> bool:

bson/raw_bson.py

@@ -54,9 +54,8 @@
 from typing import Any, ItemsView, Iterator, Mapping, Optional
 
 from bson import _get_object_size, _raw_to_dict
-from bson.codec_options import _RAW_BSON_DOCUMENT_MARKER
+from bson.codec_options import _RAW_BSON_DOCUMENT_MARKER, CodecOptions
 from bson.codec_options import DEFAULT_CODEC_OPTIONS as DEFAULT
-from bson.codec_options import CodecOptions
 from bson.son import SON
 
 
@@ -131,7 +130,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.
@@ -173,7 +172,7 @@ def __eq__(self, other: Any) -> bool:
             return self.__raw == other.raw
         return NotImplemented
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "{}({!r}, codec_options={!r})".format(
             self.__class__.__name__,
             self.raw,

bson/regex.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Tools for representing MongoDB regular expressions.
-"""
+"""Tools for representing MongoDB regular expressions."""
 
 import re
 from typing import Any, Generic, Pattern, Type, TypeVar, Union
@@ -116,7 +115,7 @@ def __eq__(self, other: Any) -> bool:
     def __ne__(self, other: Any) -> bool:
         return not self == other
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"Regex({self.pattern!r}, {self.flags!r})"
 
     def try_compile(self) -> "Pattern[_T]":

bson/son.py

@@ -16,7 +16,8 @@
 
 Regular dictionaries can be used instead of SON objects, but not when the order
 of keys is important. A SON object can be used just like a normal Python
-dictionary."""
+dictionary.
+"""
 
 import copy
 import re
@@ -70,7 +71,7 @@ def __new__(cls: Type["SON[_Key, _Value]"], *args: Any, **kwargs: Any) -> "SON[_
         instance.__keys = []
         return instance
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         result = []
         for key in self.__keys:
             result.append(f"({key!r}, {self[key]!r})")

bson/timestamp.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Tools for representing MongoDB internal Timestamps.
-"""
+"""Tools for representing MongoDB internal Timestamps."""
 
 import calendar
 import datetime
@@ -112,7 +111,7 @@ def __ge__(self, other: Any) -> bool:
             return (self.time, self.inc) >= (other.time, other.inc)
         return NotImplemented
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"Timestamp({self.__time}, {self.__inc})"
 
     def as_datetime(self) -> datetime.datetime: