Converted string formatting to f-strings.

23 files changed, 220 insertions, 564 deletions

diff --git a/doc/conf.py b/doc/conf.py
index bae26d1ec..7bbb1e054 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -74,7 +74,7 @@ try:
     with open(prologPath, "r") as prologFile:
         rst_prolog = prologFile.read()
 except Exception as ex:
-    print("[ERROR:] While reading '{0!s}'.".format(prologPath))
+    print(f"[ERROR:] While reading '{prologPath!s}'.")
     print(ex)
     rst_prolog = ""
 
diff --git a/pyGHDL/cli/dom.py b/pyGHDL/cli/dom.py
index 816baafba..68bd33c34 100755
--- a/pyGHDL/cli/dom.py
+++ b/pyGHDL/cli/dom.py
@@ -224,7 +224,7 @@ class Application(LineTerminal, ArgParseMixin):
             try:
                 self.SubParsers[args.Command].print_help()
             except KeyError:
-                self.WriteError("Command {0} is unknown.".format(args.Command))
+                self.WriteError(f"Command {args.Command} is unknown.")
 
         self.WriteNormal("")
         self.exit()
@@ -237,15 +237,15 @@ class Application(LineTerminal, ArgParseMixin):
         self.PrintHeadline()
 
         copyrights = __copyright__.split("\n", 1)
-        self.WriteNormal("Copyright:  {0}".format(copyrights[0]))
+        self.WriteNormal(f"Copyright:  {copyrights[0]}")
         for copyright in copyrights[1:]:
-            self.WriteNormal("            {0}".format(copyright))
-        self.WriteNormal("License:    {0}".format(__license__))
+            self.WriteNormal(f"            {copyright}")
+        self.WriteNormal(f"License:    {__license__}")
         authors = __author__.split(", ")
-        self.WriteNormal("Authors:    {0}".format(authors[0]))
+        self.WriteNormal(f"Authors:    {authors[0]}")
         for author in authors[1:]:
-            self.WriteNormal("            {0}".format(author))
-        self.WriteNormal("Version:    {0}".format(__version__))
+            self.WriteNormal(f"            {author}")
+        self.WriteNormal(f"Version:    {__version__}")
         self.exit()
 
     # ----------------------------------------------------------------------------
@@ -263,10 +263,10 @@ class Application(LineTerminal, ArgParseMixin):
         if args.Files is not None:
             for file in args.Files:
                 if not file.exists():
-                    self.WriteError("File '{0!s}' does not exist.".format(file))
+                    self.WriteError(f"File '{file!s}' does not exist.")
                     continue
 
