Misc modernize (pyupgrade)

benchmarks/bench_translations.py

@@ -57,8 +57,9 @@ def track_m2l_op_count(self, param):
         m_expn = self.mpole_expn_class(knl, order=param.order)
         l_expn = self.local_expn_class(knl, order=param.order)
 
-        src_coeff_exprs = [sym.Symbol("src_coeff%d" % i)
-                for i in range(len(m_expn))]
+        src_coeff_exprs = [
+            sym.Symbol(f"src_coeff{i}")
+            for i in range(len(m_expn))]
         dvec = sym.make_sym_vector("d", knl.dim)
         src_rscale = sym.Symbol("src_rscale")
         tgt_rscale = sym.Symbol("tgt_rscale")
@@ -72,7 +73,7 @@ def track_m2l_op_count(self, param):
             result = l_expn.translate_from(m_expn, src_coeff_exprs, src_rscale,
                                        dvec, tgt_rscale)
         for i, expr in enumerate(result):
-            sac.assign_unique("coeff%d" % i, expr)
+            sac.assign_unique(f"coeff{i}", expr)
         sac.run_global_cse()
         insns = to_loopy_insns(sac.assignments.items())
         counter = pymbolic.mapper.flop_counter.CSEAwareFlopCounter()

examples/curve-pot.py

@@ -32,7 +32,7 @@ def process_kernel(knl, what_operator):
     #     from sumpy.kernel import DirectionalTargetDerivative
     #     knl = DirectionalTargetDerivative(knl)
     else:
-        raise RuntimeError("unrecognized operator '%s'" % what_operator)
+        raise RuntimeError(f"unrecognized operator '{what_operator}'")
 
     return source_knl, target_knl
 

setup.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 
 import os
 from setuptools import setup
@@ -23,27 +22,33 @@ def find_git_revision(tree_root):
     # setup.py.
 
     from os.path import join, exists, abspath
+
     tree_root = abspath(tree_root)
 
     if not exists(join(tree_root, ".git")):
         return None
 
     from subprocess import Popen, PIPE, STDOUT
-    p = Popen(["git", "rev-parse", "HEAD"], shell=False,
-              stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True,
-              cwd=tree_root)
-    (git_rev, _) = p.communicate()
 
-    import sys
-    if sys.version_info >= (3,):
-        git_rev = git_rev.decode()
+    p = Popen(
+        ["git", "rev-parse", "HEAD"],
+        shell=False,
+        stdin=PIPE,
+        stdout=PIPE,
+        stderr=STDOUT,
+        close_fds=True,
+        cwd=tree_root,
+    )
+    (git_rev, _) = p.communicate()
 
+    git_rev = git_rev.decode()
     git_rev = git_rev.rstrip()
 
     retcode = p.returncode
     assert retcode is not None
     if retcode != 0:
         from warnings import warn
+
         warn("unable to find git revision")
         return None
 
@@ -52,53 +57,54 @@ def find_git_revision(tree_root):
 
 def write_git_revision(package_name):
     from os.path import dirname, join
+
     dn = dirname(__file__)
     git_rev = find_git_revision(dn)
 
     with open(join(dn, package_name, "_git_rev.py"), "w") as outf:
-        outf.write('GIT_REVISION = "%s"\n' % git_rev)
+        outf.write(f'GIT_REVISION = "{git_rev}"\n')
 
 
 write_git_revision("sumpy")
 
 # }}}
 
 
