Python: Clean up f-strings

5 files changed, 44 insertions, 52 deletions

diff --git a/build-aux/stack.c.gen b/build-aux/stack.c.gen
index 5a983cb..a8e2149 100755
--- a/build-aux/stack.c.gen
+++ b/build-aux/stack.c.gen
@@ -71,7 +71,7 @@ def parse_vcg(reader: typing.TextIO) -> typing.Iterator[VCGElem]:
             k = m.group(1)
             v = m.group(2)
             if k in elem.attrs:
-                _raise(f"duplicate key: {repr(k)}")
+                _raise(f"duplicate key: {k!r}")
             if v.startswith('"'):
 
                 def unesc(esc: re.Match[str]) -> str:
@@ -83,7 +83,7 @@ def parse_vcg(reader: typing.TextIO) -> typing.Iterator[VCGElem]:
                         case "\\":
                             return "\\"
                         case _:
-                            _raise(f"invalid escape code {repr(esc.group(0))}")
+                            _raise(f"invalid escape code {esc.group(0)!r}")
 
                 v = re_esc.sub(unesc, v[1:-1])
             elem.attrs[k] = v
@@ -107,7 +107,7 @@ class BaseName:
 
     def __init__(self, content: str) -> None:
         if ":" in content:
-            raise ValueError(f"invalid non-qualified name: {repr(content)}")
+            raise ValueError(f"invalid non-qualified name: {content!r}")
         self._content = content
 
     def __str__(self) -> str:
@@ -240,9 +240,7 @@ def analyze(
                             if elem.attrs.get("shape", "") != "ellipse":
                                 m = re_node_label.fullmatch(v)
                                 if not m:
-                                    raise ValueError(
-                                        f"unexpected label value {repr(v)}"
-                                    )
+                                    raise ValueError(f"unexpected label value {v!r}")
                                 node.location = m.group("location")
                                 node.usage_kind = typing.cast(
                                     UsageKind, m.group("usage_kind")
@@ -251,13 +249,13 @@ def analyze(
                                 node.ndynamic = int(m.group("ndynamic"))
                         case "shape":
                             if v != "ellipse":
-                                raise ValueError(f"unexpected shape value {repr(v)}")
+                                raise ValueError(f"unexpected shape value {v!r}")
                             skip = True
                         case _:
-                            raise ValueError(f"unknown edge key {repr(k)}")
+                            raise ValueError(f"unknown edge key {k!r}")
                 if not skip:
                     if node.funcname in graph:
-                        raise ValueError(f"duplicate node {repr(str(node.funcname))}")
+                        raise ValueError(f"duplicate node {str(node.funcname)!r}")
                     graph[node.funcname] = node
                     if ":" in str(node.funcname):
                         basename = node.funcname.base()
@@ -276,9 +274,9 @@ def analyze(
                         case "label":
                             pass
                         case _:
-                            raise ValueError(f"unknown edge key {repr(k)}")
+                            raise ValueError(f"unknown edge key {k!r}")
                 if caller is None or callee is None:
-                    raise ValueError(f"incomplete edge: {repr(elem.attrs)}")
+                    raise ValueError(f"incomplete edge: {elem.attrs!r}")
                 if caller not in graph:
                     raise ValueError(f"unknown caller: {caller}")
                 if str(callee) == "__indirect_call":
@@ -289,7 +287,7 @@ def analyze(
                 else:
                     graph[caller].calls[callee] = False
             case _:
-                raise ValueError(f"unknown elem type {repr(elem.typ)}")
+                raise ValueError(f"unknown elem type {elem.typ!r}")
 
     for ci_fname in ci_fnames:
         with open(ci_fname, "r", encoding="utf-8") as fh:
@@ -298,7 +296,7 @@ def analyze(
 
     for node in app.extra_nodes():
         if node.funcname in graph:
-            raise ValueError(f"duplicate node {repr(str(node.funcname))}")
+            raise ValueError(f"duplicate node {str(node.funcname)!r}")
         graph[node.funcname] = node
 
     missing: set[QName] = set()
@@ -397,7 +395,7 @@ def read_source(location: str) -> str:
     re_location = re.compile(r"(?P<filename>.+):(?P<row>[0-9]+):(?P<col>[0-9]+)")
     m = re_location.fullmatch(location)
     if not m:
-        raise ValueError(f"unexpected label value {repr(location)}")
+        raise ValueError(f"unexpected label value {location!r}")
     filename = m.group("filename")
     row = int(m.group("row")) - 1
     col = int(m.group("col")) - 1
@@ -1493,12 +1491,12 @@ def main(
             if val.nstatic == 0:
                 continue
             print(
-                f"{name.ljust(namelen)} {str(val.nstatic).rjust(numlen)}"
+                f"{name:<{namelen}} {val.nstatic:>{numlen}}"
                 + (f" * {val.cnt}" if val.cnt != 1 else "")
             )
         print(sep2)
-        print(f"{'Total'.ljust(namelen)} {str(nsum).rjust(numlen)}")
-        print(f"{'Maximum'.ljust(namelen)} {str(nmax).rjust(numlen)}")
+        print(f"{'Total':<{namelen}} {nsum:>{numlen}}")
+        print(f"{'Maximum':<{namelen}} {nmax:>{numlen}}")
         print(sep1)
 
     def next_power_of_2(x: int) -> int:
@@ -1542,8 +1540,8 @@ def main(
         if comment:
             print(f"/* {name}".ljust(len(prefix) + namelen), end="")
         else:
-            print(f"{prefix}{name.ljust(namelen)}", end="")
-        print(f" = {str(size).rjust(sizelen)};", end="")
+            print(f"{prefix}{name:<{namelen}}", end="")
+        print(f" = {size:>{sizelen}};", end="")
         if comment:
             print(" */", end="")
         elif eqn:
@@ -1557,7 +1555,7 @@ def main(
             False,
             row.name,
             row.size,
-            f"LM_NEXT_POWER_OF_2({str(row.base).rjust(baselen)}+{intrstack}+{stack_guard_size})-{stack_guard_size}",
+            f"LM_NEXT_POWER_OF_2({row.base:>{baselen}}+{intrstack}+{stack_guard_size})-{stack_guard_size}",
         )
     print_row(True, "TOTAL (inc. stack guard)", sizesum)
     if mainrow:
@@ -1565,7 +1563,7 @@ def main(
             True,
             "MAIN/KERNEL",
             mainrow.size,
-            f"                   {str(mainrow.base).rjust(baselen)}+{intrstack}",
+            f"                   {mainrow.base:>{baselen}}+{intrstack}",
         )
     print()
     print("/*")
diff --git a/gdb-helpers/libcr.py b/gdb-helpers/libcr.py
index f74a702..fcfd86e 100644
--- a/gdb-helpers/libcr.py
+++ b/gdb-helpers/libcr.py
@@ -1,6 +1,6 @@
 # gdb-helpers/libcr.py - GDB helpers for libcr.
 #
-# Copyright (C) 2024  Luke T. Shumaker <lukeshu@lukeshu.com>
+# Copyright (C) 2024-2025  Luke T. Shumaker <lukeshu@lukeshu.com>
 # SPDX-License-Identifier: AGPL-3.0-or-later
 
 import contextlib
@@ -428,11 +428,11 @@ class CrSelectCommand(gdb.Command):
                 crs += [cr]
         match len(crs):
             case 0:
-                raise gdb.GdbError(f"No such coroutine: {repr(name)}")
+                raise gdb.GdbError(f"No such coroutine: {name!r}")
             case 1:
                 return crs[0]
             case _:
-                raise gdb.GdbError(f"Ambiguous name, must use Id: {repr(name)}")
+                raise gdb.GdbError(f"Ambiguous name, must use Id: {name!r}")
 
 
 # Wire it all in ###############################################################
diff --git a/gdb-helpers/rp2040.py b/gdb-helpers/rp2040.py
index 45bdbc7..087974d 100644
--- a/gdb-helpers/rp2040.py
+++ b/gdb-helpers/rp2040.py
@@ -32,7 +32,7 @@ def box(title: str, content: str) -> str:
 
     ret = "┏━[" + title + "]" + ("━" * (width - len(title) - 5)) + "┓\n"
     for line in content.split("\n"):
-        ret += f"┃ {line.ljust(width-4)} ┃\n"
+        ret += f"┃ {line:<{width-4}} ┃\n"
     ret += "┗" + ("━" * (width - 2)) + "┛"
     return ret
 
diff --git a/lib9p/idl.gen b/lib9p/idl.gen
index 65ff734..eaeca49 100755
--- a/lib9p/idl.gen
+++ b/lib9p/idl.gen
@@ -440,9 +440,7 @@ enum {idprefix}version {{
             continue
         msg = id2typ[n]
         ret += ifdef_push(1, c_ver_ifdef(msg.in_versions))
-        ret += (
-            f"\t{idprefix.upper()}TYP_{msg.typname.ljust(namewidth)} = {msg.msgid},\n"
-        )
+        ret += f"\t{idprefix.upper()}TYP_{msg.typname:<{namewidth}} = {msg.msgid},\n"
     ret += ifdef_pop(0)
     ret += "};\n"
 
@@ -464,7 +462,7 @@ enum {idprefix}version {{
             ret = ""
             v_width = max(len(c_ver_enum(v)) for v in typ.in_versions)
             for version, line in lines.items():
-                ret += f"/* {c_ver_enum(version).ljust(v_width)}: {line} */\n"
+                ret += f"/* {c_ver_enum(version):<{v_width}}: {line} */\n"
             return ret
 
     for typ in topo_sorted(typs):
@@ -496,7 +494,7 @@ enum {idprefix}version {{
                 prefix = f"{idprefix.upper()}{typ.typname.upper()}_"
                 namewidth = max(len(name) for name in typ.vals)
                 for name, val in typ.vals.items():
-                    ret += f"#define {prefix}{name.ljust(namewidth)} (({c_typename(typ)})UINT{typ.static_size*8}_C({val}))\n"
+                    ret += f"#define {prefix}{name:<{namewidth}} (({c_typename(typ)})UINT{typ.static_size*8}_C({val}))\n"
             case idl.Bitfield():
                 ret += f"typedef {c_typename(typ.prim)} {c_typename(typ)};\n"
 
@@ -581,7 +579,7 @@ enum {idprefix}version {{
                     if member.val:
                         continue
                     ret += ifdef_push(2, c_ver_ifdef(member.in_versions))
-                    ret += f"\t{c_typename(member.typ, member).ljust(typewidth)}  {'*' if member.cnt else ' '}{member.membname};\n"
+                    ret += f"\t{c_typename(member.typ, member):<{typewidth}}  {'*' if member.cnt else ' '}{member.membname};\n"
                 ret += ifdef_pop(1)
                 ret += "};\n"
         del typ
diff --git a/lib9p/idl/__init__.py b/lib9p/idl/__init__.py
index 70eaf57..e7b3670 100644
--- a/lib9p/idl/__init__.py
+++ b/lib9p/idl/__init__.py
@@ -176,12 +176,10 @@ class StructMember:
         assert self.cnt
         if not isinstance(self.cnt.typ, Primitive):
             raise ValueError(
-                f"list count must be an integer type: {repr(self.cnt.membname)}"
+                f"list count must be an integer type: {self.cnt.membname!r}"
             )
         if self.cnt.val:  # TODO: allow this?
-            raise ValueError(
-                f"list count may not have ,val=: {repr(self.cnt.membname)}"
-            )
+            raise ValueError(f"list count may not have ,val=: {self.cnt.membname!r}")
         return 0
 
     @property
@@ -189,17 +187,15 @@ class StructMember:
         assert self.cnt
         if not isinstance(self.cnt.typ, Primitive):
             raise ValueError(
-                f"list count must be an integer type: {repr(self.cnt.membname)}"
+                f"list count must be an integer type: {self.cnt.membname!r}"
             )
         if self.cnt.val:  # TODO: allow this?
-            raise ValueError(
-                f"list count may not have ,val=: {repr(self.cnt.membname)}"
-            )
+            raise ValueError(f"list count may not have ,val=: {self.cnt.membname!r}")
         if self.cnt.max:
             # TODO: be more flexible?
             if len(self.cnt.max.tokens) != 1:
                 raise ValueError(
-                    f"list count ,max= may only have 1 token: {repr(self.cnt.membname)}"
+                    f"list count ,max= may only have 1 token: {self.cnt.membname!r}"
                 )
             match tok := self.cnt.max.tokens[0]:
                 case ExprLit():
@@ -210,7 +206,7 @@ class StructMember:
                     return (1 << 63) - 1
                 case _:
                     raise ValueError(
-                        f'list count ,max= only allows literal, "s32_max", and "s64_max" tokens: {repr(self.cnt.membname)}'
+                        f'list count ,max= only allows literal, "s32_max", and "s64_max" tokens: {self.cnt.membname!r}'
                     )
         return (1 << (self.cnt.typ.value * 8)) - 1
 
@@ -319,10 +315,10 @@ def parse_numspec(ver: str, n: Number, spec: str) -> None:
         name = m.group("name")
         val = m.group("val")
         if name in n.vals:
-            raise ValueError(f"{n.typname}: name {repr(name)} already assigned")
+            raise ValueError(f"{n.typname}: name {name!r} already assigned")
         n.vals[name] = val
     else:
-        raise SyntaxError(f"invalid num spec {repr(spec)}")
+        raise SyntaxError(f"invalid num spec {spec!r}")
 
 
 def parse_bitspec(ver: str, bf: Bitfield, spec: str) -> None:
@@ -391,7 +387,7 @@ def parse_members(ver: str, env: dict[str, Type], struct: Struct, specs: str) ->
     for spec in specs.split():
         m = re.fullmatch(re_memberspec, spec)
         if not m:
-            raise SyntaxError(f"invalid member spec {repr(spec)}")
+            raise SyntaxError(f"invalid member spec {spec!r}")
 
         member = StructMember()
         member.in_versions = {ver}
@@ -401,12 +397,12 @@ def parse_members(ver: str, env: dict[str, Type], struct: Struct, specs: str) ->
             raise ValueError(f"duplicate member name {member.membname!r}")
 
         if m.group("typ") not in env:
-            raise NameError(f"Unknown type {repr(m.group('typ'))}")
+            raise NameError(f"Unknown type {m.group('typ')!r}")
         member.typ = env[m.group("typ")]
 
         if cnt := m.group("cnt"):
             if len(struct.members) == 0 or struct.members[-1].membname != cnt:
-                raise ValueError(f"list count must be previous item: {repr(cnt)}")
+                raise ValueError(f"list count must be previous item: {cnt!r}")
             cnt_mem = struct.members[-1]
             member.cnt = cnt_mem
             _ = member.max_cnt  # force validation
@@ -462,10 +458,10 @@ def parse_file(
     def get_type(name: str, tc: type[T]) -> T:
         nonlocal env
         if name not in env:
-            raise NameError(f"Unknown type {repr(name)}")
+            raise NameError(f"Unknown type {name!r}")
         ret = env[name]
         if (not isinstance(ret, tc)) or (ret.__class__.__name__ != tc.__name__):
-            raise NameError(f"Type {repr(ret.typname)} is not a {tc.__name__}")
+            raise NameError(f"Type {ret.typname!r} is not a {tc.__name__}")
         return ret
 
     with open(filename, "r", encoding="utf-8") as fh:
@@ -516,7 +512,7 @@ def parse_file(
                                 env[typ.typname] = typ
                         if symname != "*" and not found:
                             raise ValueError(
-                                f"import: {m.group('file')}: no symbol {repr(symname)}"
+                                f"import: {m.group('file')}: no symbol {symname!r}"
                             )
                 elif m := re.fullmatch(re_line_num, line):
                     num = Number()
@@ -655,18 +651,18 @@ class Parser:
         ret_typs: dict[str, UserType] = {}
         for version, typs in self.cache.values():
             if version in ret_versions:
-                raise ValueError(f"duplicate protocol version {repr(version)}")
+                raise ValueError(f"duplicate protocol version {version!r}")
             ret_versions.add(version)
             for typ in typs:
                 if typ.typname in ret_typs:
                     if typ != ret_typs[typ.typname]:
-                        raise ValueError(f"duplicate type name {repr(typ.typname)}")
+                        raise ValueError(f"duplicate type name {typ.typname!r}")
                 else:
                     ret_typs[typ.typname] = typ
         msgids: set[int] = set()
         for typ in ret_typs.values():
             if isinstance(typ, Message):
                 if typ.msgid in msgids:
-                    raise ValueError(f"duplicate msgid {repr(typ.msgid)}")
+                    raise ValueError(f"duplicate msgid {typ.msgid!r}")
                 msgids.add(typ.msgid)
         return ret_versions, list(ret_typs.values())