-                self.WriteNormal("Parsing file '{!s}'".format(file))
+                self.WriteNormal(f"Parsing file '{file!s}'")
                 document = self.addFile(file, "pretty")
                 self.WriteInfo(
                     dedent(
@@ -282,10 +282,10 @@ class Application(LineTerminal, ArgParseMixin):
         elif args.Directory is not None:
             d: Path = args.Directory
             if not d.exists():
-                self.WriteError("Directory '{0!s}' does not exist.".format(d))
+                self.WriteError(f"Directory '{d!s}' does not exist.")
 
             for file in d.glob("**/*.vhd?"):
-                self.WriteNormal("Parsing file '{!s}'".format(file))
+                self.WriteNormal(f"Parsing file '{file!s}'")
                 document = self.addFile(file, "pretty")
                 self.WriteInfo(
                     dedent(
@@ -349,23 +349,23 @@ def main():  # mccabe:disable=MC0001
         app.Run()
         app.exit()
     except PrettyPrintException as ex:
-        print("PP: {!s}".format(ex))
+        print(f"PP: {ex!s}")
         LineTerminal.exit()
 
     except DOMException as ex:
-        print("DOM: {!s}".format(ex))
+        print(f"DOM: {ex!s}")
         ex2: LibGHDLException = ex.__cause__
         if ex2 is not None:
             for message in ex2.InternalErrors:
-                print("libghdl: {message}".format(message=message))
+                print(f"libghdl: {message}")
             LineTerminal.exit(0)
 
         LineTerminal.exit(6)
 
     except LibGHDLException as ex:
-        print("LIB: {!s}".format(ex))
+        print(f"LIB: {ex!s}")
         for message in ex.InternalErrors:
-            print("  {message}".format(message=message))
+            print(f"  {message}")
         LineTerminal.exit(5)
 
     except GHDLBaseException as ex:
diff --git a/pyGHDL/cli/lsp.py b/pyGHDL/cli/lsp.py
index 694988153..5d09d7cc7 100644
--- a/pyGHDL/cli/lsp.py
+++ b/pyGHDL/cli/lsp.py
@@ -67,18 +67,18 @@ def __rotate_log_files(basename: str, num: int):
     # one.
     # Note: Path.with_suffix cannot be used as there might be multiple
     # suffixes (like in trace.out.0).
-    oldfile = Path("{}.{}".format(basename, num))
+    oldfile = Path(f"{basename}.{num}")
     if oldfile.is_file():
         oldfile.unlink()
     # Rotate old files
     for i in range(num, 0, -1):
-        oldfile = Path("{}.{}".format(basename, i - 1))
+        oldfile = Path(f"{basename}.{i-1}")
         if oldfile.is_file():
-            oldfile.rename(Path("{}.{}".format(basename, i)))
+            oldfile.rename(Path(f"{basename}.{i}"))
     # Rotate the newest log file.
     bname = Path(basename)
     if bname.is_file():
-        bname.rename(Path("{}.{}".format(basename, 0)))
+        bname.rename(Path(f"{basename}.0"))
 
 
 def _generateCLIParser() -> ArgumentParser:
@@ -115,7 +115,7 @@ def main():
         errorout_console.Install_Handler()
         libghdl.disp_config()
         print("python:")
-        print("sys.platform: {}, os.name: {}".format(sys.platform, os.name))
+        print(f"sys.platform: {sys.platform}, os.name: {os.name}")
         print(sys.version)
         return
 
@@ -140,8 +140,8 @@ def main():
     )
 
     if args.verbose != 0:
-        sys_stderr.write("Args: {}\n".format(sys_argv))
-        sys_stderr.write("Current directory: {}\n".format(os_getcwd()))
+        sys_stderr.write(f"Args: {sys_argv}\n")
+        sys_stderr.write(f"Current directory: {os_getcwd()}\n")
 
     logger.info("Args: %s", sys_argv)
     logger.info("Current directory is %s", os_getcwd())
diff --git a/pyGHDL/dom/Attribute.py b/pyGHDL/dom/Attribute.py
index 3b3f3b40e..808f0a6a3 100644
--- a/pyGHDL/dom/Attribute.py
+++ b/pyGHDL/dom/Attribute.py
@@ -121,30 +121,14 @@ class AttributeSpecification(VHDLModel_AttributeSpecification, DOMMixin):
                 print("[NOT IMPLEMENTED] Signature name in attribute specifications.")
             else:
                 position = Position.parse(name)
-                raise DOMException(
-                    "Unknown name kind '{kind}' in attribute specification '{attr}' at {file}:{line}:{column}.".format(
-                        kind=nameKind.name,
-                        attr=attributeNode,
-                        file=position.Filename,
-                        line=position.Line,
-                        column=position.Column,
-                    )
-                )
+                raise DOMException(f"Unknown name kind '{nameKind.name}' in attribute specification '{attributeNode}' at {position.Filename}:{position.Line}:{position.Column}.")
 
         entityClassToken = nodes.Get_Entity_Class(attributeNode)
         try:
             entityClass = _TOKEN_TRANSLATION[entityClassToken]
         except KeyError:
             position = Position.parse(attributeNode)
-            raise DOMException(
-                "Unknown token '{token}' in attribute specification for entity class '{entityClass}' at {file}:{line}:{column}.".format(
-                    token=entityClassToken.name,
-                    entityClass=attributeNode,
-                    file=position.Filename,
-                    line=position.Line,
-                    column=position.Column,
-                )
-            )
+            raise DOMException(f"Unknown token '{entityClassToken.name}' in attribute specification for entity class '{attributeNode}' at {position.Filename}:{position.Line}:{position.Column}.")
 
         expression = GetExpressionFromNode(nodes.Get_Expression(attributeNode))
 
diff --git a/pyGHDL/dom/Concurrent.py b/pyGHDL/dom/Concurrent.py
index f1f545d53..754f58f14 100644
--- a/pyGHDL/dom/Concurrent.py
+++ b/pyGHDL/dom/Concurrent.py
@@ -552,11 +552,7 @@ class CaseGenerateStatement(VHDLModel_CaseGenerateStatement, DOMMixin):
                     rng = GetNameFromNode(choiceRange)
                 else:
                     pos = Position.parse(alternative)
-                    raise DOMException(
-                        "Unknown choice range kind '{kind}' in case...generate statement at line {line}.".format(
-                            kind=choiceRangeKind.name, line=pos.Line
-                        )
-                    )
+                    raise DOMException(f"Unknown choice range kind '{choiceRangeKind.name}' in case...generate statement at line {pos.Line}.")
 
                 choice = RangedGenerateChoice(alternative, rng)
                 if sameAlternative:
@@ -573,11 +569,7 @@ class CaseGenerateStatement(VHDLModel_CaseGenerateStatement, DOMMixin):
                 continue
             else:
                 pos = Position.parse(alternative)
-                raise DOMException(
-                    "Unknown choice kind '{kind}' in case...generate statement at line {line}.".format(
-                        kind=choiceKind.name, line=pos.Line
-                    )
-                )
+                raise DOMException(f"Unknown choice kind '{choiceKind.name}' in case...generate statement at line {pos.Line}.")
 
             if choices is not None:
                 cases.append(GenerateCase.parse(caseNode, choices))
@@ -633,11 +625,7 @@ class ForGenerateStatement(VHDLModel_ForGenerateStatement, DOMMixin):
             rng = GetNameFromNode(discreteRange)
         else:
             pos = Position.parse(generateNode)
-            raise DOMException(
-                "Unknown discete range kind '{kind}' in for...generate statement at line {line}.".format(
-                    kind=rangeKind.name, line=pos.Line
-                )
-            )
+            raise DOMException(f"Unknown discete range kind '{rangeKind.name}' in for...generate statement at line {pos.Line}.")
 
         body = nodes.Get_Generate_Statement_Body(generateNode)
         declarationChain = nodes.Get_Declaration_Chain(body)
diff --git a/pyGHDL/dom/DesignUnit.py b/pyGHDL/dom/DesignUnit.py
index 3c0d2ab0c..f45cb8340 100644
--- a/pyGHDL/dom/DesignUnit.py
+++ b/pyGHDL/dom/DesignUnit.py
@@ -314,11 +314,7 @@ class Context(VHDLModel_Context, DOMMixin):
                 items.append(UseClause.parse(item))
             else:
                 pos = Position.parse(item)
-                raise DOMException(
-                    "Unknown context item kind '{kind}' in context at line {line}.".format(
-                        kind=kind.name, line=pos.Line
-                    )
-                )
+                raise DOMException(f"Unknown context item kind '{kind.name}' in context at line {pos.Line}.")
 
         return cls(contextNode, name, items)
 
diff --git a/pyGHDL/dom/Expression.py b/pyGHDL/dom/Expression.py
index f68ab0d51..f56ca148f 100644
--- a/pyGHDL/dom/Expression.py
+++ b/pyGHDL/dom/Expression.py
@@ -519,11 +519,7 @@ class Aggregate(VHDLModel_Aggregate, DOMMixin):
                     rng = GetNameFromNode(choiceRange)
                 else:
                     pos = Position.parse(item)
-                    raise DOMException(
-                        "Unknown discete range kind '{kind}' in for...generate statement at line {line}.".format(
-                            kind=rangeKind.name, line=pos.Line
-                        )
-                    )
+                    raise DOMException(f"Unknown discete range kind '{rangeKind.name}' in for...generate statement at line {pos.Line}.")
 
                 choices.append(RangedAggregateElement(item, rng, value))
             elif kind == nodes.Iir_Kind.Choice_By_Name:
@@ -533,8 +529,6 @@ class Aggregate(VHDLModel_Aggregate, DOMMixin):
             elif kind == nodes.Iir_Kind.Choice_By_Others:
                 choices.append(OthersAggregateElement(item, value))
             else:
-                raise DOMException(
-                    "Unknown choice kind '{kind}' in aggregate '{aggr}'.".format(kind=kind.name, aggr=node)
-                )
+                raise DOMException(f"Unknown choice kind '{kind.name}' in aggregate '{node}'.")
 
         return cls(node, choices)
diff --git a/pyGHDL/dom/NonStandard.py b/pyGHDL/dom/NonStandard.py
index 4e842f012..e6af8284a 100644
--- a/pyGHDL/dom/NonStandard.py
+++ b/pyGHDL/dom/NonStandard.py
@@ -191,11 +191,7 @@ class Document(VHDLModel_Document):
                         contextItems.append(ContextReference.parse(item))
                     else:
                         pos = Position.parse(item)
-                        raise DOMException(
-                            "Unknown context item kind '{kind}' in context at line {line}.".format(
-                                kind=itemKind.name, line=pos.Line
-                            )
-                        )
+                        raise DOMException(f"Unknown context item kind '{itemKind.name}' in context at line {pos.Line}.")
 
             if nodeKind == nodes.Iir_Kind.Entity_Declaration:
                 entity = Entity.parse(libraryUnit, contextItems)
@@ -238,7 +234,7 @@ class Document(VHDLModel_Document):
                 self.VerificationModes.append(vmod)
 
             else:
-                raise DOMException("Unknown design unit kind '{kind}'.".format(kind=nodeKind.name))
+                raise DOMException(f"Unknown design unit kind '{nodeKind.name}'.")
 
     @property
     def LibGHDLProcessingTime(self) -> float:
diff --git a/pyGHDL/dom/Sequential.py b/pyGHDL/dom/Sequential.py
index 35f7b0d4f..3e9ebaf48 100644
--- a/pyGHDL/dom/Sequential.py
+++ b/pyGHDL/dom/Sequential.py
@@ -291,11 +291,7 @@ class CaseStatement(VHDLModel_CaseStatement, DOMMixin):
                     rng = GetNameFromNode(choiceRange)
                 else:
                     pos = Position.parse(alternative)
-                    raise DOMException(
-                        "Unknown choice range kind '{kind}' in case statement at line {line}.".format(
-                            kind=choiceRangeKind.name, line=pos.Line
-                        )
-                    )
+                    raise DOMException(f"Unknown choice range kind '{choiceRangeKind.name}' in case statement at line {pos.Line}.")
 
                 choice = RangedChoice(alternative, rng)
                 if sameAlternative:
@@ -312,11 +308,7 @@ class CaseStatement(VHDLModel_CaseStatement, DOMMixin):
                 continue
             else:
                 pos = Position.parse(alternative)
-                raise DOMException(
-                    "Unknown choice kind '{kind}' in case statement at line {line}.".format(
-                        kind=choiceKind.name, line=pos.Line
-                    )
-                )
+                raise DOMException(f"Unknown choice kind '{choiceKind.name}' in case statement at line {pos.Line}.")
 
             if choices is not None:
                 cases.append(Case.parse(cNode, choices, label))
@@ -370,11 +362,7 @@ class ForLoopStatement(VHDLModel_ForLoopStatement, DOMMixin):
             rng = GetNameFromNode(discreteRange)
         else:
             pos = Position.parse(loopNode)
-            raise DOMException(
-                "Unknown discete range kind '{kind}' in for...loop statement at line {line}.".format(
-                    kind=rangeKind.name, line=pos.Line
-                )
-            )
+            raise DOMException(f"Unknown discete range kind '{rangeKind.name}' in for...loop statement at line {pos.Line}.")
 
         statementChain = nodes.Get_Sequential_Statement_Chain(loopNode)
         statements = GetSequentialStatementsFromChainedNodes(statementChain, "for", label)
diff --git a/pyGHDL/dom/Type.py b/pyGHDL/dom/Type.py
index ba039852c..6724ac743 100644
--- a/pyGHDL/dom/Type.py
+++ b/pyGHDL/dom/Type.py
@@ -128,11 +128,7 @@ class PhysicalType(VHDLModel_PhysicalType, DOMMixin):
             rng = GetNameFromNode(rangeConstraint)
         else:
             pos = Position.parse(typeDefinitionNode)
-            raise DOMException(
-                "Unknown range kind '{kind}' in physical type definition at line {line}.".format(
-                    kind=rangeKind.name, line=pos.Line
-                )
-            )
+            raise DOMException(f"Unknown range kind '{rangeKind.name}' in physical type definition at line {pos.Line}.")
 
         primaryUnit = nodes.Get_Primary_Unit(typeDefinitionNode)
         primaryUnitName = GetNameOfNode(primaryUnit)
@@ -172,11 +168,7 @@ class ArrayType(VHDLModel_ArrayType, DOMMixin):
                 indexSubtype = GetSimpleTypeFromNode(index)
                 indices.append(indexSubtype)
             else:
-                raise DOMException(
-                    "Unknown kind '{kind}' for an index in the array definition of `{typeName}`.".format(
-                        kind=indexKind.name, typeName=typeName
-                    )
-                )
+                raise DOMException(f"Unknown kind '{indexKind.name}' for an index in the array definition of `{typeName}`.")
 
         elementSubtypeIndication = nodes.Get_Element_Subtype_Indication(typeDefinitionNode)
         elementSubtype = GetSubtypeIndicationFromIndicationNode(elementSubtypeIndication, "array declaration", typeName)
diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py
index 2f4a90343..7e21b98bf 100644
--- a/pyGHDL/dom/_Translate.py
+++ b/pyGHDL/dom/_Translate.py
@@ -199,7 +199,7 @@ def GetNameFromNode(node: Iir) -> Name:
         prefixName = GetNameFromNode(nodes.Get_Prefix(node))
         return AllName(node, prefixName)
     else:
-        raise DOMException("Unknown name kind '{kind}'".format(kind=kind.name))
+        raise DOMException(f"Unknown name kind '{kind.name}'")
 
 
 def GetAssociations(node: Iir) -> List:
@@ -216,11 +216,7 @@ def GetAssociations(node: Iir) -> List:
 
             associations.append(expr)
         else:
-            raise DOMException(
-                "Unknown association kind '{kind}' in array index/slice or function call '{node}'.".format(
-                    kind=kind.name, node=node
-                )
-            )
+            raise DOMException(f"Unknown association kind '{kind.name}' in array index/slice or function call '{node}'.")
 
     return associations
 
@@ -243,16 +239,7 @@ def GetArrayConstraintsFromSubtypeIndication(
             constraints.append(GetNameFromNode(constraint))
         else:
             position = Position.parse(constraint)
-            raise DOMException(
-                "Unknown constraint kind '{kind}' for constraint '{constraint}' in subtype indication '{indication}' at {file}:{line}:{column}.".format(
-                    kind=constraintKind.name,
-                    constraint=constraint,
-                    indication=subtypeIndication,
-                    file=position.Filename,
-                    line=position.Line,
-                    column=position.Column,
-                )
-            )
+            raise DOMException(f"Unknown constraint kind '{constraintKind.name}' for constraint '{constraint}' in subtype indication '{subtypeIndication}' at {position.Filename}:{position.Line}:{position.Column}.")
 
     return constraints
 
@@ -279,15 +266,7 @@ def GetTypeFromNode(node: Iir) -> BaseType:
         return ProtectedType.parse(typeName, typeDefinition)
     else:
         position = Position.parse(typeDefinition)
-        raise DOMException(
-            "GetTypeFromNode: Unknown type definition kind '{kind}' for type '{name}' at {file}:{line}:{column}.".format(
-                kind=kind.name,
-                name=typeName,
-                file=position.Filename,
-                line=position.Line,
-                column=position.Column,
-            )
-        )
+        raise DOMException(f"GetTypeFromNode: Unknown type definition kind '{kind.name}' for type '{typeName}' at {position.Filename}:{position.Line}:{position.Column}.")
 
 
 @export
@@ -315,15 +294,7 @@ def GetAnonymousTypeFromNode(node: Iir) -> BaseType:
         return ArrayType(typeDefinition, "????", [], None)
     else:
         position = Position.parse(typeDefinition)
-        raise DOMException(
-            "GetAnonymousTypeFromNode: Unknown type definition kind '{kind}' for type '{name}' at {file}:{line}:{column}.".format(
-                kind=kind.name,
-                name=typeName,
-                file=position.Filename,
-                line=position.Line,
-                column=position.Column,
-            )
-        )
+        raise DOMException(f"GetAnonymousTypeFromNode: Unknown type definition kind '{kind.name}' for type '{typeName}' at {position.Filename}:{position.Line}:{position.Column}.")
 
 
 @export
@@ -349,11 +320,7 @@ def GetSubtypeIndicationFromIndicationNode(subtypeIndicationNode: Iir, entity: s
     elif kind == nodes.Iir_Kind.Array_Subtype_Definition:
         return GetCompositeConstrainedSubtypeFromNode(subtypeIndicationNode)
     else:
-        raise DOMException(
-            "Unknown kind '{kind}' for an subtype indication in a {entity} of `{name}`.".format(
-                kind=kind.name, entity=entity, name=name
-            )
-        )
+        raise DOMException(f"Unknown kind '{kind.name}' for an subtype indication in a {entity} of `{name}`.")
 
 
 @export
@@ -471,15 +438,7 @@ def GetExpressionFromNode(node: Iir) -> ExpressionUnion:
         cls = __EXPRESSION_TRANSLATION[kind]
     except KeyError:
         position = Position.parse(node)
-        raise DOMException(
-            "Unknown expression kind '{kind}' in expression '{expr}' at {file}:{line}:{column}.".format(
-                kind=kind.name,
-                expr=node,
-                file=position.Filename,
-                line=position.Line,
-                column=position.Column,
-            )
-        )
+        raise DOMException(f"Unknown expression kind '{kind.name}' in expression '{node}' at {position.Filename}:{position.Line}:{position.Column}.")
 
     return cls.parse(node)
 
@@ -536,15 +495,7 @@ def GetGenericsFromChainedNodes(
                 yield GenericFunctionInterfaceItem.parse(generic)
             else:
                 position = Position.parse(generic)
-                raise DOMException(
-                    "Unknown generic kind '{kind}' in generic '{generic}' at {file}:{line}:{column}.".format(
-                        kind=kind.name,
-                        generic=generic,
-                        file=position.Filename,
-                        line=position.Line,
-                        column=position.Column,
-                    )
-                )
+                raise DOMException(f"Unknown generic kind '{kind.name}' in generic '{generic}' at {position.Filename}:{position.Line}:{position.Column}.")
 
         generic = nodes.Get_Chain(generic)
 
@@ -586,15 +537,7 @@ def GetPortsFromChainedNodes(
             continue
         else:
             position = Position.parse(port)
-            raise DOMException(
-                "Unknown port kind '{kind}' in port '{port}' at {file}:{line}:{column}.".format(
-                    kind=kind.name,
-                    port=port,
-                    file=position.Filename,
-                    line=position.Line,
-                    column=position.Column,
-                )
-            )
+            raise DOMException(f"Unknown port kind '{kind.name}' in port '{port}' at {position.Filename}:{position.Line}:{position.Column}.")
 
 
 @export
@@ -623,15 +566,7 @@ def GetParameterFromChainedNodes(
             param = ParameterFileInterfaceItem.parse(parameter)
         else:
             position = Position.parse(parameter)
-            raise DOMException(
-                "Unknown parameter kind '{kind}' in parameter '{param}' at {file}:{line}:{column}.".format(
-                    kind=kind.name,
-                    param=parameter,
-                    file=position.Filename,
-                    line=position.Line,
-                    column=position.Column,
-                )
-            )
+            raise DOMException(f"Unknown parameter kind '{kind.name}' in parameter '{parameter}' at {position.Filename}:{position.Line}:{position.Column}.")
 
         # Lookahead for parameters with multiple identifiers at once
         if nodes.Get_Has_Identifier_List(parameter):
@@ -679,11 +614,7 @@ def GetMapAspect(mapAspect: Iir, cls: Type, entity: str) -> Generator[Associatio
             yield cls(generic, OpenName(generic), formal)
         else:
             pos = Position.parse(generic)
-            raise DOMException(
-                "Unknown association kind '{kind}' in {entity} map at line {line}.".format(
-                    kind=kind.name, entity=entity, line=pos.Line
-                )
-            )
+            raise DOMException(f"Unknown association kind '{kind.name}' in {entity} map at line {pos.Line}.")
 
 
 def GetGenericMapAspect(
@@ -751,16 +682,7 @@ def GetDeclaredItemsFromChainedNodes(nodeChain: Iir, entity: str, name: str) ->
                     pass
                 else:
                     position = Position.parse(item)
-                    raise DOMException(
-                        "Found unexpected function body '{functionName}' in {entity} '{name}' at {file}:{line}:{column}.".format(
-                            functionName=GetNameOfNode(item),
-                            entity=entity,
-                            name=name,
-                            file=position.Filename,
-                            line=position.Line,
-                            column=position.Column,
-                        )
-                    )
+                    raise DOMException(f"Found unexpected function body '{GetNameOfNode(item)}' in {entity} '{name}' at {position.Filename}:{position.Line}:{position.Column}.")
             elif kind == nodes.Iir_Kind.Procedure_Declaration:
                 if nodes.Get_Has_Body(item):
                     yield Procedure.parse(item)
@@ -775,16 +697,7 @@ def GetDeclaredItemsFromChainedNodes(nodeChain: Iir, entity: str, name: str) ->
                     pass
                 else:
                     position = Position.parse(item)
-                    raise DOMException(
-                        "Found unexpected procedure body '{functionName}' in {entity} '{name}' at {file}:{line}:{column}.".format(
-                            functionName=GetNameOfNode(item),
-                            entity=entity,
-                            name=name,
-                            file=position.Filename,
-                            line=position.Line,
-                            column=position.Column,
-                        )
-                    )
+                    raise DOMException(f"Found unexpected procedure body '{GetNameOfNode(item)}' in {entity} '{name}' at {position.Filename}:{position.Line}:{position.Column}.")
             elif kind == nodes.Iir_Kind.Protected_Type_Body:
                 yield ProtectedTypeBody.parse(item)
             elif kind == nodes.Iir_Kind.Object_Alias_Declaration:
@@ -814,37 +727,28 @@ def GetDeclaredItemsFromChainedNodes(nodeChain: Iir, entity: str, name: str) ->
 
                 yield PackageInstantiation.parse(item)
             elif kind == nodes.Iir_Kind.Configuration_Specification:
-                print("[NOT IMPLEMENTED] Configuration specification in {name}".format(name=name))
+                print(f"[NOT IMPLEMENTED] Configuration specification in {name}")
             elif kind == nodes.Iir_Kind.Psl_Default_Clock:
                 yield DefaultClock.parse(item)
             elif kind == nodes.Iir_Kind.Group_Declaration:
-                print("[NOT IMPLEMENTED] Group declaration in {name}".format(name=name))
+                print(f"[NOT IMPLEMENTED] Group declaration in {name}")
             elif kind == nodes.Iir_Kind.Group_Template_Declaration:
-                print("[NOT IMPLEMENTED] Group template declaration in {name}".format(name=name))
+                print(f"[NOT IMPLEMENTED] Group template declaration in {name}")
             elif kind == nodes.Iir_Kind.Disconnection_Specification:
-                print("[NOT IMPLEMENTED] Disconnect specification in {name}".format(name=name))
+                print(f"[NOT IMPLEMENTED] Disconnect specification in {name}")
             elif kind == nodes.Iir_Kind.Nature_Declaration:
-                print("[NOT IMPLEMENTED] Nature declaration in {name}".format(name=name))
+                print(f"[NOT IMPLEMENTED] Nature declaration in {name}")
             elif kind == nodes.Iir_Kind.Free_Quantity_Declaration:
-                print("[NOT IMPLEMENTED] Free quantity declaration in {name}".format(name=name))
+                print(f"[NOT IMPLEMENTED] Free quantity declaration in {name}")
             elif kind == nodes.Iir_Kind.Across_Quantity_Declaration:
-                print("[NOT IMPLEMENTED] Across quantity declaration in {name}".format(name=name))
+                print(f"[NOT IMPLEMENTED] Across quantity declaration in {name}")
             elif kind == nodes.Iir_Kind.Through_Quantity_Declaration:
-                print("[NOT IMPLEMENTED] Through quantity declaration in {name}".format(name=name))
+                print(f"[NOT IMPLEMENTED] Through quantity declaration in {name}")
             elif kind == nodes.Iir_Kind.Terminal_Declaration:
-                print("[NOT IMPLEMENTED] Terminal declaration in {name}".format(name=name))
+                print(f"[NOT IMPLEMENTED] Terminal declaration in {name}")
             else:
                 position = Position.parse(item)
-                raise DOMException(
-                    "Unknown declared item kind '{kind}' in {entity} '{name}' at {file}:{line}:{column}.".format(
-                        kind=kind.name,
-                        entity=entity,
-                        name=name,
-                        file=position.Filename,
-                        line=position.Line,
-                        column=position.Column,
-                    )
-                )
+                raise DOMException(f"Unknown declared item kind '{kind.name}' in {entity} '{name}' at {position.Filename}:{position.Line}:{position.Column}.")
 
             lastKind = None
             item = nodes.Get_Chain(item)
@@ -880,7 +784,7 @@ def GetConcurrentStatementsFromChainedNodes(
         label = nodes.Get_Label(statement)
         label = name_table.Get_Name_Ptr(label) if label != nodes.Null_Iir else None
 
-        pos = Position.parse(statement)
+        position = Position.parse(statement)
 
         kind = GetIirKindOfNode(statement)
         if kind == nodes.Iir_Kind.Sensitized_Process_Statement:
@@ -892,17 +796,9 @@ def GetConcurrentStatementsFromChainedNodes(
         elif kind == nodes.Iir_Kind.Concurrent_Simple_Signal_Assignment:
             yield ConcurrentSimpleSignalAssignment.parse(statement, label)
         elif kind == nodes.Iir_Kind.Concurrent_Conditional_Signal_Assignment:
-            print(
-                "[NOT IMPLEMENTED] Concurrent (conditional) signal assignment (label: '{label}') at line {line}".format(
-                    label=label, line=pos.Line
-                )
-            )
+            print(f"[NOT IMPLEMENTED] Concurrent (conditional) signal assignment (label: '{label}') at line {position.Line}")
         elif kind == nodes.Iir_Kind.Concurrent_Selected_Signal_Assignment:
-            print(
-                "[NOT IMPLEMENTED] Concurrent (selected) signal assignment (label: '{label}') at line {line}".format(
-                    label=label, line=pos.Line
-                )
-            )
+            print(f"[NOT IMPLEMENTED] Concurrent (selected) signal assignment (label: '{label}') at line {position.Line}")
         elif kind == nodes.Iir_Kind.Concurrent_Procedure_Call_Statement:
             yield ConcurrentProcedureCall.parse(statement, label)
         elif kind == nodes.Iir_Kind.Component_Instantiation_Statement:
@@ -915,15 +811,7 @@ def GetConcurrentStatementsFromChainedNodes(
             elif instantiatedUnitKind == nodes.Iir_Kind.Simple_Name:
                 yield ComponentInstantiation.parse(statement, instantiatedUnit, label)
             else:
-                raise DOMException(
-                    "Unknown instantiation kind '{kind}' in instantiation of label {label} at {file}:{line}:{column}.".format(
-                        kind=instantiatedUnitKind.name,
-                        label=label,
-                        file=pos.Filename,
-                        line=pos.Line,
-                        column=pos.Column,
-                    )
-                )
+                raise DOMException(f"Unknown instantiation kind '{instantiatedUnitKind.name}' in instantiation of label {label} at {position.Filename}:{position.Line}:{position.Column}.")
         elif kind == nodes.Iir_Kind.Block_Statement:
             yield ConcurrentBlockStatement.parse(statement, label)
         elif kind == nodes.Iir_Kind.If_Generate_Statement:
@@ -935,22 +823,9 @@ def GetConcurrentStatementsFromChainedNodes(
         elif kind == nodes.Iir_Kind.Psl_Assert_Directive:
             yield ConcurrentAssertStatement.parse(statement, label)
         elif kind == nodes.Iir_Kind.Simple_Simultaneous_Statement:
-            print(
-                "[NOT IMPLEMENTED] Simple simultaneous statement (label: '{label}') at line {line}".format(
-                    label=label, line=pos.Line
-                )
-            )
+            print(f"[NOT IMPLEMENTED] Simple simultaneous statement (label: '{label}') at line {position.Line}")
         else:
-            raise DOMException(
-                "Unknown statement of kind '{kind}' in {entity} '{name}' at {file}:{line}:{column}.".format(
-                    kind=kind.name,
-                    entity=entity,
-                    name=name,
-                    file=pos.Filename,
-                    line=pos.Line,
-                    column=pos.Column,
-                )
-            )
+            raise DOMException(f"Unknown statement of kind '{kind.name}' in {entity} '{name}' at {position.Filename}:{position.Line}:{position.Column}.")
 
 
 def GetSequentialStatementsFromChainedNodes(
@@ -960,7 +835,7 @@ def GetSequentialStatementsFromChainedNodes(
         label = nodes.Get_Label(statement)
         label = name_table.Get_Name_Ptr(label) if label != nodes.Null_Iir else None
 
-        pos = Position.parse(statement)
+        position = Position.parse(statement)
         kind = GetIirKindOfNode(statement)
         if kind == nodes.Iir_Kind.If_Statement:
             yield IfStatement.parse(statement, label)
@@ -974,11 +849,7 @@ def GetSequentialStatementsFromChainedNodes(
             nodes.Iir_Kind.Variable_Assignment_Statement,
             nodes.Iir_Kind.Conditional_Variable_Assignment_Statement,
         ):
-            print(
-                "[NOT IMPLEMENTED] Variable assignment (label: '{label}') at line {line}".format(
-                    label=label, line=pos.Line
-                )
-            )
+            print(f"[NOT IMPLEMENTED] Variable assignment (label: '{label}') at line {position.Line}")
         elif kind == nodes.Iir_Kind.Wait_Statement:
             yield WaitStatement.parse(statement, label)
         elif kind == nodes.Iir_Kind.Procedure_Call_Statement:
@@ -990,16 +861,7 @@ def GetSequentialStatementsFromChainedNodes(
         elif kind == nodes.Iir_Kind.Null_Statement:
             yield NullStatement(statement, label)
         else:
-            raise DOMException(
-                "Unknown statement of kind '{kind}' in {entity} '{name}' at {file}:{line}:{column}.".format(
-                    kind=kind.name,
-                    entity=entity,
-                    name=name,
-                    file=pos.Filename,
-                    line=pos.Line,
-                    column=pos.Column,
-                )
-            )
+            raise DOMException(f"Unknown statement of kind '{kind.name}' in {entity} '{name}' at {position.Filename}:{position.Line}:{position.Column}.")
 
 
 def GetAliasFromNode(aliasNode: Iir):
diff --git a/pyGHDL/dom/_Utils.py b/pyGHDL/dom/_Utils.py
index 76dec9a06..0349a11ef 100644
--- a/pyGHDL/dom/_Utils.py
+++ b/pyGHDL/dom/_Utils.py
@@ -62,9 +62,7 @@ def CheckForErrors() -> None:
             fileName = ""  # name_table.Get_Name_Ptr(files_map.Get_File_Name(rec.file))
             message = errorout_memory.Get_Error_Message(i + 1)
 
-            errors.append(
-                "{file}:{line}:{column}: {msg}".format(file=fileName, line=rec.line, column=rec.offset, msg=message)
-            )
+            errors.append(f"{fileName}:{rec.line}:{rec.offset}: {message}")
 
         raise DOMException("Error raised in libghdl.") from LibGHDLException("libghdl: Internal error.", errors)
 
diff --git a/pyGHDL/dom/__init__.py b/pyGHDL/dom/__init__.py
index f5d38fa09..e9eb89240 100644
--- a/pyGHDL/dom/__init__.py
+++ b/pyGHDL/dom/__init__.py
@@ -83,7 +83,7 @@ class Position:
         return self._column
 
     def __str__(self):
-        return "{file}:{line}:{column}".format(file=self._filename, line=self._line, column=self._column)
+        return f"{self._filename}:{self._line}:{self._column}"
 
 
 @export
diff --git a/pyGHDL/dom/formatting/prettyprint.py b/pyGHDL/dom/formatting/prettyprint.py
index a72a32862..14d13e2c5 100644
--- a/pyGHDL/dom/formatting/prettyprint.py
+++ b/pyGHDL/dom/formatting/prettyprint.py
@@ -117,14 +117,14 @@ class PrettyPrint:
     def formatDesign(self, design: Design, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}Libraries:".format(prefix=prefix))
+        buffer.append(f"{prefix}Libraries:")
         for library in design.Libraries.values():
-            buffer.append("{prefix}  - Name: {name}".format(prefix=prefix, name=library.Identifier))
+            buffer.append(f"{prefix}  - Name: {library.Identifier}")
             for line in self.formatLibrary(library, level + 2):
                 buffer.append(line)
-        buffer.append("{prefix}Documents:".format(prefix=prefix))
+        buffer.append(f"{prefix}Documents:")
         for document in design.Documents:
-            buffer.append("{prefix}  - Path: '{doc!s}':".format(doc=document.Path, prefix=prefix))
+            buffer.append(f"{prefix}  - Path: '{document.Path!s}':")
             for line in self.formatDocument(document, level + 2):
                 buffer.append(line)
 
@@ -133,48 +133,36 @@ class PrettyPrint:
     def formatLibrary(self, library: Library, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}Entities:".format(prefix=prefix))
+        buffer.append(f"{prefix}Entities:")
         for entity in library.Entities:
-            buffer.append(
-                "{prefix}  - {name}({architectures})".format(
-                    prefix=prefix,
-                    name=entity.Identifier,
-                    architectures=", ".join([a.Identifier for a in entity.Architectures]),
-                )
-            )
-        buffer.append("{prefix}Packages:".format(prefix=prefix))
+            buffer.append(f"{prefix}  - {entity.Identifier}({', '.join([a.Identifier for a in entity.Architectures])})")
+        buffer.append(f"{prefix}Packages:")
         for package in library.Packages:
             if isinstance(package, Package):
-                buffer.append("{prefix}  - {name}".format(prefix=prefix, name=package.Identifier))
+                buffer.append(f"{prefix}  - {package.Identifier}")
             elif isinstance(package, PackageInstantiation):
-                buffer.append(
-                    "{prefix}  - {name} instantiate from {package}".format(
-                        prefix=prefix,
-                        name=package.Identifier,
-                        package=package.PackageReference,
-                    )
-                )
-        buffer.append("{prefix}Configurations:".format(prefix=prefix))
+                buffer.append(f"{prefix}  - {package.Identifier} instantiate from {package.PackageReference}")
+        buffer.append(f"{prefix}Configurations:")
         for configuration in library.Configurations:
-            buffer.append("{prefix}  - {name}".format(prefix=prefix, name=configuration.Identifier))
-        buffer.append("{prefix}Contexts:".format(prefix=prefix))
+            buffer.append(f"{prefix}  - {configuration.Identifier}")
+        buffer.append(f"{prefix}Contexts:")
         for context in library.Contexts:
-            buffer.append("{prefix}  - {name}".format(prefix=prefix, name=context.Identifier))
+            buffer.append(f"{prefix}  - {context.Identifier}")
 
         return buffer
 
     def formatDocument(self, document: Document, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}Entities:".format(prefix=prefix))
+        buffer.append(f"{prefix}Entities:")
         for entity in document.Entities:
             for line in self.formatEntity(entity, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}Architectures:".format(prefix=prefix))
+        buffer.append(f"{prefix}Architectures:")
         for architecture in document.Architectures:
             for line in self.formatArchitecture(architecture, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}Packages:".format(prefix=prefix))
+        buffer.append(f"{prefix}Packages:")
         for package in document.Packages:
             if isinstance(package, Package):
                 gen = self.formatPackage
@@ -183,15 +171,15 @@ class PrettyPrint:
 
             for line in gen(package, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}PackageBodies:".format(prefix=prefix))
+        buffer.append(f"{prefix}PackageBodies:")
         for packageBodies in document.PackageBodies:
             for line in self.formatPackageBody(packageBodies, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}Configurations:".format(prefix=prefix))
+        buffer.append(f"{prefix}Configurations:")
         for configuration in document.Configurations:
             for line in self.formatConfiguration(configuration, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}Contexts:".format(prefix=prefix))
+        buffer.append(f"{prefix}Contexts:")
         for context in document.Contexts:
             for line in self.formatContext(context, level + 1):
                 buffer.append(line)
@@ -201,60 +189,44 @@ class PrettyPrint:
     def formatEntity(self, entity: Entity, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append(
-            "{prefix}- Name: {name}\n{prefix}  File: {file}\n{prefix}  Position: {line}:{column}".format(
-                name=entity.Identifier,
-                prefix=prefix,
-                file=entity.Position.Filename.name,
-                line=entity.Position.Line,
-                column=entity.Position.Column,
-            )
-        )
-        buffer.append("{prefix}  Generics:".format(prefix=prefix))
+        buffer.append(f"{prefix}- Name: {entity.Identifier}\n{prefix}  File: {entity.Position.Filename.name}\n{prefix}  Position: {entity.Position.Line}:{entity.Position.Column}")
+        buffer.append(f"{prefix}  Generics:")
         for generic in entity.GenericItems:
             for line in self.formatGeneric(generic, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}  Ports:".format(prefix=prefix))
+        buffer.append(f"{prefix}  Ports:")
         for port in entity.PortItems:
             for line in self.formatPort(port, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}  Declared:".format(prefix=prefix))
+        buffer.append(f"{prefix}  Declared:")
         for item in entity.DeclaredItems:
             for line in self.formatDeclaredItems(item, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}  Statements:".format(prefix=prefix))
+        buffer.append(f"{prefix}  Statements:")
         for item in entity.Statements:
-            buffer.append("{prefix}    ...".format(prefix=prefix))
-        buffer.append("{prefix}  Architecures:".format(prefix=prefix))
+            buffer.append(f"{prefix}    ...")
+        buffer.append(f"{prefix}  Architectures:")
         for item in entity.Architectures:
-            buffer.append("{prefix}  - {name}".format(prefix=prefix, name=item.Identifier))
+            buffer.append(f"{prefix}  - {item.Identifier}")
 
         return buffer
 
     def formatArchitecture(self, architecture: Architecture, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append(
-            "{prefix}- Name: {name}\n{prefix}  File: {file}\n{prefix}  Position: {line}:{column}".format(
-                name=architecture.Identifier,
-                prefix=prefix,
-                file=architecture.Position.Filename.name,
-                line=architecture.Position.Line,
-                column=architecture.Position.Column,
-            )
-        )
-        buffer.append("{prefix}  Entity: {entity}".format(entity=architecture.Entity.SymbolName, prefix=prefix))
-        buffer.append("{prefix}  Declared:".format(prefix=prefix))
+        buffer.append(f"{prefix}- Name: {architecture.Identifier}\n{prefix}  File: {architecture.Position.Filename.name}\n{prefix}  Position: {architecture.Position.Line}:{architecture.Position.Column}")
+        buffer.append(f"{prefix}  Entity: {architecture.Entity.SymbolName}")
+        buffer.append(f"{prefix}  Declared:")
         for item in architecture.DeclaredItems:
             for line in self.formatDeclaredItems(item, level + 2):
                 buffer.append(line)
-        buffer.append("{prefix}  Hierarchy:".format(prefix=prefix))
+        buffer.append(f"{prefix}  Hierarchy:")
         for item in architecture.Statements:
             for line in self.formatHierarchy(item, level + 2):
                 buffer.append(line)
-        buffer.append("{prefix}  Statements:".format(prefix=prefix))
+        buffer.append(f"{prefix}  Statements:")
         for item in architecture.Statements:
-            buffer.append("{prefix}    ...".format(prefix=prefix))
+            buffer.append(f"{prefix}    ...")
         #            for line in self.formatStatements(item, level + 2):
         #                buffer.append(line)
 
@@ -263,12 +235,12 @@ class PrettyPrint:
     def formatComponent(self, component: Component, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- Component: {name}".format(name=component.Identifier, prefix=prefix))
-        buffer.append("{prefix}  Generics:".format(prefix=prefix))
+        buffer.append(f"{prefix}- Component: {component.Identifier}")
+        buffer.append(f"{prefix}  Generics:")
         for generic in component.GenericItems:
             for line in self.formatGeneric(generic, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}  Ports:".format(prefix=prefix))
+        buffer.append(f"{prefix}  Ports:")
         for port in component.PortItems:
             for line in self.formatPort(port, level + 1):
                 buffer.append(line)
@@ -278,16 +250,8 @@ class PrettyPrint:
     def formatPackage(self, package: Package, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append(
-            "{prefix}- Name: {name}\n{prefix}  File: {file}\n{prefix}  Position: {line}:{column}".format(
-                name=package.Identifier,
-                prefix=prefix,
-                file=package.Position.Filename.name,
-                line=package.Position.Line,
-                column=package.Position.Column,
-            )
-        )
-        buffer.append("{prefix}  Declared:".format(prefix=prefix))
+        buffer.append(f"{prefix}- Name: {package.Identifier}\n{prefix}  File: {package.Position.Filename.name}\n{prefix}  Position: {package.Position.Line}:{package.Position.Column}")
+        buffer.append(f"{prefix}  Declared:")
         for item in package.DeclaredItems:
             for line in self.formatDeclaredItems(item, level + 1):
                 buffer.append(line)
@@ -297,9 +261,9 @@ class PrettyPrint:
     def formatPackageInstance(self, package: PackageInstantiation, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- Name: {name}".format(name=package.Identifier, prefix=prefix))
-        buffer.append("{prefix}  Package: {name!s}".format(prefix=prefix, name=package.PackageReference))
-        buffer.append("{prefix}  Generic Map: ...".format(prefix=prefix))
+        buffer.append(f"{prefix}- Name: {package.Identifier}")
+        buffer.append(f"{prefix}  Package: {package.PackageReference!s}")
+        buffer.append(f"{prefix}  Generic Map: ...")
         #        for item in package.GenericItems:
         #            for line in self.formatGeneric(item, level + 1):
         #                buffer.append(line)
@@ -309,8 +273,8 @@ class PrettyPrint:
     def formatPackageBody(self, packageBody: PackageBody, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- Name: {name}".format(name=packageBody.Identifier, prefix=prefix))
-        buffer.append("{prefix}  Declared:".format(prefix=prefix))
+        buffer.append(f"{prefix}- Name: {packageBody.Identifier}")
+        buffer.append(f"{prefix}  Declared:")
         for item in packageBody.DeclaredItems:
             for line in self.formatDeclaredItems(item, level + 1):
                 buffer.append(line)
@@ -320,14 +284,14 @@ class PrettyPrint:
     def formatConfiguration(self, configuration: Configuration, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- Name: {name}".format(name=configuration.Identifier, prefix=prefix))
+        buffer.append(f"{prefix}- Name: {configuration.Identifier}")
 
         return buffer
 
     def formatContext(self, context: Context, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- Name: {name}".format(name=context.Identifier, prefix=prefix))
+        buffer.append(f"{prefix}- Name: {context.Identifier}")
 
         return buffer
 
@@ -337,21 +301,13 @@ class PrettyPrint:
         elif isinstance(generic, GenericTypeInterfaceItem):
             return self.formatGenericType(generic, level)
         else:
-            raise PrettyPrintException(
-                "Unhandled generic kind '{kind}' for generic '{name}'.".format(
-                    kind=generic.__class__.__name__, name=generic.Identifiers[0]
-                )
-            )
+            raise PrettyPrintException(f"Unhandled generic kind '{generic.__class__.__name__}' for generic '{generic.Identifiers[0]}'.")
 
     def formatPort(self, port: Union[NamedEntity, PortInterfaceItem], level: int = 0) -> StringBuffer:
         if isinstance(port, PortSignalInterfaceItem):
             return self.formatPortSignal(port, level)
         else:
-            raise PrettyPrintException(
-                "Unhandled port kind '{kind}' for port '{name}'.".format(
-                    kind=port.__class__.__name__, name=port.Identifiers[0]
-                )
-            )
+            raise PrettyPrintException(f"Unhandled port kind '{port.__class__.__name__}' for port '{port.Identifiers[0]}'.")
 
     def formatGenericConstant(self, generic: GenericConstantInterfaceItem, level: int = 0) -> StringBuffer:
         buffer = []
@@ -373,12 +329,7 @@ class PrettyPrint:
         buffer = []
         prefix = "  " * level
 
-        buffer.append(
-            "{prefix}  - type {name}".format(
-                prefix=prefix,
-                name=generic.Identifier,
-            )
-        )
+        buffer.append(f"{prefix}  - type {generic.Identifier}")
 
         return buffer
 
@@ -404,7 +355,7 @@ class PrettyPrint:
 
         if isinstance(item, BaseConstant):
             if isinstance(item, Constant):
-                default = " := {expr}".format(expr=str(item.DefaultExpression))
+                default = f" := {item.DefaultExpression!s}"
             else:
                 default = ""
 
@@ -430,7 +381,7 @@ class PrettyPrint:
                     prefix=prefix,
                     name=", ".join(item.Identifiers),
                     subtype=self.formatSubtypeIndication(item.Subtype, "signal", item.Identifiers[0]),
-                    initValue=" := {expr}".format(expr=str(item.DefaultExpression))
+                    initValue=f" := {item.DefaultExpression!s}"
                     if item.DefaultExpression is not None
                     else "",
                 )
@@ -444,74 +395,41 @@ class PrettyPrint:
                 )
             )
         elif isinstance(item, (FullType, IncompleteType)):
-            buffer.append("{prefix}- {type}".format(prefix=prefix, type=self.formatType(item)))
+            buffer.append(f"{prefix}- {self.formatType(item)}")
         elif isinstance(item, Subtype):
-            buffer.append(
-                "{prefix}- subtype {name} is ?????".format(
-                    prefix=prefix,
-                    name=item.Identifier,
-                )
-            )
+            buffer.append(f"{prefix}- subtype {item.Identifier} is ?????")
         elif isinstance(item, Alias):
-            buffer.append(
-                "{prefix}- alias {name} is ?????".format(
-                    prefix=prefix,
-                    name=item.Identifier,
-                )
-            )
+            buffer.append(f"{prefix}- alias {item.Identifier} is ?????")
         elif isinstance(item, Function):
-            buffer.append(
-                "{prefix}- function {name} return {returnType!s}".format(
-                    prefix=prefix, name=item.Identifier, returnType=item.ReturnType
-                )
-            )
+            buffer.append(f"{prefix}- function {item.Identifier} return {item.ReturnType!s}")
         elif isinstance(item, Procedure):
-            buffer.append(
-                "{prefix}- procedure {name}".format(
-                    prefix=prefix,
-                    name=item.Identifier,
-                )
-            )
+            buffer.append(f"{prefix}- procedure {item.Identifier}")
         elif isinstance(item, Component):
             for line in self.formatComponent(item, level):
                 buffer.append(line)
         elif isinstance(item, Attribute):
-            buffer.append(
-                "{prefix}- attribute {name} : {type!s}".format(prefix=prefix, name=item.Identifier, type=item.Subtype)
-            )
+            buffer.append(f"{prefix}- attribute {item.Identifier} : {item.Subtype!s}")
         elif isinstance(item, AttributeSpecification):
-            buffer.append(
-                "{prefix}- attribute {name!s} of {entity} : {entityClass} is {value}".format(
-                    prefix=prefix,
-                    name=item.Attribute,
-                    entity="????",
-                    entityClass="????",
-                    value="????",
-                )
-            )
+            buffer.append(f"{prefix}- attribute {item.Attribute!s} of {'????'} : {'????'} is {'????'}")
         elif isinstance(item, UseClause):
             buffer.append("{prefix}- use {names}".format(prefix=prefix, names=", ".join([str(n) for n in item.Names])))
         elif isinstance(item, Package):
-            buffer.append("{prefix}- package {name} is ..... end package".format(prefix=prefix, name=item.Identifier))
+            buffer.append(f"{prefix}- package {item.Identifier} is ..... end package")
         elif isinstance(item, PackageInstantiation):
-            buffer.append(
-                "{prefix}- package {name} is new {name2!s} generic map (.....)".format(
-                    prefix=prefix, name=item.Identifier, name2=item.PackageReference
-                )
-            )
+            buffer.append(f"{prefix}- package {item.Identifier} is new {item.PackageReference!s} generic map (.....)")
         elif isinstance(item, DefaultClock):
-            buffer.append("{prefix}- default {name} is {expr}".format(prefix=prefix, name=item.Identifier, expr="..."))
+            buffer.append(f"{prefix}- default {item.Identifier} is {'...'}", )
         else:
-            raise PrettyPrintException("Unhandled declared item kind '{name}'.".format(name=item.__class__.__name__))
+            raise PrettyPrintException(f"Unhandled declared item kind '{item.__class__.__name__}'.")
 
         return buffer
 
     def formatType(self, item: BaseType) -> str:
-        result = "type {name} is ".format(name=item.Identifier)
+        result = f"type {item.Identifier} is "
         if isinstance(item, IncompleteType):
             result += ""
         elif isinstance(item, IntegerType):
-            result += "range {range!s}".format(range=item.Range)
+            result += f"range {item.Range!s}"
         elif isinstance(item, EnumeratedType):
             result += "(........)"
         elif isinstance(item, PhysicalType):
@@ -529,13 +447,13 @@ class PrettyPrint:
         elif isinstance(item, ProtectedTypeBody):
             result += "protected body ..... end protected body"
         else:
-            raise PrettyPrintException("Unknown type '{name}'".format(name=item.__class__.__name__))
+            raise PrettyPrintException(f"Unknown type '{item.__class__.__name__}'")
 
         return result
 
     def formatSubtypeIndication(self, subtypeIndication, entity: str, name: str) -> str:
         if isinstance(subtypeIndication, SimpleSubtypeSymbol):
-            return "{type}".format(type=subtypeIndication.SymbolName)
+            return f"{subtypeIndication.SymbolName}"
         elif isinstance(subtypeIndication, ConstrainedCompositeSubtypeSymbol):
             constraints = []
             for constraint in subtypeIndication.Constraints:
@@ -543,102 +461,59 @@ class PrettyPrint:
 
             return "{type}({constraints})".format(type=subtypeIndication.SymbolName, constraints=", ".join(constraints))
         else:
-            raise PrettyPrintException(
-                "Unhandled subtype kind '{type}' for {entity} '{name}'.".format(
-                    type=subtypeIndication.__class__.__name__, entity=entity, name=name
-                )
-            )
+            raise PrettyPrintException(f"Unhandled subtype kind '{subtypeIndication.__class__.__name__}' for {entity} '{name}'.")
 
     def formatInitialValue(self, item: WithDefaultExpressionMixin) -> str:
         if item.DefaultExpression is None:
             return ""
 
-        return " := {expr!s}".format(expr=item.DefaultExpression)
+        return f" := {item.DefaultExpression!s}"
 
     def formatHierarchy(self, statement: ConcurrentStatement, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
 
         if isinstance(statement, ProcessStatement):
-            buffer.append("{prefix}- {label}: process(...)".format(prefix=prefix, label=statement.Label))
+            buffer.append(f"{prefix}- {statement.Label}: process(...)")
         elif isinstance(statement, EntityInstantiation):
-            buffer.append(
-                "{prefix}- {label}: entity {name}".format(prefix=prefix, label=statement.Label, name=statement.Entity)
-            )
+            buffer.append(f"{prefix}- {statement.Label}: entity {statement.Entity}")
         elif isinstance(statement, ComponentInstantiation):
-            buffer.append(
-                "{prefix}- {label}: component {name}".format(
-                    prefix=prefix, label=statement.Label, name=statement.Component
-                )
-            )
+            buffer.append(f"{prefix}- {statement.Label}: component {statement.Component}")
         elif isinstance(statement, ConfigurationInstantiation):
-            buffer.append(
-                "{prefix}- {label}: configuration {name}".format(
-                    prefix=prefix, label=statement.Label, name=statement.Configuration
-                )
-            )
+            buffer.append(f"{prefix}- {statement.Label}: configuration {statement.Configuration}")
         elif isinstance(statement, ConcurrentBlockStatement):
-            buffer.append("{prefix}- {label}: block".format(prefix=prefix, label=statement.Label))
+            buffer.append(f"{prefix}- {statement.Label}: block")
             for stmt in statement.Statements:
                 for line in self.formatHierarchy(stmt, level + 2):
                     buffer.append(line)
         elif isinstance(statement, IfGenerateStatement):
-            buffer.append(
-                "{prefix}- {label}: if {condition} generate".format(
-                    prefix=prefix,
-                    label=statement.Label,
-                    condition=statement.IfBranch.Condition,
-                )
-            )
+            buffer.append(f"{prefix}- {statement.Label}: if {statement.IfBranch.Condition} generate")
             for stmt in statement.IfBranch.Statements:
                 for line in self.formatHierarchy(stmt, level + 2):
                     buffer.append(line)
             for elsifBranch in statement.ElsifBranches:
-                buffer.append(
-                    "{prefix}  {label}: elsif {condition} generate".format(
-                        prefix=prefix,
-                        label=statement.Label,
-                        condition=elsifBranch.Condition,
-                    )
-                )
+                buffer.append(f"{prefix}  {statement.Label}: elsif {elsifBranch.Condition} generate")
                 for stmt in elsifBranch.Statements:
                     for line in self.formatHierarchy(stmt, level + 2):
                         buffer.append(line)
             if statement.ElseBranch is not None:
-                buffer.append("{prefix}  {label}: else generate".format(prefix=prefix, label=statement.Label))
+                buffer.append(f"{prefix}  {statement.Label}: else generate")
                 for stmt in statement.ElseBranch.Statements:
                     for line in self.formatHierarchy(stmt, level + 2):
                         buffer.append(line)
         elif isinstance(statement, CaseGenerateStatement):
-            buffer.append(
-                "{prefix}- {label}: case {expression} generate".format(
-                    prefix=prefix,
-                    label=statement.Label,
-                    expression=statement.SelectExpression,
-                )
-            )
+            buffer.append(f"{prefix}- {statement.Label}: case {statement.SelectExpression} generate")
             for case in statement.Cases:
-                buffer.append("{prefix}    {case!s}".format(prefix=prefix, label=case.Label, case=case))
+                buffer.append(f"{prefix}    {case!s}")
                 for stmt in case.Statements:
                     for line in self.formatHierarchy(stmt, level + 2):
                         buffer.append(line)
         elif isinstance(statement, ForGenerateStatement):
-            buffer.append(
-                "{prefix}- {label}: for {index} in {range} generate".format(
-                    prefix=prefix,
-                    label=statement.Label,
-                    index=statement.LoopIndex,
-                    range=statement.Range,
-                )
-            )
+            buffer.append(f"{prefix}- {statement.Label}: for {statement.LoopIndex} in {statement.Range} generate")
             for stmt in statement.Statements:
                 for line in self.formatHierarchy(stmt, level + 2):
                     buffer.append(line)
         elif isinstance(statement, ConcurrentProcedureCall):
-            buffer.append(
-                "{prefix}- {label}: {name!s}(...)".format(
-                    prefix=prefix, label=statement.Label, name=statement.Procedure
-                )
-            )
+            buffer.append(f"{prefix}- {statement.Label}: {statement.Procedure!s}(...)")
 
         return buffer
diff --git a/pyGHDL/libghdl/_decorator.py b/pyGHDL/libghdl/_decorator.py
index b124461e5..99ebbe286 100644
--- a/pyGHDL/libghdl/_decorator.py
+++ b/pyGHDL/libghdl/_decorator.py
@@ -116,7 +116,7 @@ def BindToLibGHDL(subprogramName):
                 c_double,
             ):
                 return typ.__bound__
-            raise TypeError("Unsupported typevar bound to {!s}".format(typ.__bound__))
+            raise TypeError(f"Unsupported typevar bound to {typ.__bound__!s}")
         elif issubclass(typ, IntEnum):
             return c_int32
         elif issubclass(typ, Structure):
@@ -128,19 +128,15 @@ def BindToLibGHDL(subprogramName):
         typeHintCount = len(typeHints)
 
         if typeHintCount == 0:
-            raise ValueError("Function {0} is not annotated with types.".format(func.__name__))
+            raise ValueError(f"Function {func.__name__} is not annotated with types.")
 
         try:
             returnType = typeHints["return"]
         except KeyError:
-            raise ValueError("Function {0} is not annotated with a return type.".format(func.__name__))
+            raise ValueError(f"Function {func.__name__} is not annotated with a return type.")
 
         if (typeHintCount - 1) != func.__code__.co_argcount:
-            raise ValueError(
-                "Number of type annotations ({0}) for function '{1}' does not match number of parameters ({2}).".format(
-                    typeHintCount - 1, func.__name__, func.__code__.co_argcount
-                )
-            )
+            raise ValueError(f"Number of type annotations ({typeHintCount - 1}) for function '{func.__name__}' does not match number of parameters ({func.__code__.co_argcount}).")
 
         # 		print(typeHints)
 
@@ -152,14 +148,12 @@ def BindToLibGHDL(subprogramName):
             try:
                 parameterTypes.append(PythonTypeToCtype(parameter))
             except TypeError:
-                raise TypeError(
-                    "Unsupported parameter type '{0!s}' in function '{1}'.".format(parameter, func.__name__)
-                )
+                raise TypeError(f"Unsupported parameter type '{parameter!s}' in function '{func.__name__}'.")
 
         try:
             resultType = PythonTypeToCtype(returnType)
         except TypeError:
-            raise TypeError("Unsupported return type '{0!s}' in function '{1}'.".format(returnType, func.__name__))
+            raise TypeError(f"Unsupported return type '{returnType!s}' in function '{func.__name__}'.")
 
         functionPointer = getattr(libghdl, subprogramName)
         functionPointer.parameterTypes = parameterTypes
@@ -173,10 +167,7 @@ def BindToLibGHDL(subprogramName):
                     returnValue = functionPointer(*args)
                 except OSError as ex:
                     errors = [str(ex)]
-                    raise LibGHDLException(
-                        "Caught exception when calling '{func}' in libghdl.".format(func=subprogramName),
-                        errors,
-                    ) from ex
+                    raise LibGHDLException(f"Caught exception when calling '{subprogramName}' in libghdl.", errors,) from ex
 
                 return returnType(returnValue)
 
@@ -189,10 +180,7 @@ def BindToLibGHDL(subprogramName):
                     return functionPointer(*args)
                 except OSError as ex:
                     errors = [str(ex)]
-                    raise LibGHDLException(
-                        "Caught exception when calling '{func}' in libghdl.".format(func=subprogramName),
-                        errors,
-                    ) from ex
+                    raise LibGHDLException(f"Caught exception when calling '{subprogramName}' in libghdl.", errors,) from ex
 
             return inner
 
diff --git a/pyGHDL/lsp/lsp.py b/pyGHDL/lsp/lsp.py
index 03b4c38e4..0b392ea84 100644
--- a/pyGHDL/lsp/lsp.py
+++ b/pyGHDL/lsp/lsp.py
@@ -139,7 +139,7 @@ class LanguageProtocolServer(object):
                 log.exception("Caught exception while handling %s with params %s:", method, params)
                 self.show_message(
                     MessageType.Error,
-                    ("Caught exception while handling {}, see VHDL language server output for details.").format(method),
+                    f"Caught exception while handling {method}, see VHDL language server output for details.",
                 )
                 response = None
             if tid is None:
@@ -163,14 +163,14 @@ class LanguageProtocolServer(object):
                 "id": tid,
                 "error": {
                     "code": JSONErrorCodes.MethodNotFound,
-                    "message": "unknown method {}".format(method),
+                    "message": f"unknown method {method}",
                 },
             }
         return rbody
 
     def write_output(self, body):
         output = json.dumps(body, separators=(",", ":"))
-        self.conn.write("Content-Length: {}\r\n".format(len(output)))
+        self.conn.write(f"Content-Length: {len(output)}\r\n")
         self.conn.write("\r\n")
         self.conn.write(output)
 
diff --git a/pyGHDL/lsp/symbols.py b/pyGHDL/lsp/symbols.py
index fdb090221..332436e5e 100644
--- a/pyGHDL/lsp/symbols.py
+++ b/pyGHDL/lsp/symbols.py
@@ -93,7 +93,7 @@ def get_symbols(fe, n):
         return get_symbols(fe, nodes.Get_Library_Unit(n))
     m = SYMBOLS_MAP.get(k, None)
     if m is None:
-        raise AssertionError("get_symbol: unhandled {}".format(pyutils.kind_image(k)))
+        raise AssertionError(f"get_symbol: unhandled {pyutils.kind_image(k)}")
     kind = m["kind"]
     if kind is None:
         return None
diff --git a/pyGHDL/lsp/workspace.py b/pyGHDL/lsp/workspace.py
index c3a575e5d..88200bc49 100644
--- a/pyGHDL/lsp/workspace.py
+++ b/pyGHDL/lsp/workspace.py
@@ -158,7 +158,7 @@ class Workspace(object):
             sfe = document.Document.load(fd.read(), self._root_path, name)
             fd.close()
         except OSError as err:
-            self._server.show_message(lsp.MessageType.Error, "cannot load {}: {}".format(name, err.strerror))
+            self._server.show_message(lsp.MessageType.Error, f"cannot load {name}: {err.strerror}")
             return
         doc = self.create_document_from_sfe(sfe, absname)
         doc.parse_document()
@@ -173,7 +173,7 @@ class Workspace(object):
         except OSError as err:
             self._server.show_message(
                 lsp.MessageType.Error,
-                "cannot open project file {}: {}".format(prj_file, err.strerror),
+                f"cannot open project file {prj_file}: {err.strerror}",
             )
             return
         log.info("reading project file %s", prj_file)
@@ -183,7 +183,7 @@ class Workspace(object):
             log.info("error in project file")
             self._server.show_message(
                 lsp.MessageType.Error,
-                "json error in project file {}:{}:{}".format(prj_file, e.lineno, e.colno),
+                f"json error in project file {prj_file}:{e.lineno}:{e.colno}",
             )
         f.close()
 
@@ -204,9 +204,9 @@ class Workspace(object):
             log.info("Using options: %s", ghdl_opts)
             for opt in ghdl_opts:
                 if not libghdl.set_option(opt):
-                    self._server.show_message(lsp.MessageType.Error, "error with option: {}".format(opt))
+                    self._server.show_message(lsp.MessageType.Error, f"error with option: {opt}")
         except ProjectError as e:
-            self._server.show_message(lsp.MessageType.Error, "error in project file: {}".format(e.msg))
+            self._server.show_message(lsp.MessageType.Error, f"error in project file: {e.msg}")
 
     def read_files_from_project(self):
         try:
@@ -223,7 +223,7 @@ class Workspace(object):
                 if lang == "vhdl":
                     self.add_vhdl_file(name)
         except ProjectError as e:
-            self._server.show_message(lsp.MessageType.Error, "error in project file: {}".format(e.msg))
+            self._server.show_message(lsp.MessageType.Error, f"error in project file: {e.msg}")
 
     def get_configuration(self):
         self._server.configuration([{"scopeUri": "", "section": "vhdl.maxNumberOfProblems"}])
diff --git a/scripts/pnodes.py b/scripts/pnodes.py
index ec00a54ac..29a2909c0 100755
--- a/scripts/pnodes.py
+++ b/scripts/pnodes.py
@@ -73,7 +73,7 @@ class ParseError(Exception):
         self.msg = msg
 
     def __str__(self):
-        return ("Parse error at {lr.filename}:{lr.lineno}: {msg}".format(lr=self.lr, msg=self.msg))
+        return f"Parse error at {self.lr.filename}:{self.lr.lineno}: {self.msg}"
 
 
 # Return fields description.
@@ -328,7 +328,7 @@ def read_nodes_fields(lr, names, fields, nodes, funcs_dict):
     cur_nodes = []
     for (nm, fmt) in names:
         if fmt not in fields:
-            raise ParseError(lr, 'unknown format "{}"'.format(fmt))
+            raise ParseError(lr, f'unknown format "{fmt}"')
         n = NodeDesc(nm, fmt, {x: None for x in fields[fmt]}, {})
         nodes[nm] = n
         cur_nodes.append(n)
diff --git a/scripts/pnodespy.py b/scripts/pnodespy.py
index 90c827de9..caa06b2b9 100755
--- a/scripts/pnodespy.py
+++ b/scripts/pnodespy.py
@@ -17,17 +17,17 @@ libname = "libghdl"
 
 
 def print_enum(name, vals):
-    print(dedent("""
+    print(dedent(f"""
 
         @export
         @unique
-        class {0}(IntEnum):
-        """).format(name), end=''
+        class {name}(IntEnum):
+        """), end=''
     )
     for n, k in enumerate(vals):
         if k == "None":
             k = "PNone"
-        print("    {0} = {1}".format(k, n))
+        print(f"    {k} = {n}")
 
 
 def print_file_header(includeIntEnumUnique=True, includeBindToLibGHDL=True):
@@ -51,16 +51,16 @@ def do_class_kinds():
         """), end=''
     )
     for k, v in pnodes.kinds_ranges.items():
-        print("    {0} = [".format(k))
+        print(f"    {k} = [")
         for e in v:
-            print("        Iir_Kind.{},".format(e))
+            print(f"        Iir_Kind.{e},")
         print("    ]")
         print()
 
 
 def do_iirs_subprg():
     classname = "vhdl__nodes"
-    print(dedent("""
+    print(dedent(f"""
 
         @export
         @BindToLibGHDL("{classname}__get_kind")
@@ -73,7 +73,7 @@ def do_iirs_subprg():
         def Get_Location(node: Iir) -> LocationType:
             \"\"\"\"\"\"
             return 0
-        """).format(libname=libname, classname=classname)
+        """)
     )
     for k in pnodes.funcs:
         # Don't use the Iir_* subtypes (as they are not described).
@@ -82,18 +82,17 @@ def do_iirs_subprg():
         if rtype == "TokenType":
             rtype = "Tok"
 
-        print(dedent("""
+        print(dedent(f"""
             @export
-            @BindToLibGHDL("{classname}__get_{kname_lower}")
-            def Get_{kname}(obj: Iir) -> {rtype}:
+            @BindToLibGHDL("{classname}__get_{k.name.lower()}")
+            def Get_{k.name}(obj: Iir) -> {rtype}:
                 \"\"\"\"\"\"
                 return 0
             @export
-            @BindToLibGHDL("{classname}__set_{kname_lower}")
-            def Set_{kname}(obj: Iir, value: {rtype}) -> None:
+            @BindToLibGHDL("{classname}__set_{k.name.lower()}")
+            def Set_{k.name}(obj: Iir, value: {rtype}) -> None:
                 \"\"\"\"\"\"
-            """).format(kname=k.name, kname_lower=k.name.lower(), rtype=rtype,
-                         libname=libname, classname=classname)
+            """)
         )
 
 
@@ -103,14 +102,14 @@ def do_libghdl_elocations():
     print("from pyGHDL.libghdl import libghdl")
     print()
     for k in pnodes.funcs:
-        print(dedent("""
+        print(dedent(f"""
             @export
-            def Get_{kname}(obj):
-                return {libname}.{classname}__get_{kname_lower}(obj)
+            def Get_{k.name}(obj):
+                return {libname}.{classname}__get_{k.name.lower()}(obj)
             @export
-            def Set_{kname}(obj, value) -> None:
-                {libname}.{classname}__set_{kname_lower}(obj, value)
-            """).format(kname=k.name, kname_lower=k.name.lower(), libname=libname, classname=classname)
+            def Set_{k.name}(obj, value) -> None:
+                {libname}.{classname}__set_{k.name.lower()}(obj, value)
+            """)
         )
 
 
@@ -121,22 +120,22 @@ def do_class_types():
 def do_types_subprg():
     print()
     for k in pnodes.get_types():
-        print(dedent("""
-            def Get_{0}(node, field):
-                return {1}.vhdl__nodes_meta__get_{2}(node, field)
-            """).format(k, libname, k.lower())
+        print(dedent(f"""
+            def Get_{k}(node, field):
+                return {libname}.vhdl__nodes_meta__get_{k.lower()}(node, field)
+            """)
         )
 
 
 def do_has_subprg():
     print()
     for f in pnodes.funcs:
-        print(dedent("""
+        print(dedent(f"""
             @export
-            @BindToLibGHDL("vhdl__nodes_meta__has_{fname_lower}")
-            def Has_{fname}(kind: IirKind) -> bool:
+            @BindToLibGHDL("vhdl__nodes_meta__has_{f.name.lower()}")
+            def Has_{f.name}(kind: IirKind) -> bool:
                 \"\"\"\"\"\"
-            """).format(fname=f.name, libname=libname, fname_lower=f.name.lower())
+            """)
         )
 
 
@@ -158,9 +157,7 @@ def read_enum(filename, type_name, prefix, class_name, g=lambda m: m.group(1)):
         pass
     line = lr.get()
     if line != "     (\n":
-        raise pnodes.ParseError(
-            lr, "{}:{}: missing open parenthesis".format(filename, lr.lineno)
-        )
+        raise pnodes.ParseError(lr, f"{filename}:{lr.lineno}: missing open parenthesis")
     toks = []
     while True:
         line = lr.get()
@@ -177,9 +174,7 @@ def read_enum(filename, type_name, prefix, class_name, g=lambda m: m.group(1)):
             print(line, file=sys.stderr)
             raise pnodes.ParseError(
                 lr,
-                "{}:{}: incorrect line in enum {}".format(
-                    filename, lr.lineno, type_name
-                ),
+                f"{filename}:{ lr.lineno}: incorrect line in enum {type_name}"
             )
     print_enum(class_name, toks)
 
@@ -334,7 +329,7 @@ def do_libghdl_names():
                 val = 0
             val_ref = dict.get(name_ref, None)
             if not val_ref:
-                raise pnodes.ParseError(lr, "name {0} not found".format(name_ref))
+                raise pnodes.ParseError(lr, f"name {name_ref} not found")
             val = val_ref + int(val)
             val_max = max(val_max, val)
             dict[name_def] = val
@@ -351,7 +346,7 @@ def do_libghdl_names():
         # Avoid clash with Python names
         if n in ["False", "True", "None"]:
             n = "N" + n
-        print("    {0} = {1}".format(n, v))
+        print(f"    {n} = {v}")
 
 
 def do_libghdl_tokens():
diff --git a/testsuite/pyunit/libghdl/Comments.py b/testsuite/pyunit/libghdl/Comments.py
index 850d6137a..69571d966 100644
--- a/testsuite/pyunit/libghdl/Comments.py
+++ b/testsuite/pyunit/libghdl/Comments.py
@@ -41,7 +41,7 @@ class Instantiate(TestCase):
         while idx != file_comments.No_Comment_Index:
             s = file_comments.Get_Comment(f, idx)
             self.assertTrue(s.find(':'+name+':') >= 0,
-                            "no :{}: in '{}'".format(name, s))
+                            f"no :{name}: in '{s}'")
             idx = file_comments.Get_Next_Comment(f, idx)
 
     def checkFlist(self, flist) -> None:
@@ -83,7 +83,7 @@ class Instantiate(TestCase):
         file_id = name_table.Get_Identifier(str(filename))
         sfe = files_map.Read_Source_File(name_table.Null_Identifier, file_id)
         if sfe == files_map.No_Source_File_Entry:
-            self.fail("Cannot read file '{!s}'".format(filename))
+            self.fail(f"Cannot read file '{filename!s}'")
 
         # Parse
         file = sem_lib.Load_File(sfe)
diff --git a/testsuite/pyunit/libghdl/VHDL.py b/testsuite/pyunit/libghdl/VHDL.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/testsuite/pyunit/libghdl/VHDL.py
diff --git a/testsuite/pyunit/lsp/LanguageServer.py b/testsuite/pyunit/lsp/LanguageServer.py
index 79c891868..a757d653f 100644
--- a/testsuite/pyunit/lsp/LanguageServer.py
+++ b/testsuite/pyunit/lsp/LanguageServer.py
@@ -30,29 +30,29 @@ def show_diffs(name, ref, res):
     if isinstance(ref, dict) and isinstance(res, dict):
         for k in ref:
             if k not in res:
-                print("{}.{} not in the result".format(name, k))
+                print(f"{name}.{k} not in the result")
             else:
-                show_diffs("{}.{}".format(name, k), ref[k], res[k])
+                show_diffs(f"{name}.{k}", ref[k], res[k])
         for k in res:
             if k not in ref:
-                print("{}.{} unexpected in the result".format(name, k))
+                print(f"{name}.{k} unexpected in the result")
     elif isinstance(ref, str) and isinstance(res, str):
         if res != ref:
-            print("{}: mismatch (ref: {}, result: {})".format(name, ref, res))
+            print(f"{name}: mismatch (ref: {ref}, result: {res})")
     elif isinstance(ref, int) and isinstance(res, int):
         if res != ref:
-            print("{}: mismatch (ref: {}, result: {})".format(name, ref, res))
+            print(f"{name}: mismatch (ref: {ref}, result: {res})")
     elif isinstance(ref, list) and isinstance(res, list):
         for i in range(max(len(ref), len(res))):
             if i >= len(res):
-                print("{}[{}]: missing element:".format(name, i))
-                print(" {}".format(res[i]))
+                print(f"{name}[{i}]: missing element:")
+                print(f" {res[i]}")
             elif i >= len(ref):
-                print("{}[{}]: extra elements".format(name, i))
+                print(f"{name}[{i}]: extra elements")
             else:
-                show_diffs("{}[{}]".format(name, i), ref[i], res[i])
+                show_diffs(f"{name}[{i}]", ref[i], res[i])
     else:
-        print("unhandle type {} in {}".format(type(ref), name))
+        print(f"unhandle type {type(ref)} in {name}")
 
 
 def root_subst(obj, path, uri):
@@ -81,7 +81,7 @@ def root_subst(obj, path, uri):
             res.append(root_subst(v, path, uri))
         return res
     else:
-        raise AssertionError("root_subst: unhandled type {}".format(type(obj)))
+        raise AssertionError(f"root_subst: unhandled type {type(obj)}")
 
 
 class JSONTest(TestCase):
@@ -140,17 +140,17 @@ class JSONTest(TestCase):
 
             rep = json_loads(rep)
             json_res.append(rep)
-            # 			self.assertEqual(rep, r, "reply does not match for {!s}".format(requestFile))
+            # 			self.assertEqual(rep, r, f"reply does not match for {requestFile!s}")
             if rep != r:
                 print(self.__class__.__name__)
-                show_diffs("[{}]".format(i), r, rep)
+                show_diffs(f"[{i}]", r, rep)
                 errs += 1
 
         rep = ls.read_request()
         self.assertIsNone(rep, "Too many replies.")
 
         if errs != 0:
-            print("FAILURE between output and {!s} (for {!s})".format(responseFile, requestFile))
+            print(f"FAILURE between output and {responseFile!s} (for {requestFile!s})")
             print("Writing result output to result.json")
             with open("result.json", "w") as f:
                 f.write(json_dumps(json_res, indent=2))