Convert str.format calls to f-strings

Rewrite every str.format call site in gemd and tests as an f-string. The
rendered strings are unchanged, since both forms dispatch to __format__.

Ruff's UP032 rule generated 44 of these. It skipped two call sites, which
this commit rewrites by hand: each nested a double-quoted string inside its
format arguments, and an f-string expression cannot reuse the enclosing
quote character before Python 3.12. Both now use single quotes inside the
expression, which Python 3.9 accepts.

Leave UP032 out of the ruff rule selection. This is a one-time improvement
rather than a standing rule.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: kroenlein

gemd/demo/cake.py

@@ -279,17 +279,15 @@ def _make_ingredient(*, material, process, **kwargs):
             tags=list(material.tags),
             material=material,
             process=process,
-            uids={
-                DEMO_SCOPE: "{}--{}".format(material.uids[DEMO_SCOPE], process.uids[DEMO_SCOPE])
-            },
+            uids={DEMO_SCOPE: f"{material.uids[DEMO_SCOPE]}--{process.uids[DEMO_SCOPE]}"},
             **kwargs,
         )
 
     def _make_material(
         *, material_name, template, process_tmpl_name, process_kwargs, **material_kwargs
     ):
         """Convenience method to reuse material name in creating a material's arguments."""
-        process_name = "{} {}".format(process_tmpl_name, material_name)
+        process_name = f"{process_tmpl_name} {material_name}"
         return MaterialSpec(
             name=material_name,
             uids={DEMO_SCOPE: material_name.lower().replace(" ", "-")},
@@ -725,22 +723,22 @@ def _randomize_object(item: BaseEntity):
         if not isinstance(item, (MaterialRun, ProcessRun, IngredientRun)):
             return
 
-        item.add_uid(DEMO_SCOPE, "{}-{}".format(item.spec.uids[DEMO_SCOPE], run_key))
+        item.add_uid(DEMO_SCOPE, f"{item.spec.uids[DEMO_SCOPE]}-{run_key}")
         if item.spec.tags is not None:
             item.tags = list(item.spec.tags)
         if item.spec.notes:  # Neither None nor empty string
-            item.notes = 'The spec says "{}"'.format(item.spec.notes)
+            item.notes = f'The spec says "{item.spec.notes}"'
         if isinstance(item, MaterialRun):
             if "raw material" in item.tags:
                 if "produce" in item.tags:
                     supplier = random.choice(producers)
                 else:
                     supplier = random.choice(drygoods)
-                item.name = "{} {}".format(supplier, item.spec.name)
+                item.name = f"{supplier} {item.spec.name}"
         if isinstance(item, ProcessRun):
             if item.template.name == "Procuring":
                 item.source = PerformedSource(performed_by="hamilton", performed_date="2015-02-17")
-                item.name = "{} {}".format(item.template.name, item.output_material.name)
+                item.name = f"{item.template.name} {item.output_material.name}"
             else:
                 item.source = cake_obj.process.source
         if isinstance(item, IngredientRun):
@@ -831,9 +829,7 @@ def _find_name(name, material):
         msr.spec.add_uid(DEMO_SCOPE, msr.spec.name.lower())
         msr.add_uid(
             DEMO_SCOPE,
-            "{}--{}-{}".format(
-                msr.spec.uids[DEMO_SCOPE], msr.material.spec.uids[DEMO_SCOPE], run_key
-            ),
+            f"{msr.spec.uids[DEMO_SCOPE]}--{msr.material.spec.uids[DEMO_SCOPE]}-{run_key}",
         )
 
     ######################################################################

gemd/demo/material_run_example.py

@@ -52,7 +52,7 @@ def _parse_value(val):
         try:
             unit = units.parse_units(toks[-1])
         except (ValueError, units.UndefinedUnitError):
-            print("Couldn't find {}".format(toks[-1]))
+            print(f"Couldn't find {toks[-1]}")
             unit = ""
 
         if std >= 0:
@@ -70,7 +70,7 @@ def _parse_value(val):
         except ValueError:
             return DiscreteCategorical(val)
     else:
-        raise ValueError("Couldn't parse {}".format(val))
+        raise ValueError(f"Couldn't parse {val}")
 
 
 def ingest_material_run(data, material_spec=None, process_run=None):
@@ -79,7 +79,7 @@ def ingest_material_run(data, material_spec=None, process_run=None):
         return [ingest_material_run(x, material_spec) for x in data]
 
     if not isinstance(data, dict):
-        raise ValueError("This ingester operates on dict, but got {}".format(type(data)))
+        raise ValueError(f"This ingester operates on dict, but got {type(data)}")
 
     material = MaterialRun("Material Run")
 

gemd/demo/strehlow_and_cook.py

@@ -472,7 +472,7 @@ def make_display_table(structured):
     """
     table = [[]]
     header_map = {
-        RealBounds: lambda bnd: "Mean({})".format(bnd.default_units),
+        RealBounds: lambda bnd: f"Mean({bnd.default_units})",
         CategoricalBounds: lambda bnd: "Category",
         CompositionBounds: lambda bnd: "Formula",
         type(None): lambda bnd: "Label",
@@ -487,7 +487,7 @@ def make_display_table(structured):
     column = structured["headers"][i_bandgap]
     table[0].insert(
         i_bandgap + 1,
-        "~".join(column["name"] + ["Std Deviation({})".format(column["bounds"].default_units)]),
+        "~".join(column["name"] + [f"Std Deviation({column['bounds'].default_units})"]),
     )
 
     content_map = {
@@ -540,7 +540,7 @@ def make_display_table(structured):
     full_table = make_strehlow_table(full_compounds)
     small_table = minimal_subset(full_table["content"])
     todo = set(_fingerprint(x) for x in small_table)
-    print("Total number of prototypes: {}".format(len(small_table)))
+    print(f"Total number of prototypes: {len(small_table)}")
 
     reduced_list = []
     for raw, clean in zip(imported_table, full_table["content"]):

gemd/entity/attribute/base_attribute.py

@@ -99,9 +99,7 @@ def template(self, template: Optional[Union[AttributeTemplate, LinkByUID]]):
                 self._check(template, self.value)
             self._template = template
         else:
-            raise TypeError(
-                "template must be a BaseAttributeTemplate or LinkByUID: {}".format(template)
-            )
+            raise TypeError(f"template must be a BaseAttributeTemplate or LinkByUID: {template}")
 
     @staticmethod
     @abstractmethod

gemd/entity/bounds/base_bounds.py

@@ -38,7 +38,7 @@ def contains(self, bounds: Union[BaseBoundsType, BaseValueType]):
             bounds = bounds._to_bounds()
         if isinstance(bounds, BaseBounds):
             return True
-        raise TypeError("{} is not a Bounds object".format(bounds))
+        raise TypeError(f"{bounds} is not a Bounds object")
 
     @abstractmethod
     def union(self, *others: Union[BaseBoundsType, BaseValueType]) -> BaseBoundsType:

gemd/entity/bounds/composition_bounds.py

@@ -40,7 +40,7 @@ def components(self, value: Iterable[str]):
         elif isinstance(value, set):
             self._components = value
         else:
-            raise ValueError("Components must be a list, tuple, or set: {}".format(value))
+            raise ValueError(f"Components must be a list, tuple, or set: {value}")
 
         if not all(isinstance(x, str) for x in self.components):
             raise ValueError("All the components must be strings")

gemd/entity/case_insensitive_dict.py

@@ -161,9 +161,7 @@ def update(self, mapping: Optional[Mapping[str, Any]] = None, **kwargs) -> None:
                 prev = self.lowercase_dict[key.lower()]
                 if prev != key:
                     raise ValueError(
-                        "Key '{}' already exists in dict with different case: '{}'".format(
-                            key, prev
-                        )
+                        f"Key '{key}' already exists in dict with different case: '{prev}'"
                     )
         if no_mapping:
             super().update(**kwargs)
@@ -185,7 +183,5 @@ def _register_key(self, key: str) -> None:
         """
         prev = self.lowercase_dict.get(key.lower())
         if prev is not None and prev != key:
-            raise ValueError(
-                "Key '{}' already exists in dict with different case: '{}'".format(key, prev)
-            )
+            raise ValueError(f"Key '{key}' already exists in dict with different case: '{prev}'")
         self.lowercase_dict[key.lower()] = key

gemd/entity/dict_serializable.py

@@ -82,9 +82,7 @@ def from_dict(cls, d: Mapping[str, Any]) -> DictSerializableType:
             if name in expected_arg_names:
                 kwargs[name] = arg
             elif name != "type":
-                logger.warning(
-                    "Ignoring unexpected keyword argument in {}: {}".format(cls.__name__, name)
-                )
+                logger.warning(f"Ignoring unexpected keyword argument in {cls.__name__}: {name}")
         # noinspection PyArgumentList
         # DictSerializable's constructor is not intended for use,
         # but all of its children will use from_dict like this.

gemd/entity/object/ingredient_run.py

@@ -122,7 +122,7 @@ def material(self, material: Union[MaterialRun, LinkByUID]):
             self._material = material
         else:
             raise TypeError(
-                "IngredientRun.material must be a MaterialRun or LinkByUID: {}".format(material)
+                f"IngredientRun.material must be a MaterialRun or LinkByUID: {material}"
             )
 
     @property
@@ -141,9 +141,7 @@ def process(self, process: Union[ProcessRun, LinkByUID]):
             if isinstance(process, ProcessRun):
                 process.ingredients.append(self)
         else:
-            raise TypeError(
-                "IngredientRun.process must be a ProcessRun or LinkByUID: {}".format(process)
-            )
+            raise TypeError(f"IngredientRun.process must be a ProcessRun or LinkByUID: {process}")
 
     @staticmethod
     def _spec_type() -> Type:

gemd/entity/object/ingredient_spec.py

@@ -133,7 +133,7 @@ def process(self, process: Union[ProcessSpec, LinkByUID]):
                 process.ingredients.append(self)
         else:
             raise TypeError(
-                "IngredientSpec.process must be a ProcessSpec or LinkByUID: {}".format(process)
+                f"IngredientSpec.process must be a ProcessSpec or LinkByUID: {process}"
             )
 
     @property