]> git.scottworley.com Git - git-cache/commitdiff
New pylint likes f-strings
authorScott Worley <scottworley@scottworley.com>
Wed, 23 Nov 2022 08:25:38 +0000 (00:25 -0800)
committerScott Worley <scottworley@scottworley.com>
Wed, 23 Nov 2022 08:31:13 +0000 (00:31 -0800)
git_cache.py
test_git_cache.py

index 1ed26017ceb18f0831d8b5566068c6eb11fdcf7a..75f7b2689b8b7f12313aedc60754c349b53fcdd3 100644 (file)
@@ -78,7 +78,7 @@ def verify_ancestry(
         ancestor: RefOrRev,
         force: bool = False) -> None:
     if not force and not is_ancestor(repo, descendant, ancestor):
         ancestor: RefOrRev,
         force: bool = False) -> None:
     if not force and not is_ancestor(repo, descendant, ancestor):
-        raise Exception('%s is not an ancestor of %s' % (ancestor, descendant))
+        raise Exception(f'{ancestor} is not an ancestor of {descendant}')
 
 
 def _read_fetch_log(repo: Repo) -> Iterator[_LogEntry]:
 
 
 def _read_fetch_log(repo: Repo) -> Iterator[_LogEntry]:
@@ -108,9 +108,10 @@ def _log_fetch(repo: Repo, ref: Ref, rev: Rev, force: bool = False) -> None:
     filename = _log_filename(repo)
     os.makedirs(os.path.dirname(filename), exist_ok=True)
     with open(filename, 'a') as f:
     filename = _log_filename(repo)
     os.makedirs(os.path.dirname(filename), exist_ok=True)
     with open(filename, 'a') as f:
-        f.write('%s %s %s %s\n' %
-                (time.strftime('%Y-%m%d-%H:%M:%S%z'),
-                 ('FORCEDFETCH' if force else 'fetch'), rev, ref))
+        f.write(
+            f'{time.strftime("%Y-%m%d-%H:%M:%S%z")} '
+            f'{"FORCEDFETCH" if force else "fetch"} {rev} {ref}\n'
+        )
 
 
 def _show_force_warning() -> None:
 
 
 def _show_force_warning() -> None:
@@ -150,7 +151,7 @@ def _show_force_warning() -> None:
 ''', end='', file=sys.stderr)
 
     for i in range(warn_time, 0, -1):
 ''', end='', file=sys.stderr)
 
     for i in range(warn_time, 0, -1):
-        msg = '* %-70s *' % ("Continuing in %d seconds..." % i)
+        msg = f'* {f"Continuing in {i} seconds...":-70s} *'
         print(msg, file=sys.stderr)
         time.sleep(1)
     print('*' * 74, file=sys.stderr)
         print(msg, file=sys.stderr)
         time.sleep(1)
     print('*' * 74, file=sys.stderr)
@@ -167,7 +168,7 @@ def _git_fetch(
         force: bool = False) -> None:
     subprocess.run(['git', '-C', cachedir, 'fetch'] +
                    (['--force'] if force else []) +
         force: bool = False) -> None:
     subprocess.run(['git', '-C', cachedir, 'fetch'] +
                    (['--force'] if force else []) +
-                   [repo, '%s:%s' % (ref, ref)], check=True)
+                   [repo, f'{ref}:{ref}'], check=True)
 
 
 def fetch(repo: Repo, ref: Ref, force: bool = False) -> Tuple[Path, Rev]:
 
 
 def fetch(repo: Repo, ref: Ref, force: bool = False) -> Tuple[Path, Rev]:
@@ -244,7 +245,8 @@ def _main() -> None:
     args = parser.parse_args()
 
     if args.rev is None:
     args = parser.parse_args()
 
     if args.rev is None:
