format all native python code using black

Author: radhermit

benches/atom_memory_usage.py

@@ -16,16 +16,17 @@
 eprint = lambda x: print(x, file=sys.stderr)
 
 atom_funcs = [
-    ('pkgcraft', pkgcraft_atom),
-    ('pkgcraft-cached', pkgcraft_atom.cached),
-    ('pkgcore', pkgcore_atom),
-    ('portage', portage_atom),
+    ("pkgcraft", pkgcraft_atom),
+    ("pkgcraft-cached", pkgcraft_atom.cached),
+    ("pkgcore", pkgcore_atom),
+    ("portage", portage_atom),
 ]
 
+
 def test(atoms):
-    eprint('---------------------------------------')
-    eprint('{:<20} {:<10} time'.format("implementation", "memory"))
-    eprint('---------------------------------------')
+    eprint("---------------------------------------")
+    eprint("{:<20} {:<10} time".format("implementation", "memory"))
+    eprint("---------------------------------------")
     for (impl, func) in atom_funcs:
         if pid := os.fork():
             os.wait()
@@ -40,14 +41,14 @@ def test(atoms):
             os._exit(0)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     num_atoms = 1000000
 
     eprint(f"\nStatic atoms ({num_atoms})")
-    test(('cat/pkg' for _ in range(num_atoms)))
+    test(("cat/pkg" for _ in range(num_atoms)))
 
     eprint(f"\nDynamic atoms ({num_atoms})")
-    test((f'=cat/pkg-{x}-r1:2/3[a,b,c]' for x in range(num_atoms)))
+    test((f"=cat/pkg-{x}-r1:2/3[a,b,c]" for x in range(num_atoms)))
 
     eprint(f"\nRandom atoms ({num_atoms})")
-    test((f'=cat/pkg-{randrange(9999)}-r1:2/3[a,b,c]' for _ in range(num_atoms)))
+    test((f"=cat/pkg-{randrange(9999)}-r1:2/3[a,b,c]" for _ in range(num_atoms)))

benches/test_atom.py

@@ -1,6 +1,6 @@
 import pytest
 
-pytest_plugins = ('benchmark', 'pkgcraft')
+pytest_plugins = ("benchmark", "pkgcraft")
 
 from pkgcore.ebuild.atom import atom as pkgcore_atom
 from portage.dep import Atom as portage_atom
@@ -11,46 +11,53 @@
 def random_atom(func, random_str):
     cat = random_str()
     pkg = random_str()
-    s = f'=cat_{cat}/pkg_{pkg}-1-r2:3/4=[a,b,c]'
+    s = f"=cat_{cat}/pkg_{pkg}-1-r2:3/4=[a,b,c]"
     return func(s)
 
+
 atom_funcs = [
-    ('pkgcraft', pkgcraft_atom),
-    ('pkgcraft', pkgcraft_atom.cached),
-    ('pkgcore', pkgcore_atom),
-    ('portage', portage_atom),
+    ("pkgcraft", pkgcraft_atom),
+    ("pkgcraft", pkgcraft_atom.cached),
+    ("pkgcore", pkgcore_atom),
+    ("portage", portage_atom),
 ]
 
+
 @pytest.mark.parametrize("lib,func", atom_funcs)
 def test_bench_atom_static(benchmark, lib, func):
-    benchmark(func, '=cat/pkg-1-r2:3/4=[a,b,c]')
+    benchmark(func, "=cat/pkg-1-r2:3/4=[a,b,c]")
+
 
 @pytest.mark.parametrize("lib,func", atom_funcs)
 def test_bench_atom_random(benchmark, random_str, lib, func):
     benchmark(random_atom, func, random_str)
 
+
 @pytest.mark.parametrize("lib,func", atom_funcs)
 def test_bench_atom_property(benchmark, lib, func):
-    atom = func('=cat/pkg-1-r2:3/4=[a,b,c]')
-    version = benchmark(getattr, atom, 'version')
-    assert str(version).startswith('1')
+    atom = func("=cat/pkg-1-r2:3/4=[a,b,c]")
+    version = benchmark(getattr, atom, "version")
+    assert str(version).startswith("1")
+
 
 @pytest.mark.parametrize("lib,func", atom_funcs)
 def test_bench_atom_property_none(benchmark, lib, func):
