REF: Use f-strings. Min Python3.6+ (#278)

* MNT: Bumped Python version reqs to 3.6+

* ENH: Updated string formatting to use f-strings

* ENH: Resolved individual code comments in #278

* ENH: __init__.py refactored to use f-strings

* ENH: cli.py refactored to use f-strings

* ENH: pdoc/test/__init__.py refactored to use f-strings

* ENH: pdoc/templates/html.mako refactored to use f-strings

* ENH: pdoc/html_helpers.py refactored to use f-strings

* ENH: pdoc/templates/pdf.mako refactored to use f-strings

* Update pdoc/html_helpers.py

Reworded variable name to be more meaningful

Author: tnwei

pdoc/__init__.py

@@ -128,7 +128,7 @@ def _get_config(**kwargs):
                   | {'module', 'modules', 'http_server', 'external_links', 'search_query'})
     invalid_keys = {k: v for k, v in kwargs.items() if k not in known_keys}
     if invalid_keys:
-        warn('Unknown configuration variables (not in config.mako): {}'.format(invalid_keys))
+        warn(f'Unknown configuration variables (not in config.mako): {invalid_keys}')
     config.update(kwargs)
 
     if 'search_query' in config:
@@ -150,10 +150,9 @@ def _render_template(template_name, **kwargs):
     try:
         t = tpl_lookup.get_template(template_name)
     except TopLevelLookupException:
-        raise OSError(
-            "No template found at any of: {}".format(
-                ', '.join(path.join(p, template_name.lstrip("/"))
-                          for p in tpl_lookup.directories)))
+        paths = [path.join(p, template_name.lstrip('/')) for p in tpl_lookup.directories]
+        raise OSError(f"No template found at any of: {', '.join(paths)}")
+
     try:
         return t.render(**config).strip()
     except Exception:
@@ -224,8 +223,7 @@ def _module_path(module):
             try:
                 module = importlib.import_module(module_path)
             except Exception as e:
-                raise ImportError('Error importing {!r}: {}: {}'
-                                  .format(module, e.__class__.__name__, e))
+                raise ImportError(f'Error importing {module!r}: {e.__class__.__name__}: {e}')
 
     assert inspect.ismodule(module)
     # If this is pdoc itself, return without reloading. Otherwise later
