Remove unnecessary .format.

MDANSE/Src/MDANSE/Chemistry/ChemicalEntity.py

@@ -51,15 +51,15 @@ class UnknownAtomError(Exception):
 
 class InvalidMoleculeError(Exception):
     def __init__(self, code):
-        self._message = "The atom {} is unknown".format(code)
+        self._message = f"The atom {code} is unknown"
 
     def __str__(self):
         return self._message
 
 
 class UnknownMoleculeError(Exception):
     def __init__(self, code):
-        self._message = "The molecule {} is unknown".format(code)
+        self._message = f"The molecule {code} is unknown"
 
     def __str__(self):
         return self._message
@@ -75,7 +75,7 @@ class InvalidResidueError(Exception):
 
 class UnknownResidueError(Exception):
     def __init__(self, code):
-        self._message = "The residue {} is unknown".format(code)
+        self._message = f"The residue {code} is unknown"
 
     def __str__(self):
         return self._message
@@ -138,7 +138,7 @@ def full_name(self) -> str:
         full_name = self.name
         parent = self._parent
         while parent is not None:
-            full_name = "{}.{}".format(parent.name, full_name)
+            full_name = f"{parent.name}.{full_name}"
             parent = parent.parent
 
         return full_name
@@ -483,7 +483,7 @@ def __init__(
         self._symbol = symbol
 
         if self._symbol not in ATOMS_DATABASE:
-            raise UnknownAtomError("The atom {} is unknown".format(self.symbol))
+            raise UnknownAtomError(f"The atom {self.symbol} is unknown")
 
         self._name = name if name else symbol
 
@@ -652,7 +652,7 @@ def symbol(self) -> str:
     @symbol.setter
     def symbol(self, symbol: str) -> None:
         if symbol not in ATOMS_DATABASE:
-            raise UnknownAtomError("The atom {} is unknown".format(symbol))
+            raise UnknownAtomError(f"The atom {symbol} is unknown")
 
         self._symbol = symbol
 
@@ -1177,16 +1177,14 @@ def __init__(self, code: str, name: str, variant: Union[str, None] = None):
             try:
                 self._selected_variant = RESIDUES_DATABASE[self._variant]
             except (KeyError, ResiduesDatabaseError):
-                raise InvalidVariantError(
-                    "The variant {} is unknown".format(self._variant)
-                )
+                raise InvalidVariantError(f"The variant {self._variant} is unknown")
             else:
                 if (
                     not self._selected_variant["is_n_terminus"]
                     and not self._selected_variant["is_c_terminus"]
                 ):
                     raise InvalidVariantError(
-                        "The variant {} is not valid".format(self._variant)
+                        f"The variant {self._variant} is not valid"
                     )
         else:
             self._selected_variant = None
@@ -1404,16 +1402,14 @@ def __init__(self, code: str, name: str, variant: Union[str, None] = None):
             try:
                 self._selected_variant = NUCLEOTIDES_DATABASE[self._variant]
             except (KeyError, NucleotidesDatabaseError):
-                raise InvalidVariantError(
-                    "The variant {} is unknown".format(self._variant)
-                )
+                raise InvalidVariantError(f"The variant {self._variant} is unknown")
             else:
                 if (
                     not self._selected_variant["is_5ter_terminus"]
                     and not self._selected_variant["is_3ter_terminus"]
                 ):
                     raise InvalidVariantError(
-                        "The variant {} is not valid".format(self._variant)
+                        f"The variant {self._variant} is not valid"
                     )
         else:
             self._selected_variant = None
@@ -1619,7 +1615,7 @@ def __getitem__(self, item: int):
         return self._nucleotides[item]
 
     def __str__(self):
-        return "NucleotideChain of {} nucleotides".format(len(self._nucleotides))
+        return f"NucleotideChain of {len(self._nucleotides)} nucleotides"
 
     def __repr__(self):
         contents = ""
@@ -2005,7 +2001,7 @@ def __getitem__(self, item: int):
         return self._residues[item]
 
     def __str__(self):
-        return "PeptideChain of {} residues".format(len(self._residues))
+        return f"PeptideChain of {len(self._residues)} residues"
 
     def __repr__(self):
         contents = ""
@@ -2411,7 +2407,7 @@ def translate_atom_names(
     :rtype: list
     """
     if not molname in database:
-        raise UnknownMoleculeError("The molecule {} is unknown".format(molname))
+        raise UnknownMoleculeError(f"The molecule {molname} is unknown")
 
     renamed_atoms = []
     for atom in atoms:
@@ -2420,7 +2416,7 @@ def translate_atom_names(
                 renamed_atoms.append(dbat)
                 break
         else:
-            raise UnknownAtomError("The atom {} is unknown".format(atom))
+            raise UnknownAtomError(f"The atom {atom} is unknown")
 
     return renamed_atoms
 

MDANSE/Src/MDANSE/Chemistry/Databases.py

@@ -207,7 +207,7 @@ def __getitem__(self, item: str) -> dict:
             return copy.deepcopy(self._data[item])
         except KeyError:
             raise AtomsDatabaseError(
-                "The element {} is not registered in the database.".format(item)
+                f"The element {item} is not registered in the database."
             )
 
     def _load(self, user_database: str = None, default_database: str = None) -> None:
@@ -245,7 +245,7 @@ def add_atom(self, atom: str) -> None:
 
         if atom in self._data:
             raise AtomsDatabaseError(
-                "The atom {} is already stored in the database".format(atom)
+                f"The atom {atom} is already stored in the database"
             )
 
         self._data[atom] = {}
@@ -264,11 +264,11 @@ def add_property(self, pname: str, ptype: str) -> None:
 
         if pname in self._properties:
             raise AtomsDatabaseError(
-                "The property {} is already registered in the database.".format(pname)
+                f"The property {pname} is already registered in the database."
             )
 
         if ptype not in AtomsDatabase._TYPES:
-            raise AtomsDatabaseError("The property type {} is unknown".format(ptype))
+            raise AtomsDatabaseError(f"The property type {ptype} is unknown")
 
         self._properties[pname] = ptype
         ptype = AtomsDatabase._TYPES[ptype]
@@ -299,7 +299,7 @@ def get_isotopes(self, atom: str) -> list[str]:
         """
 
         if atom not in self._data:
-            raise AtomsDatabaseError("The atom {} is unknown".format(atom))
+            raise AtomsDatabaseError(f"The atom {atom} is unknown")
 
         # The isotopes are searched according to |symbol| property
         symbol = self._data[atom]["symbol"]
@@ -332,7 +332,7 @@ def get_property(self, pname: str) -> dict[str, Union[str, int, float, list]]:
 
         if pname not in self._properties:
             raise AtomsDatabaseError(
-                "The property {} is not registered in the database".format(pname)
+                f"The property {pname} is not registered in the database"
             )
 
         ptype = AtomsDatabase._TYPES[self._properties[pname]]
@@ -357,11 +357,11 @@ def get_value(self, atom: str, pname: str) -> Union[str, int, float, list]:
         """
 
         if atom not in self._data:
-            raise AtomsDatabaseError("The atom {} is unknown".format(atom))
+            raise AtomsDatabaseError(f"The atom {atom} is unknown")
 
         if pname not in self._properties:
             raise AtomsDatabaseError(
-                "The property {} is not registered in the database".format(pname)
+                f"The property {pname} is not registered in the database"
             )
 
         ptype = self._properties[pname]
@@ -389,12 +389,12 @@ def get_values_for_multiple_atoms(
 
         if not all(atom in self._data for atom in atoms):
             raise AtomsDatabaseError(
-                "One or more of the provided atoms {} are unknown".format(atoms)
+                f"One or more of the provided atoms {atoms} are unknown"
             )
 
         if prop not in self._properties:
             raise AtomsDatabaseError(
-                "The property {} is not registered in the database".format(prop)
+                f"The property {prop} is not registered in the database"
             )
 
         values = {name: self._data[name][prop] for name in unique_atoms}
@@ -417,11 +417,11 @@ def set_value(
         """
 
         if atom not in self._data:
-            raise AtomsDatabaseError("The element {} is unknown".format(atom))
+            raise AtomsDatabaseError(f"The element {atom} is unknown")
 
         if pname not in self._properties:
             raise AtomsDatabaseError(
-                "The property {} is not registered in the database".format(pname)
+                f"The property {pname} is not registered in the database"
             )
 
         try:
@@ -430,7 +430,7 @@ def set_value(
             )
         except ValueError:
             raise AtomsDatabaseError(
-                "Can not coerce {} to {} type".format(value, self._properties[pname])
+                f"Can not coerce {value} to {self._properties[pname]} type"
             )
 
     def has_atom(self, atom: str) -> bool:
@@ -472,7 +472,7 @@ def info(self, atom: str) -> str:
 
         # A delimiter line.
         delimiter = "-" * 70
-        tab_fmt = "{:<20}{:>50}"
+        tab_fmt = " {:<20}{:>50}"
 
         info = [
             delimiter,
@@ -482,10 +482,12 @@ def info(self, atom: str) -> str:
         ]
 
         # The values for all element's properties
+        print(tab_fmt)
+        print(self._data[atom])
         for pname in sorted(self._properties):
-            info.append(
-                tab_fmt.format(pname, self._data[atom].get(pname, None))
-            )
+            print(pname)
+
+            info.append(tab_fmt.format(pname, self._data[atom].get(pname, None)))
 
         info.append(delimiter)
         info = "\n".join(info)
@@ -518,7 +520,7 @@ def match_numeric_property(
                 )
         except KeyError:
             raise AtomsDatabaseError(
-                "The property {} is not registered in the database".format(pname)
+                f"The property {pname} is not registered in the database"
             )
 
         tolerance = abs(tolerance)
@@ -634,7 +636,7 @@ def __getitem__(self, item: str):
             return copy.deepcopy(self._data[self._residue_map[item]])
         else:
             raise MoleculesDatabaseError(
-                "The molecule {} is not registered in the database.".format(item)
+                f"The molecule {item} is not registered in the database."
             )
 
     def _load(self, user_database: str = None, default_database: str = None) -> None:
@@ -662,7 +664,7 @@ def add_molecule(self, molecule: str) -> None:
 
         if molecule in self._data:
             raise MoleculesDatabaseError(
-                "The element {} is already stored in the database".format(molecule)
+                f"The element {molecule} is already stored in the database"
             )
 
         self._data[molecule] = {"alternatives": [], "atoms": {}}
@@ -717,7 +719,7 @@ def __getitem__(
             return copy.deepcopy(self._data[self._residue_map[item]])
         else:
             raise NucleotidesDatabaseError(
-                "The nucleotide {} is not registered in the database.".format(item)
+                f"The nucleotide {item} is not registered in the database."
             )
 
     def _load(self, user_database: str = None, default_database: str = None) -> None:
@@ -757,7 +759,7 @@ def add_nucleotide(
 
         if nucleotide in self._residue_map:
             raise NucleotidesDatabaseError(
-                "The nucleotide {} is already stored in the database".format(nucleotide)
+                f"The nucleotide {nucleotide} is already stored in the database"
             )
 
         self._data[nucleotide] = {
@@ -818,7 +820,7 @@ def __getitem__(
             return copy.deepcopy(self._data[self._residue_map[item]])
         else:
             raise ResiduesDatabaseError(
-                "The residue {} is not registered in the database.".format(item)
+                f"The residue {item} is not registered in the database."
             )
 
     def _load(self, user_database: str = None, default_database: str = None) -> None:
@@ -857,7 +859,7 @@ def add_residue(
 
         if residue in self._residue_map:
             raise ResiduesDatabaseError(
-                "The element {} is already stored in the database".format(residue)
+                f"The element {residue} is already stored in the database"
             )
 
         self._data[residue] = {

MDANSE/Src/MDANSE/Core/Platform.py

@@ -217,7 +217,7 @@ def create_directory(self, path):
         except OSError as e:
             raise PlatformError(
                 "The following exception was raised while trying to create a directory at "
-                "{0}: /n {1}".format(str(path), e)
+                f"{path}: /n {e}"
             )
 
     @classmethod

MDANSE/Src/MDANSE/Framework/Configurable.py

@@ -251,17 +251,19 @@ def build_doc_texttable(cls, doclist):
             v["Description"] = v["Description"].strip()
             v["Description"] = v["Description"].splitlines()
             v["Description"] = ["| " + vv.strip() for vv in v["Description"]]
-            sizes[2] = max(sizes[2], max(v["Description"], key=len))
+            sizes[2] = max(sizes[2], max(map(len, v["Description"])))
 
         data_line = "| " + "| ".join(f"{{}}:<{size}" for size in sizes) + "|\n"
-        sep_line = "+" + "+".join("-" * (size+1) for size in sizes) + "+\n"
+        sep_line = "+" + "+".join("-" * (size + 1) for size in sizes) + "+\n"
 
         docstring += sep_line
         docstring += data_line.format(*columns)
         docstring += sep_line.replace("-", "=")
 
         for v in doclist:
-            docstring += data_line.format(v["Configurator"], v["Default value"], v["Description"][0])
+            docstring += data_line.format(
+                v["Configurator"], v["Default value"], v["Description"][0]
+            )
             if len(v["Description"]) > 1:
                 for descr in v["Description"][1:]:
                     data_line.format("", "", descr)

MDANSE/Src/MDANSE/Framework/Configurators/GroupingLevelConfigurator.py

@@ -133,7 +133,7 @@ def configure(self, value):
         names = []
         group_indices = []
         for i, v in enumerate(groups.values()):
-            names.append(f"group_{i}")
+            names.append(f"group_{i:d}")
             elements.append(v["elements"])
             indexes.append(v["indexes"])
             masses.append(v["masses"])

MDANSE/Src/MDANSE/Framework/Configurators/IConfigurator.py

@@ -49,7 +49,9 @@ def __str__(self):
         """
 
         if self._configurator is not None:
-            self._message = f"Configurator: {self._configurator.name!r} --> {self._message}"
+            self._message = (
+                f"Configurator: {self._configurator.name!r} --> {self._message}"
+            )
 
         return self._message
 

MDANSE/Src/MDANSE/Framework/Configurators/QVectorsConfigurator.py

@@ -122,8 +122,6 @@ def get_information(self):
             return "QVectors could not be configured correctly"
         else:
             for qValue, qVectors in self["q_vectors"].items():
-                info.append(
-                    f"Shell {qValue}: {len(qVectors)} Q vectors generated\n"
-                )
+                info.append(f"Shell {qValue}: {len(qVectors)} Q vectors generated\n")
 
             return "".join(info)

MDANSE/Src/MDANSE/Framework/Configurators/RangeConfigurator.py

@@ -213,7 +213,7 @@ def get_information(self):
 
         if self._valid:
 
-            info = f"{self['number']} values from {self['first']} to {self['last']}"
+            info = f"{self['number']:d} values from {self['first']} to {self['last']}"
 
             if self._includeLast:
                 info += " last value included"

MDANSE/Src/MDANSE/Framework/Configurators/XYZFileConfigurator.py

@@ -47,9 +47,7 @@ def parse(self):
         try:
             self["n_atoms"] = int(self["instance"].readline().strip())
         except ValueError:
-            raise XYZFileError(
-                f"Could not read the number of atoms in {filename} file"
-            )
+            raise XYZFileError(f"Could not read the number of atoms in {filename} file")
 
         self._nAtomsLineSize = self["instance"].tell()
         self["instance"].readline()