-    atom = func('cat/pkg')
-    version = benchmark(getattr, atom, 'version')
+    atom = func("cat/pkg")
+    version = benchmark(getattr, atom, "version")
     assert version is None
 
+
 # portage atoms don't natively support comparisons
-@pytest.mark.parametrize("lib,func", (('pkgcraft', pkgcraft_atom), ('pkgcore', pkgcore_atom)))
+@pytest.mark.parametrize("lib,func", (("pkgcraft", pkgcraft_atom), ("pkgcore", pkgcore_atom)))
 def test_bench_atom_sorting_worst_case(benchmark, lib, func):
-    atoms = [func(f'=cat/pkg-{v}-r1:2/3=[a,b,c]') for v in reversed(range(100))]
+    atoms = [func(f"=cat/pkg-{v}-r1:2/3=[a,b,c]") for v in reversed(range(100))]
     result = benchmark(sorted, atoms)
     assert result == list(reversed(atoms))
 
+
 # portage atoms don't natively support comparisons
-@pytest.mark.parametrize("lib,func", (('pkgcraft', pkgcraft_atom), ('pkgcore', pkgcore_atom)))
+@pytest.mark.parametrize("lib,func", (("pkgcraft", pkgcraft_atom), ("pkgcore", pkgcore_atom)))
 def test_bench_atom_sorting_best_case(benchmark, lib, func):
-    atoms = [func(f'=cat/pkg-{v}-r1:2/3=[a,b,c]') for v in range(100)]
+    atoms = [func(f"=cat/pkg-{v}-r1:2/3=[a,b,c]") for v in range(100)]
     result = benchmark(sorted, atoms)
     assert result == atoms

benches/test_ordered_set.py

@@ -2,13 +2,13 @@
 
 import pytest
 
-pytest_plugins = ('benchmark',)
+pytest_plugins = ("benchmark",)
 
 from ordered_set import OrderedSet as PyOrderedSet
 
 from pkgcraft.set import OrderedSet as CyOrderedSet
 
-set_types = [('cython', CyOrderedSet), ('python', PyOrderedSet), ('standard', set)]
+set_types = [("cython", CyOrderedSet), ("python", PyOrderedSet), ("standard", set)]
 
 
 @pytest.mark.parametrize("variant,cls", set_types)

benches/test_repo.py

@@ -1,22 +1,25 @@
 import pytest
 
-pytest_plugins = ('benchmark', 'pkgcraft')
+pytest_plugins = ("benchmark", "pkgcraft")
 
 from pkgcore.ebuild.atom import atom as pkgcore_atom
 
 from pkgcraft.atom import Atom
 from pkgcraft.repo import RepoSet
 
 
-@pytest.mark.parametrize("lib,func", (('pkgcraft', Atom), ('pkgcore', pkgcore_atom)))
+@pytest.mark.parametrize("lib,func", (("pkgcraft", Atom), ("pkgcore", pkgcore_atom)))
 def test_bench_ebuild_repo_iter(benchmark, lib, func, ebuild_repo):
     # create ebuilds
     for i in range(100):
-        ebuild_repo.create_ebuild(f'cat/pkg-{i}')
+        ebuild_repo.create_ebuild(f"cat/pkg-{i}")
 
-    if lib == 'pkgcore':
+    if lib == "pkgcore":
         from pkgcore.ebuild import repo_objs, repository
-        repo_config = repo_objs.RepoConfig(location=str(ebuild_repo.path), disable_inst_caching=True)
+
+        repo_config = repo_objs.RepoConfig(
+            location=str(ebuild_repo.path), disable_inst_caching=True
+        )
         r = repository.UnconfiguredTree(str(ebuild_repo.path), repo_config=repo_config)
         pkgs = benchmark(lambda x: list(iter(x)), r)
     else:
@@ -25,54 +28,57 @@ def test_bench_ebuild_repo_iter(benchmark, lib, func, ebuild_repo):
     assert len(pkgs) == 100
 
 
-@pytest.mark.parametrize("lib,func", (('pkgcraft', Atom), ('pkgcore', pkgcore_atom)))
+@pytest.mark.parametrize("lib,func", (("pkgcraft", Atom), ("pkgcore", pkgcore_atom)))
 def test_bench_ebuild_repo_iter_restrict_atom(benchmark, lib, func, ebuild_repo):
     # create ebuilds
     for i in range(100):