-        print('{1} {0}'.format(*fetch(args.repo, args.ref, force=args.force)))
+        cachedir, rev = fetch(args.repo, args.ref, force=args.force)
+        print(f'{rev} {cachedir}')
     else:
         print(
             ensure_rev_available(
     else:
         print(
             ensure_rev_available(
index ce80fcbfaca911589ae13cee4eb61dfb67c30cd1..cc3cf3533715ed16e87198e9fb426215b13e5a7b 100644 (file)
@@ -69,32 +69,32 @@ class TestGitCache(unittest.TestCase):
 
     def test_fetch(self) -> None:
         d, rev = git_cache.fetch(self.upstream, 'main')
 
     def test_fetch(self) -> None:
         d, rev = git_cache.fetch(self.upstream, 'main')
-        self.assertEqual(_git(d, 'show', '%s:file' % rev), b'Contents')
+        self.assertEqual(_git(d, 'show', f'{rev}:file'), b'Contents')
 
     def test_fetch_twice(self) -> None:
         d1, rev1 = git_cache.fetch(self.upstream, 'main')
 
     def test_fetch_twice(self) -> None:
         d1, rev1 = git_cache.fetch(self.upstream, 'main')
-        self.assertEqual(_git(d1, 'show', '%s:file' % rev1), b'Contents')
+        self.assertEqual(_git(d1, 'show', f'{rev1}:file'), b'Contents')
         d2, rev2 = git_cache.fetch(self.upstream, 'main')
         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)
         d2, rev2 = git_cache.fetch(self.upstream, 'main')
         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)
-        self.assertEqual(_git(d2, 'show', '%s:file' % rev2), b'Contents')
+        self.assertEqual(_git(d2, 'show', f'{rev2}:file'), b'Contents')
 
     def test_fetch_then_ensure(self) -> None:
         d1, rev = git_cache.fetch(self.upstream, 'main')
 
     def test_fetch_then_ensure(self) -> None:
         d1, rev = git_cache.fetch(self.upstream, 'main')
-        self.assertEqual(_git(d1, 'show', '%s:file' % rev), b'Contents')
+        self.assertEqual(_git(d1, 'show', f'{rev}:file'), b'Contents')
         d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev)
         self.assertEqual(d1, d2)
         d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev)
         self.assertEqual(d1, d2)
-        self.assertEqual(_git(d2, 'show', '%s:file' % rev), b'Contents')
+        self.assertEqual(_git(d2, 'show', f'{rev}:file'), b'Contents')
 
     def test_ensure_then_fetch(self) -> None:
         rev1 = _git(
             self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         d1 = git_cache.ensure_rev_available(self.upstream, 'main', rev1)
 
     def test_ensure_then_fetch(self) -> None:
         rev1 = _git(
             self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         d1 = git_cache.ensure_rev_available(self.upstream, 'main', rev1)
-        self.assertEqual(_git(d1, 'show', '%s:file' % rev1), b'Contents')
+        self.assertEqual(_git(d1, 'show', f'{rev1}:file'), b'Contents')
         d2, rev2 = git_cache.fetch(self.upstream, 'main')
         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)
         d2, rev2 = git_cache.fetch(self.upstream, 'main')
         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)
-        self.assertEqual(_git(d2, 'show', '%s:file' % rev2), b'Contents')
+        self.assertEqual(_git(d2, 'show', f'{rev2}:file'), b'Contents')
 
     def test_fetch_new_file(self) -> None:
         d1, rev1 = git_cache.fetch(self.upstream, 'main')
 
     def test_fetch_new_file(self) -> None:
         d1, rev1 = git_cache.fetch(self.upstream, 'main')
@@ -102,7 +102,7 @@ class TestGitCache(unittest.TestCase):
         d2, rev2 = git_cache.fetch(self.upstream, 'main')
         self.assertEqual(d1, d2)
         self.assertNotEqual(rev1, rev2)
         d2, rev2 = git_cache.fetch(self.upstream, 'main')
         self.assertEqual(d1, d2)
         self.assertNotEqual(rev1, rev2)
-        self.assertEqual(_git(d2, 'show', '%s:foofile' % rev2), b'foo')
+        self.assertEqual(_git(d2, 'show', f'{rev2}:foofile'), b'foo')
 
     def test_ensure_doesnt_fetch_new_file(self) -> None:
         d1, rev1 = git_cache.fetch(self.upstream, 'main')
 
     def test_ensure_doesnt_fetch_new_file(self) -> None:
         d1, rev1 = git_cache.fetch(self.upstream, 'main')
@@ -113,7 +113,7 @@ class TestGitCache(unittest.TestCase):
         d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev1)
         self.assertEqual(d1, d2)
         p = subprocess.run(
         d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev1)
         self.assertEqual(d1, d2)
         p = subprocess.run(
-            ['git', '-C', d2, 'show', '%s:foofile' % rev2], check=False)
+            ['git', '-C', d2, 'show', f'{rev2}:foofile'], check=False)
         self.assertNotEqual(p.returncode, 0)
 
     def test_ensure_doesnt_fetch_from_deleted_upstream(self) -> None:
         self.assertNotEqual(p.returncode, 0)
 
     def test_ensure_doesnt_fetch_from_deleted_upstream(self) -> None:
@@ -130,7 +130,7 @@ class TestGitCache(unittest.TestCase):
         self.assertNotEqual(rev1, rev2)
         d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev2)
         self.assertEqual(d1, d2)
         self.assertNotEqual(rev1, rev2)
         d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev2)
         self.assertEqual(d1, d2)
-        self.assertEqual(_git(d2, 'show', '%s:foofile' % rev2), b'foo')
+        self.assertEqual(_git(d2, 'show', f'{rev2}:foofile'), b'foo')
 
     def test_fetch_raises_on_invalid_repo(self) -> None:
         self.tempdir.cleanup()
 
     def test_fetch_raises_on_invalid_repo(self) -> None:
         self.tempdir.cleanup()
@@ -171,18 +171,18 @@ class TestGitCache(unittest.TestCase):
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         d = git_cache.ensure_rev_available(self.upstream, 'otherbranch', rev)
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         d = git_cache.ensure_rev_available(self.upstream, 'otherbranch', rev)
-        self.assertEqual(_git(d, 'show', '%s:foofile' % rev), b'foo')
+        self.assertEqual(_git(d, 'show', f'{rev}:foofile'), b'foo')
 
     def test_catch_up(self) -> None:
         _git(self.upstream, 'checkout', '-b', 'otherbranch')
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         d = git_cache.ensure_rev_available(self.upstream, 'otherbranch', rev)
 
     def test_catch_up(self) -> None:
         _git(self.upstream, 'checkout', '-b', 'otherbranch')
         _commit_file(self.upstream, 'foofile', 'foo', 'Foo')
         rev = _git(self.upstream, 'log', '--format=%H', '-n1').strip().decode()
         d = git_cache.ensure_rev_available(self.upstream, 'otherbranch', rev)
-        self.assertEqual(_git(d, 'show', '%s:foofile' % rev), b'foo')
+        self.assertEqual(_git(d, 'show', f'{rev}:foofile'), b'foo')
         _git(self.upstream, 'checkout', 'main')
         _git(self.upstream, 'merge', '--ff-only', 'otherbranch')
         d = git_cache.ensure_rev_available(self.upstream, 'main', rev)
         _git(self.upstream, 'checkout', 'main')
         _git(self.upstream, 'merge', '--ff-only', 'otherbranch')
         d = git_cache.ensure_rev_available(self.upstream, 'main', rev)
-        self.assertEqual(_git(d, 'show', '%s:foofile' % rev), b'foo')
+        self.assertEqual(_git(d, 'show', f'{rev}:foofile'), b'foo')
 
     def test_fetch_after_cache_deleted(self) -> None:
         d1, rev1 = git_cache.fetch(self.upstream, 'main')
 
     def test_fetch_after_cache_deleted(self) -> None:
         d1, rev1 = git_cache.fetch(self.upstream, 'main')
@@ -190,14 +190,14 @@ class TestGitCache(unittest.TestCase):
         d2, rev2 = git_cache.fetch(self.upstream, 'main')
         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)
         d2, rev2 = git_cache.fetch(self.upstream, 'main')
         self.assertEqual(d1, d2)
         self.assertEqual(rev1, rev2)
-        self.assertEqual(_git(d2, 'show', '%s:file' % rev2), b'Contents')
+        self.assertEqual(_git(d2, 'show', f'{rev2}:file'), b'Contents')
 
     def test_ensure_after_cache_deleted(self) -> None:
         d1, rev = git_cache.fetch(self.upstream, 'main')
         shutil.rmtree(d1)
         d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev)
         self.assertEqual(d1, d2)
 
     def test_ensure_after_cache_deleted(self) -> None:
         d1, rev = git_cache.fetch(self.upstream, 'main')
         shutil.rmtree(d1)
         d2 = git_cache.ensure_rev_available(self.upstream, 'main', rev)
         self.assertEqual(d1, d2)
-        self.assertEqual(_git(d2, 'show', '%s:file' % rev), b'Contents')
+        self.assertEqual(_git(d2, 'show', f'{rev}:file'), b'Contents')
 
     def test_fetch_raises_on_amend(self) -> None:
         git_cache.fetch(self.upstream, 'main')
 
     def test_fetch_raises_on_amend(self) -> None:
         git_cache.fetch(self.upstream, 'main')