Run pyupgrade --py37-plus (#1035)

- Discards rewrites of `io.open`, see #1020

Author: kurtmckee

pyfakefs/fake_file.py

@@ -75,7 +75,7 @@ class FakeLargeFileIoException(Exception):
     """
 
     def __init__(self, file_path: str) -> None:
-        super(FakeLargeFileIoException, self).__init__(
+        super().__init__(
             "Read and write operations not supported for "
             "fake large file: %s" % file_path
         )
@@ -395,7 +395,7 @@ def __setattr__(self, key: str, value: Any) -> None:
         return super().__setattr__(key, value)
 
     def __str__(self) -> str:
-        return "%r(%o)" % (self.name, self.st_mode)
+        return f"{self.name!r}({self.st_mode:o})"
 
     def has_permission(self, permission_bits: int) -> bool:
         """Checks if the given permissions are set in the fake file.
@@ -416,7 +416,7 @@ def has_permission(self, permission_bits: int) -> bool:
 class FakeNullFile(FakeFile):
     def __init__(self, filesystem: "FakeFilesystem") -> None:
         devnull = "nul" if filesystem.is_windows_fs else "/dev/null"
-        super(FakeNullFile, self).__init__(devnull, filesystem=filesystem, contents="")
+        super().__init__(devnull, filesystem=filesystem, contents="")
 
     @property
     def byte_contents(self) -> bytes:
@@ -466,7 +466,7 @@ def byte_contents(self) -> Optional[bytes]:
 
     def set_contents(self, contents, encoding=None):
         self.contents_read = True
-        super(FakeFileFromRealFile, self).set_contents(contents, encoding)
+        super().set_contents(contents, encoding)
 
     def is_large_file(self):
         """The contents are never faked."""
@@ -650,7 +650,7 @@ def has_parent_object(self, dir_object: "FakeDirectory") -> bool:
         return False
 
     def __str__(self) -> str:
-        description = super(FakeDirectory, self).__str__() + ":\n"
+        description = super().__str__() + ":\n"
         for item in self.entries:
             item_desc = self.entries[item].__str__()
             for line in item_desc.split("\n"):
@@ -688,7 +688,7 @@ def __init__(
         """
         target_path = target_path or source_path
         real_stat = os.stat(source_path)
-        super(FakeDirectoryFromRealDirectory, self).__init__(
+        super().__init__(
             name=to_string(os.path.split(target_path)[1]),
             perm_bits=real_stat.st_mode,
             filesystem=filesystem,
@@ -730,7 +730,7 @@ def size(self) -> int:
         # we cannot get the size until the contents are loaded
         if not self.contents_read:
             return 0
-        return super(FakeDirectoryFromRealDirectory, self).size
+        return super().size
 
     @size.setter
     def size(self, st_size: int) -> None:

pyfakefs/fake_pathlib.py

@@ -231,7 +231,7 @@ def __init__(self, filesystem):
             self.sep = filesystem.path_separator
             self.altsep = filesystem.alternative_path_separator
             self.has_drv = filesystem.is_windows_fs
-            super(_FakeFlavour, self).__init__()
+            super().__init__()
 
         @staticmethod
         def _split_extended_path(path, ext_prefix=ext_namespace_prefix):
@@ -442,7 +442,7 @@ def make_uri(self, path):
             if len(drive) == 2 and drive[1] == ":":
                 # It's a path on a local drive => 'file:///c:/a/b'
                 rest = path.as_posix()[2:].lstrip("/")
-                return "file:///%s/%s" % (
+                return "file:///{}/{}".format(
                     drive,
                     urlquote_from_bytes(rest.encode("utf-8")),
                 )
@@ -618,15 +618,8 @@ def resolve(self, strict=None):
             Raises:
                 OSError: if the path doesn't exist (strict=True)
             """
-            if sys.version_info >= (3, 6):
-                if strict is None:
-                    strict = False
-            else:
-                if strict is not None:
-                    raise TypeError(
-                        "resolve() got an unexpected keyword argument 'strict'"
-                    )
-                strict = True
+            if strict is None:
+                strict = False
             self._raise_on_closed()
             path = self._flavour.resolve(
                 self, strict=strict

pyfakefs/fake_scandir.py

@@ -104,10 +104,8 @@ def stat(self, follow_symlinks=True):
                 self._statresult.st_nlink = 0
         return self._statresult
 
-    if sys.version_info >= (3, 6):
-
-        def __fspath__(self):
-            return self.path
+    def __fspath__(self):
+        return self.path
 
     if sys.version_info >= (3, 12):
 
@@ -155,16 +153,14 @@ def __next__(self):
         dir_entry._islink = self.filesystem.islink(dir_entry._abspath)
         return dir_entry
 
-    if sys.version_info >= (3, 6):
-
-        def __enter__(self):
-            return self
+    def __enter__(self):
+        return self
 
-        def __exit__(self, exc_type, exc_val, exc_tb):
-            self.close()
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
 
-        def close(self):
-            pass
+    def close(self):
+        pass
 
 
 def scandir(filesystem, path=""):
@@ -249,8 +245,7 @@ def do_walk(top_dir, top_most=False):
                 path = filesystem.joinpaths(top_dir, directory)
                 if not followlinks and filesystem.islink(path):
                     continue
-                for contents in do_walk(path):
-                    yield contents
+                yield from do_walk(path)
             if not topdown:
                 yield top_contents
 

pyfakefs/pytest_tests/io.py

@@ -10,5 +10,5 @@ def __init__(self, name):
         self.name = name
 
     def read(self):
-        with open(self.name, "r") as f:
+        with open(self.name) as f:
             return f.readline()

pyfakefs/pytest_tests/pytest_doctest_test.py

@@ -9,8 +9,6 @@
 Add `-s` option to enable print statements.
 """
 
-from __future__ import unicode_literals
-
 
 def make_file_factory(func_name, fake, result):
     """Return a simple function with parametrized doctest."""

pyfakefs/tests/dynamic_patch_test.py

@@ -28,7 +28,7 @@ def setUp(self):
 
 class DynamicImportPatchTest(TestPyfakefsUnittestBase):
     def __init__(self, methodName="runTest"):
-        super(DynamicImportPatchTest, self).__init__(methodName)
+        super().__init__(methodName)
 
     def test_os_patch(self):
         import os

pyfakefs/tests/example.py

@@ -67,7 +67,7 @@ def create_file(path):
 'It was created using open().\\n']
     """
     with open(path, "w", encoding="utf8") as f:
-        f.write("This is test file '{0}'.\n".format(path))
+        f.write(f"This is test file '{path}'.\n")
         f.write("It was created using open().\n")
 
 

pyfakefs/tests/fake_filesystem_shutil_test.py

@@ -411,7 +411,7 @@ def use_real_fs(self):
 
 class FakeCopyFileTest(RealFsTestCase):
     def tearDown(self):
-        super(FakeCopyFileTest, self).tearDown()
+        super().tearDown()
 
     def test_common_case(self):
         src_file = self.make_path("xyzzy")

pyfakefs/tests/fake_filesystem_vs_real_test.py

@@ -179,7 +179,7 @@ def _compare_behaviors(
         def _error_class(exc):
             if exc:
                 if hasattr(exc, "errno"):
-                    return "{}({})".format(exc.__class__.__name__, exc.errno)
+                    return f"{exc.__class__.__name__}({exc.errno})"
                 return exc.__class__.__name__
             return "None"
 
@@ -192,26 +192,26 @@ def _error_class(exc):
         # is almost always different because of the file paths.
         if _error_class(real_err) != _error_class(fake_err):
             if real_err is None:
-                return "%s: real version returned %s, fake raised %s" % (
+                return "{}: real version returned {}, fake raised {}".format(
                     method_call,
                     real_value,
                     _error_class(fake_err),
                 )
             if fake_err is None:
-                return "%s: real version raised %s, fake returned %s" % (
+                return "{}: real version raised {}, fake returned {}".format(
                     method_call,
                     _error_class(real_err),
                     fake_value,
                 )
-            return "%s: real version raised %s, fake raised %s" % (
+            return "{}: real version raised {}, fake raised {}".format(
                 method_call,
                 _error_class(real_err),
                 _error_class(fake_err),
             )
         real_errno = _get_errno(real_err)
         fake_errno = _get_errno(fake_err)
         if real_errno != fake_errno:
-            return "%s(%s): both raised %s, real errno %s, fake errno %s" % (
+            return "{}({}): both raised {}, real errno {}, fake errno {}".format(
                 method_name,
                 path,
                 _error_class(real_err),
@@ -230,7 +230,7 @@ def _error_class(exc):
                 real_value = real_value[len(self.real_base) :]
                 fake_value = fake_value[len(self.fake_base) :]
         if real_value != fake_value:
-            return "%s: real return %s, fake returned %s" % (
+            return "{}: real return {}, fake returned {}".format(
                 method_call,
                 real_value,
                 fake_value,
@@ -472,7 +472,7 @@ def assertFileHandleOpenBehaviorsMatch(self, *args, **kwargs):
             )
 
         if not is_exception_equal:
-            msg = "Behaviors don't match on open with args %s & kwargs %s.\n" % (
+            msg = "Behaviors don't match on open with args {} & kwargs {}.\n".format(
                 args,
                 kwargs,
             )

pyfakefs/tests/fake_open_test.py

@@ -33,7 +33,7 @@
 
 class FakeFileOpenTestBase(RealFsTestCase):
     def setUp(self):
-        super(FakeFileOpenTestBase, self).setUp()
+        super().setUp()
         if self.use_real_fs():
             self.open = io.open
         else:
@@ -46,11 +46,11 @@ def path_separator(self):
 
 class FakeFileOpenTest(FakeFileOpenTestBase):
     def setUp(self):
-        super(FakeFileOpenTest, self).setUp()
+        super().setUp()
         self.orig_time = time.time
 
     def tearDown(self):
-        super(FakeFileOpenTest, self).tearDown()
+        super().tearDown()
         time.time = self.orig_time
 
     def test_open_no_parent_dir(self):
@@ -1056,7 +1056,7 @@ def use_real_fs(self):
 @unittest.skipIf(sys.version_info < (3, 8), "open_code only present since Python 3.8")
 class FakeFilePatchedOpenCodeTest(FakeFileOpenTestBase):
     def setUp(self):
-        super(FakeFilePatchedOpenCodeTest, self).setUp()
+        super().setUp()
         if self.use_real_fs():
             self.open_code = io.open_code
         else:
@@ -1066,7 +1066,7 @@ def setUp(self):
     def tearDown(self):
         if not self.use_real_fs():
             self.filesystem.patch_open_code = False
-        super(FakeFilePatchedOpenCodeTest, self).tearDown()
+        super().tearDown()
 
     @unittest.skipIf(IS_PYPY, "Different behavior in PyPy")
     def test_invalid_path(self):
@@ -1104,7 +1104,7 @@ def use_real_fs(self):
 @unittest.skipIf(sys.version_info < (3, 8), "open_code only present since Python 3.8")
 class FakeFileUnpatchedOpenCodeTest(FakeFileOpenTestBase):
     def setUp(self):
-        super(FakeFileUnpatchedOpenCodeTest, self).setUp()
+        super().setUp()
         if self.use_real_fs():
             self.open_code = io.open_code
         else:
@@ -1377,7 +1377,7 @@ class OpenFileWithEncodingTest(FakeFileOpenTestBase):
     an explicit text encoding."""
 
     def setUp(self):
-        super(OpenFileWithEncodingTest, self).setUp()
+        super().setUp()
         self.file_path = self.make_path("foo")
 
     def test_write_str_read_bytes(self):
@@ -1536,7 +1536,7 @@ def use_real_fs(self):
 
 class FakeFileOpenLineEndingTest(FakeFileOpenTestBase):
     def setUp(self):
-        super(FakeFileOpenLineEndingTest, self).setUp()
+        super().setUp()
 
     def test_read_default_newline_mode(self):
         file_path = self.make_path("some_file")
@@ -1656,7 +1656,7 @@ def use_real_fs(self):
 
 class FakeFileOpenLineEndingWithEncodingTest(FakeFileOpenTestBase):
     def setUp(self):
-        super(FakeFileOpenLineEndingWithEncodingTest, self).setUp()
+        super().setUp()
 
     def test_read_standard_newline_mode(self):
         file_path = self.make_path("some_file")
@@ -1769,7 +1769,7 @@ def use_real_fs(self):
 
 class OpenWithFlagsTestBase(FakeFileOpenTestBase):
     def setUp(self):
-        super(OpenWithFlagsTestBase, self).setUp()
+        super().setUp()
         self.file_path = self.make_path("some_file")
         self.file_contents = None
 
@@ -1795,7 +1795,7 @@ def write_and_reopen_file(self, fake_file, mode="r", encoding=None):
 
 class OpenWithBinaryFlagsTest(OpenWithFlagsTestBase):
     def setUp(self):
-        super(OpenWithBinaryFlagsTest, self).setUp()
+        super().setUp()
         self.file_contents = b"real binary contents: \x1f\x8b"
         self.create_file(self.file_path, contents=self.file_contents)
 
@@ -1830,7 +1830,7 @@ def use_real_fs(self):
 
 class OpenWithTextModeFlagsTest(OpenWithFlagsTestBase):
     def setUp(self):
-        super(OpenWithTextModeFlagsTest, self).setUp()
+        super().setUp()
         self.setUpFileSystem()
 
     def setUpFileSystem(self):

pyfakefs/tests/fake_os_test.py

@@ -1641,7 +1641,7 @@ def test_mkdir(self):
         self.assertTrue(self.filesystem.exists("/%s" % directory))
         self.os.chdir(directory)
         self.os.mkdir(directory)
-        self.assertTrue(self.filesystem.exists("/%s/%s" % (directory, directory)))
+        self.assertTrue(self.filesystem.exists(f"/{directory}/{directory}"))
         self.os.chdir(directory)
         self.os.mkdir("../abccb")
         self.assertTrue(self.os.path.exists("/%s/abccb" % directory))
@@ -1662,7 +1662,7 @@ def test_mkdir_raises_if_empty_directory_name(self):
     def test_mkdir_raises_if_no_parent(self):
         """mkdir raises exception if parent directory does not exist."""
         parent = "xyzzy"
-        directory = "%s/foo" % (parent,)
+        directory = f"{parent}/foo"
         self.assertFalse(self.os.path.exists(parent))
         self.assert_raises_os_error(errno.ENOENT, self.os.mkdir, directory)
 

pyfakefs/tests/fake_pathlib_test.py

@@ -304,7 +304,7 @@ def use_real_fs(self):
 
 class FakePathlibFileObjectPropertyTest(RealPathlibTestCase):
     def setUp(self):
-        super(FakePathlibFileObjectPropertyTest, self).setUp()
+        super().setUp()
         self.umask = self.os.umask(0o022)
         self.file_path = self.make_path("home", "jane", "test.py")
         self.create_file(self.file_path, contents=b"a" * 100)