-        ebuild_repo.create_ebuild(f'cat/pkg-{i}')
+        ebuild_repo.create_ebuild(f"cat/pkg-{i}")
 
     # single atom restriction
-    atom = func('=cat/pkg-50')
+    atom = func("=cat/pkg-50")
 
-    if lib == 'pkgcore':
+    if lib == "pkgcore":
         from pkgcore.ebuild import repo_objs, repository
-        repo_config = repo_objs.RepoConfig(location=str(ebuild_repo.path), disable_inst_caching=True)
+
+        repo_config = repo_objs.RepoConfig(
+            location=str(ebuild_repo.path), disable_inst_caching=True
+        )
         r = repository.UnconfiguredTree(str(ebuild_repo.path), repo_config=repo_config)
         pkgs = benchmark(lambda x: list(r.itermatch(x)), atom)
     else:
         pkgs = benchmark(lambda x: list(ebuild_repo.iter_restrict(x)), atom)
 
     assert len(pkgs) == 1
-    assert str(pkgs[0].version) == '50'
+    assert str(pkgs[0].version) == "50"
 
 
 def test_bench_fake_repo_iter(benchmark, fake_repo):
     # create pkgs
-    fake_repo.extend([f'cat/pkg-{i}' for i in range(100)])
+    fake_repo.extend([f"cat/pkg-{i}" for i in range(100)])
     pkgs = benchmark(lambda x: list(iter(x)), fake_repo)
     assert len(pkgs) == 100
 
 
 def test_bench_fake_repo_iter_restrict_atom(benchmark, fake_repo):
     # create pkgs
-    fake_repo.extend([f'cat/pkg-{i}' for i in range(100)])
+    fake_repo.extend([f"cat/pkg-{i}" for i in range(100)])
 
     # single atom restriction
-    atom = Atom('=cat/pkg-50')
+    atom = Atom("=cat/pkg-50")
 
     pkgs = benchmark(lambda x: list(fake_repo.iter_restrict(x)), atom)
     assert len(pkgs) == 1
-    assert str(pkgs[0].version) == '50'
+    assert str(pkgs[0].version) == "50"
 
 
 def test_bench_repo_set_iter(benchmark, make_ebuild_repo):
     r1 = make_ebuild_repo()
     r2 = make_ebuild_repo()
     # create ebuilds
     for i in range(50):
-        r1.create_ebuild(f'cat/pkg-{i}')
+        r1.create_ebuild(f"cat/pkg-{i}")
     for i in range(50, 100):
-        r2.create_ebuild(f'cat/pkg-{i}')
+        r2.create_ebuild(f"cat/pkg-{i}")
 
     repos = RepoSet(r1, r2)
     pkgs = benchmark(lambda x: list(iter(x)), repos)
@@ -84,15 +90,15 @@ def test_bench_repo_set_iter_restrict_atom(benchmark, make_ebuild_repo):
     r2 = make_ebuild_repo()
     # create ebuilds
     for i in range(50):
-        r1.create_ebuild(f'cat/pkg-{i}')
+        r1.create_ebuild(f"cat/pkg-{i}")
     for i in range(50, 100):
-        r2.create_ebuild(f'cat/pkg-{i}')
+        r2.create_ebuild(f"cat/pkg-{i}")
 
     # single atom restriction
-    atom = Atom('=cat/pkg-50')
+    atom = Atom("=cat/pkg-50")
 
     repos = RepoSet(r1, r2)
     pkgs = benchmark(lambda x: list(repos.iter_restrict(x)), atom)
 
     assert len(pkgs) == 1
-    assert str(pkgs[0].version) == '50'
+    assert str(pkgs[0].version) == "50"

examples/eapi-usage

@@ -14,9 +14,9 @@ from pkgcraft.logging import logger
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument('--quiet', '-q', action='count', default=0)
-    parser.add_argument('--verbose', '-v', action='count', default=0)
-    parser.add_argument('--repo', '-r', default='gentoo')
+    parser.add_argument("--quiet", "-q", action="count", default=0)
+    parser.add_argument("--verbose", "-v", action="count", default=0)
+    parser.add_argument("--repo", "-r", default="gentoo")
     args = parser.parse_args()
 
     # set logging level, defaulting to warning
