Python: Clean up f-strings

1 files changed, 17 insertions, 21 deletions

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())