-setup(name="sumpy",
-      version=ver_dic["VERSION_TEXT"],
-      description="Fast summation in Python",
-      long_description="""
+setup(
+    name="sumpy",
+    version=ver_dic["VERSION_TEXT"],
+    description="Fast summation in Python",
+    long_description="""
       Code-generating FMM etc.
       """,
-      classifiers=[
-          "Development Status :: 3 - Alpha",
-          "Intended Audience :: Developers",
-          "Intended Audience :: Other Audience",
-          "Intended Audience :: Science/Research",
-          "License :: OSI Approved :: MIT License",
-          "Natural Language :: English",
-          "Programming Language :: Python",
-          "Topic :: Scientific/Engineering",
-          "Topic :: Scientific/Engineering :: Information Analysis",
-          "Topic :: Scientific/Engineering :: Mathematics",
-          "Topic :: Scientific/Engineering :: Visualization",
-          "Topic :: Software Development :: Libraries",
-          "Topic :: Utilities",
-          ],
-
-      author="Andreas Kloeckner",
-      author_email="inform@tiker.net",
-      license="MIT",
-      packages=["sumpy", "sumpy.expansion"],
-
-      python_requires="~=3.6",
-      install_requires=[
-          "pytools>=2021.1.1",
-          "loopy>=2021.1",
-          "boxtree>=2018.1",
-          "pytest>=2.3",
-          "pyrsistent>=0.16.0",
-          "dataclasses>=0.7;python_version<='3.6'",
-          "sympy>=0.7.2",
-          "pymbolic>=2021.1",
-          ])
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Other Audience",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: MIT License",
+        "Natural Language :: English",
+        "Programming Language :: Python",
+        "Topic :: Scientific/Engineering",
+        "Topic :: Scientific/Engineering :: Information Analysis",
+        "Topic :: Scientific/Engineering :: Mathematics",
+        "Topic :: Scientific/Engineering :: Visualization",
+        "Topic :: Software Development :: Libraries",
+        "Topic :: Utilities",
+    ],
+    author="Andreas Kloeckner",
+    author_email="inform@tiker.net",
+    license="MIT",
+    packages=["sumpy", "sumpy.expansion"],
+    python_requires="~=3.6",
+    install_requires=[
+        "pytools>=2021.1.1",
+        "loopy>=2021.1",
+        "boxtree>=2018.1",
+        "pytest>=2.3",
+        "pyrsistent>=0.16.0",
+        "dataclasses>=0.7;python_version<='3.6'",
+        "sympy>=0.7.2",
+        "pymbolic>=2021.1",
+    ],
+)

sumpy/codegen.py

@@ -274,7 +274,7 @@ def map_call(self, expr, rec_self=None, *args):
                     2**(-k)*sum(
                         (-1)**idx*int(sym.binomial(k, idx)) * function(i, arg)
                         for idx, i in enumerate(range(order-k, order+k+1, 2))),
-                    "d%d_%s_%s" % (n_derivs, function.name, order_str))
+                    f"d{n_derivs}_{function.name}_{order_str}")
         else:
             return CSECachingIdentityMapper.map_call(
                     rec_self or self, expr, rec_self, *args)
@@ -309,8 +309,8 @@ def wrap_in_cse(self, expr, prefix):
 
     @memoize_method
     def bessel_jv_two(self, order, arg):
-        name_om1 = self.name_gen("bessel_%d" % (order-1))
-        name_o = self.name_gen("bessel_%d" % order)
+        name_om1 = self.name_gen(f"bessel_{order - 1}")
+        name_o = self.name_gen(f"bessel_{order}")
         self.assignments.append(
                 make_assignment(
                     (prim.Variable(name_om1), prim.Variable(name_o),),
@@ -329,16 +329,15 @@ def bessel_j(self, order, arg):
         elif order < 0:
             return self.wrap_in_cse(
                     (-1)**order*self.bessel_j(-order, arg),
-                    "bessel_j_neg%d" % -order)
+                    f"bessel_j_neg{-order}")
         else:
             assert abs(order) < top_order
 
             # AS (9.1.27)
             nu = order+1
             return self.wrap_in_cse(
-                    2*nu/arg*self.bessel_j(nu, arg)
-                    - self.bessel_j(nu+1, arg),
-                    "bessel_j_%d" % order)
+                    2*nu/arg*self.bessel_j(nu, arg) - self.bessel_j(nu+1, arg),
+                    f"bessel_j_{order}")
 
     # }}}
 
@@ -366,14 +365,13 @@ def hankel_1(self, order, arg):
             nu = -order
             return self.wrap_in_cse(
                     (-1) ** nu * self.hankel_1(nu, arg),
-                    "hank1_neg%d" % nu)
+                    f"hank1_neg{nu}")
         elif order > 1:
             # AS (9.1.27)
             nu = order-1
             return self.wrap_in_cse(
-                    2*nu/arg*self.hankel_1(nu, arg)
-                    - self.hankel_1(nu-1, arg),
-                    "hank1_%d" % order)
+                    2*nu/arg*self.hankel_1(nu, arg) - self.hankel_1(nu-1, arg),
+                    f"hank1_{order}")
         else:
             raise AssertionError()
 
@@ -463,8 +461,8 @@ def map_constant(self, expr, *args):
             expr_as_float = self.float_type(expr)
             if int(expr_as_float) != int(expr):
                 from warnings import warn
-                warn("Converting '%d' to '%s' loses digits"
-                        % (expr, self.float_type.__name__))
+                warn(f"Converting '{expr}' to "
+                     f"'{self.float_type.__name__}' loses digits")
 
             # Suppress further warnings.
             self.warn = False
@@ -684,15 +682,15 @@ def cmb_mapper(expr):
             return expr
 
     def convert_expr(name, expr):
-        logger.debug("generate expression for: %s" % name)
+        logger.debug("generate expression for: %s", name)
         expr = cmb_mapper(expr)
         for m in pymbolic_expr_maps:
             expr = m(expr)
         return expr
 
     assignments = [(name, convert_expr(name, expr)) for name, expr in assignments]
     from pytools import UniqueNameGenerator
-    name_gen = UniqueNameGenerator(set([name for name, expr in assignments]))
+    name_gen = UniqueNameGenerator({name for name, expr in assignments})
 
     result = []
     bessel_sub = BesselSubstitutor(