@@ -41,8 +41,8 @@ def main():
 
     # output EAPI usage in descending order
     for (eapi, cpvs) in sorted(eapis.items(), key=lambda x: len(x[1]), reverse=True):
-        print(f'EAPI {eapi}: {len(cpvs)} pkgs')
+        print(f"EAPI {eapi}: {len(cpvs)} pkgs")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/leaf-pkgs

@@ -15,9 +15,9 @@ from pkgcraft.logging import logger
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument('--quiet', '-q', action='count', default=0)
-    parser.add_argument('--verbose', '-v', action='count', default=0)
-    parser.add_argument('--repo', '-r', default='gentoo')
+    parser.add_argument("--quiet", "-q", action="count", default=0)
+    parser.add_argument("--verbose", "-v", action="count", default=0)
+    parser.add_argument("--repo", "-r", default="gentoo")
     args = parser.parse_args()
 
     # set logging level, defaulting to warning
@@ -56,5 +56,5 @@ def main():
             print(cpv)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/query

@@ -32,19 +32,19 @@ from pkgcraft.restrict import Restrict
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument('--quiet', '-q', action='count', default=0)
-    parser.add_argument('--verbose', '-v', action='count', default=0)
-    parser.add_argument('--repo', '-r', metavar='REPO_PATH', dest='repos', action='append')
-    parser.add_argument('--restrict', metavar='RESTRICT', dest='restricts', action='append')
-    parser.add_argument('targets', metavar='TARGET', nargs='*')
+    parser.add_argument("--quiet", "-q", action="count", default=0)
+    parser.add_argument("--verbose", "-v", action="count", default=0)
+    parser.add_argument("--repo", "-r", metavar="REPO_PATH", dest="repos", action="append")
+    parser.add_argument("--restrict", metavar="RESTRICT", dest="restricts", action="append")
+    parser.add_argument("targets", metavar="TARGET", nargs="*")
     args = parser.parse_args()
 
     # set logging level, defaulting to warning
     level = logging.WARNING + (args.quiet - args.verbose) * 10
     logger.setLevel(level)
 
     if not (args.restricts or args.targets):
-        parser.error('restrictions and/or targets must be specified')
+        parser.error("restrictions and/or targets must be specified")
 
     def str_to_restrict(convert, combine, args):
         try:
@@ -55,11 +55,9 @@ def main():
     # convert strings to restrictions
     restricts = []
     if args.restricts:
-        restricts.append(str_to_restrict(
-            Restrict.pkg, lambda x, y: x & y, args.restricts))
+        restricts.append(str_to_restrict(Restrict.pkg, lambda x, y: x & y, args.restricts))
     if args.targets:
-        restricts.append(str_to_restrict(
-            Restrict.dep, lambda x, y: x | y, args.targets))
+        restricts.append(str_to_restrict(Restrict.dep, lambda x, y: x | y, args.targets))
 
     # combine pkg and target restrictions
     r = reduce(lambda x, y: x & y, restricts)
@@ -79,5 +77,5 @@ def main():
         print(pkg)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/revdeps

@@ -13,10 +13,10 @@ from pkgcraft.restrict import Restrict
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument('--quiet', '-q', action='count', default=0)
-    parser.add_argument('--verbose', '-v', action='count', default=0)
-    parser.add_argument('--repo', '-r', metavar='REPO_PATH', dest='repos', action='append')
-    parser.add_argument('dep')
+    parser.add_argument("--quiet", "-q", action="count", default=0)
+    parser.add_argument("--verbose", "-v", action="count", default=0)
+    parser.add_argument("--repo", "-r", metavar="REPO_PATH", dest="repos", action="append")
+    parser.add_argument("dep")
     args = parser.parse_args()
 
     # set logging level, defaulting to warning
@@ -43,8 +43,8 @@ def main():
     for pkg in config.repos.ebuild:
         for (attr, deps) in ((k, deps) for k in dep_keys if (deps := getattr(pkg, k.lower()))):
             for a in filter(restrict.matches, deps.iter_flatten()):
-                print(f'{pkg}: {attr}: {a}')
+                print(f"{pkg}: {attr}: {a}")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()