@@ -272,7 +270,7 @@ def _pep224_docstrings(doc_obj: Union['Module', 'Class'], *,
             # Don't emit a warning for builtins that don't have source available
             is_builtin = getattr(doc_obj.obj, '__module__', None) == 'builtins'
             if not is_builtin:
-                warn("Couldn't read PEP-224 variable docstrings from {!r}: {}".format(doc_obj, exc),
+                warn(f"Couldn't read PEP-224 variable docstrings from {doc_obj!r}: {exc}",
                      stacklevel=3 + int(isinstance(doc_obj, Class)))
             return {}, {}
 
@@ -409,7 +407,7 @@ def _toposort(graph: Mapping[T, Set[T]]) -> Generator[T, None, None]:
         yield from ordered
         if not ordered:
             break
-    assert not graph, "A cyclic dependency exists amongst %r" % graph
+    assert not graph, f"A cyclic dependency exists amongst {graph!r}"
 
 
 def link_inheritance(context: Context = None):
@@ -492,7 +490,7 @@ def __init__(self, name, module, obj, docstring=None):
         """
 
     def __repr__(self):
-        return '<{} {!r}>'.format(self.__class__.__name__, self.refname)
+        return f'<{self.__class__.__name__} {self.refname!r}>'
 
     @property  # type: ignore
     @lru_cache()
@@ -640,8 +638,8 @@ def __init__(self, module: Union[ModuleType, str], *, docfilter: Callable[[Doc],
                 try:
                     obj = getattr(self.obj, name)
                 except AttributeError:
-                    warn("Module {!r} doesn't contain identifier `{}` "
-                         "exported in `__all__`".format(self.module, name))
+                    warn(f"Module {self.module!r} doesn't contain identifier `{name}` "
+                         "exported in `__all__`")
                 if not _is_blacklisted(name, self):
                     obj = inspect.unwrap(obj)
                 public_objs.append((name, obj))
@@ -703,7 +701,7 @@ def iter_modules(paths):
                     continue
 
                 assert self.refname == self.name
-                fullname = "%s.%s" % (self.name, root)
+                fullname = f"{self.name}.{root}"
                 try:
                     m = Module(import_module(fullname),
                                docfilter=docfilter, supermodule=self,
@@ -767,20 +765,20 @@ def _link_inheritance(self):
             if docstring is True:
                 continue
 
-            refname = "%s.%s" % (self.refname, name)
+            refname = f"{self.refname}.{name}"
             if docstring in (False, None):
                 if docstring is None:
                     warn('Setting `__pdoc__[key] = None` is deprecated; '
                          'use `__pdoc__[key] = False` '
-                         '(key: {!r}, module: {!r}).'.format(name, self.name))
+                         f'(key: {name!r}, module: {self.name!r}).')
 
                 if name in self._skipped_submodules:
                     continue
 
                 if (not name.endswith('.__init__') and
                         name not in self.doc and refname not in self._context):
-                    warn('__pdoc__-overriden key {!r} does not exist '
-                         'in module {!r}'.format(name, self.name))
+                    warn(f'__pdoc__-overriden key {name!r} does not exist '
+                         f'in module {self.name!r}')
 
                 obj = self.find_ident(name)
                 cls = getattr(obj, 'cls', None)
@@ -800,8 +798,8 @@ def _link_inheritance(self):
             if isinstance(dobj, External):
                 continue
             if not isinstance(docstring, str):
-                raise ValueError('__pdoc__ dict values must be strings;'
-                                 '__pdoc__[{!r}] is of type {}'.format(name, type(docstring)))
+                raise ValueError('__pdoc__ dict values must be strings; '
+                                 f'__pdoc__[{name!r}] is of type {type(docstring)}')
             dobj.docstring = inspect.cleandoc(docstring)
 
         # Now after docstrings are set correctly, continue the
@@ -1044,7 +1042,7 @@ def _method_type(cls: type, name: str):
                 if isinstance(c.__dict__[name], staticmethod):
                     return staticmethod
                 return None
-        raise RuntimeError("{}.{} not found".format(cls, name))
+        raise RuntimeError(f"{cls}.{name} not found")
 
     @property
     def refname(self) -> str:
@@ -1307,7 +1305,7 @@ def return_annotation(self, *, link=None) -> str:
         else:
             # Don't warn on variables. The annotation just isn't available.
             if not isinstance(self, Variable):
-                warn("Error handling return annotation for {!r}".format(self), stacklevel=3)
+                warn(f"Error handling return annotation for {self!r}", stacklevel=3)
 
         if annot is inspect.Parameter.empty or not annot:
             return ''
@@ -1469,10 +1467,10 @@ def _signature_from_string(self):
                 # See: https://github.com/pdoc3/pdoc/pull/148#discussion_r407114141
                 module_basename = self.module.name.rsplit('.', maxsplit=1)[-1]
                 if module_basename in string and module_basename not in _globals:
-                    string = re.sub(r'(?<!\.)\b{}\.\b'.format(module_basename), '', string)
+                    string = re.sub(fr'(?<!\.)\b{module_basename}\.\b', '', string)
 
                 try:
-                    exec('def {}: pass'.format(string), _globals, _locals)
+                    exec(f'def {string}: pass', _globals, _locals)
                 except SyntaxError:
                     continue
                 signature = inspect.signature(_locals[self.name])
@@ -1565,4 +1563,4 @@ def url(self, *args, **kwargs):
         """
         `External` objects return absolute urls matching `/{name}.ext`.
         """
-        return '/%s.ext' % self.name
+        return f'/{self.name}.ext'

pdoc/cli.py

@@ -129,8 +129,8 @@
 def _check_host_port(s):
     if s and ':' not in s:
         raise argparse.ArgumentTypeError(
-            "'{}' doesn't match '[HOST]:[PORT]'. "
-            "Specify `--http :` to use default hostname and port.".format(s))
+            f"'{s}' doesn't match '[HOST]:[PORT]'. "
+            "Specify `--http :` to use default hostname and port.")
     return s
 
 
@@ -141,7 +141,7 @@ def _check_host_port(s):
     metavar='HOST:PORT',
     help="When set, pdoc will run as an HTTP server providing documentation "
          "for specified modules. If you just want to use the default hostname "
-         "and port ({}:{}), set the parameter to :.".format(DEFAULT_HOST, DEFAULT_PORT),
+         f"and port ({DEFAULT_HOST}:{DEFAULT_PORT}), set the parameter to :.",
 )
 aa(
     "--skip-errors",
@@ -212,14 +212,14 @@ def do_GET(self):
             import_path = self.path[:-4].lstrip("/")
             resolved = self.resolve_ext(import_path)
             if resolved is None:  # Try to generate the HTML...
-                print("Generating HTML for %s on the fly..." % import_path, file=sys.stderr)
+                print(f"Generating HTML for {import_path} on the fly...", file=sys.stderr)
                 try:
                     out = pdoc.html(import_path.split(".")[0], **self.template_config)
                 except Exception as e:
-                    print('Error generating docs: {}'.format(e), file=sys.stderr)
+                    print(f'Error generating docs: {e}', file=sys.stderr)
                     # All hope is lost.
                     code = 404
-                    out = "External identifier <code>%s</code> not found." % import_path
+                    out = f"External identifier <code>{import_path}</code> not found."
             else:
                 return self.redirect(resolved)
         # Redirect '/pdoc' to '/pdoc/' so that relative links work
@@ -236,8 +236,11 @@ def do_GET(self):
                 import traceback
                 from html import escape
                 code = 404
-                out = "Error importing module <code>{}</code>:\n\n<pre>{}</pre>".format(
-                    self.import_path_from_req_url, escape(traceback.format_exc()))
+                out = (
+                    "Error importing module "
+                    f"<code>{self.import_path_from_req_url}</code>:\n\n"
+                    f"<pre>{escape(traceback.format_exc())}</pre>"
+                )
                 out = out.replace('\n', '<br>')
 
         self.send_response(code)
@@ -282,7 +285,7 @@ def exists(p):
             p = path.join(*parts[0:i])
             realp = exists(p)
             if realp is not None:
-                return "/%s#%s" % (realp.lstrip("/"), import_path)
+                return f"/{realp.lstrip('/')}#{import_path}"
         return None
 
     @property
@@ -312,8 +315,7 @@ def _quit_if_exists(m: pdoc.Module, ext: str):
 
     for pth in paths:
         if path.lexists(pth):
-            print("File '%s' already exists. Delete it, or run with --force" % pth,
-                  file=sys.stderr)
+            print(f"File '{pth}' already exists. Delete it, or run with --force", file=sys.stderr)
             sys.exit(1)
 
 
@@ -362,7 +364,7 @@ def _print_pdf(modules, **kwargs):
 
 
 def _warn_deprecated(option, alternative='', use_config_mako=False):
-    msg = 'Program option `{}` is deprecated.'.format(option)
+    msg = f'Program option `{option}` is deprecated.'
     if alternative:
         msg += ' Use `' + alternative + '`'
         if use_config_mako:
@@ -453,9 +455,8 @@ def main(_args=None):
             template_config[key] = value
         except Exception:
             raise ValueError(
-                'Error evaluating --config statement "{}". '
+                f'Error evaluating --config statement "{config_str}". '
                 'Make sure string values are quoted?'
-                .format(config_str)
             )
 
     if args.html_no_source:
@@ -470,8 +471,7 @@ def main(_args=None):
 
     if args.template_dir is not None:
         if not path.isdir(args.template_dir):
-            print('Error: Template dir {!r} is not a directory'.format(args.template_dir),
-                  file=sys.stderr)
+            print(f'Error: Template dir {args.template_dir!r} is not a directory', file=sys.stderr)
             sys.exit(1)
         pdoc.tpl_lookup.directories.insert(0, args.template_dir)
 
@@ -495,7 +495,7 @@ def main(_args=None):
                 with open(pth) as f:
                     sys.path.append(path.join(libdir, f.readline().rstrip()))
             except IOError:
-                warn('Invalid egg-link in venv: {!r}'.format(pth))
+                warn(f'Invalid egg-link in venv: {pth!r}')
 
     if args.http:
         template_config['link_prefix'] = "/"
@@ -508,9 +508,9 @@ def main(_args=None):
         host = host or DEFAULT_HOST
         port = int(port or DEFAULT_PORT)
 
-        print('Starting pdoc server on {}:{}'.format(host, port), file=sys.stderr)
+        print(f'Starting pdoc server on {host}:{port}', file=sys.stderr)
         httpd = HTTPServer((host, port), _WebDoc)
-        print("pdoc server ready at http://%s:%d" % (host, port), file=sys.stderr)
+        print(f"pdoc server ready at http://{host}:{port}", file=sys.stderr)
 
         # Allow tests to perform `pdoc.cli._httpd.shutdown()`
         global _httpd
@@ -537,7 +537,8 @@ def docfilter(obj, _filters=args.filter.strip().split(',')):
     if args.pdf:
         _print_pdf(modules, **template_config)
         import textwrap
-        print("""
+        PANDOC_CMD = textwrap.indent(_PANDOC_COMMAND, '    ')
+        print(f"""
 PDF-ready markdown written to standard output.
                               ^^^^^^^^^^^^^^^
 Convert this file to PDF using e.g. Pandoc:
@@ -562,7 +563,7 @@ def docfilter(obj, _filters=args.filter.strip().split(',')):
 
     wkhtmltopdf --encoding utf8 -s A4 --print-media-type pdf.html pdf.pdf
 
-or similar, at your own discretion.""".format(PANDOC_CMD=textwrap.indent(_PANDOC_COMMAND, '    ')),
+or similar, at your own discretion.""",
               file=sys.stderr)
         sys.exit(0)