Formatting Cleanup (#569)

- Convert all s-string into f-string
- Remove mode "r" from `load` function, as it is the default value
- Write sets using brackets instead of `Set` constructor

Author: phiwuu

lobster/common/exceptions.py

@@ -28,7 +28,7 @@ def __init__(self, message, data=None):
         self.data     = data
 
     def dump(self):
-        print("LOBSTER Error: %s" % self.message)
+        print(f"LOBSTER Error: {self.message}")
         if self.data:
             print("-" * 60)
             pprint(self.data)

lobster/common/io.py

@@ -65,7 +65,7 @@ def lobster_read(
     loc = File_Reference(filename)
 
     # Read and validate JSON
-    with open(filename, "r", encoding="UTF-8") as fd:
+    with open(filename, encoding="UTF-8") as fd:
         try:
             data = json.load(fd)
         except json.decoder.JSONDecodeError as err:
@@ -80,7 +80,7 @@ def lobster_read(
 
     for rkey in ("schema", "version", "generator", "data"):
         if rkey not in data:
-            mh.error(loc, "required top-level key %s not present" % rkey)
+            mh.error(loc, f"required top-level key {rkey} not present")
         if rkey == "data":
             if not isinstance(data[rkey], list):
                 mh.error(loc, "data is not an array")
@@ -89,16 +89,16 @@ def lobster_read(
                 mh.error(loc, "version is not an integer")
         else:
             if not isinstance(data[rkey], str):
-                mh.error(loc, "%s is not a string" % rkey)
+                mh.error(loc, f"{rkey} is not a string")
 
     # Validate indicated schema
     supported_schema = {
-        "lobster-req-trace" : set([3, 4]),
-        "lobster-imp-trace" : set([3]),
-        "lobster-act-trace" : set([3]),
+        "lobster-req-trace" : {3, 4},
+        "lobster-imp-trace" : {3},
+        "lobster-act-trace" : {3},
     }
     if data["schema"] not in supported_schema:
-        mh.error(loc, "unknown schema kind %s" % data["schema"])
+        mh.error(loc, f"unknown schema kind {data['schema']}")
     if data["version"] not in supported_schema[data["schema"]]:
         mh.error(loc,
                  "version %u for schema %s is not supported" %

lobster/common/items.py

@@ -43,10 +43,9 @@ def __init__(
         self.hash_val  = None
 
     def __str__(self):
-        rv = "%s %s" % (self.namespace,
-                        self.tag)
+        rv = f"{self.namespace} {self.tag}"
         if self.version:
-            rv += "@%s" % str(self.version)
+            rv += f"@{self.version}"
         return rv
 
     def key(self) -> str:

lobster/common/lexer.py

@@ -36,9 +36,7 @@ def value(self):
         return self.text
 
     def __repr__(self):
-        return "Token(%s, %s, %s)" % (self.kind,
-                                      self.text,
-                                      self.loc)
+        return f"Token({self.kind}, {self.text}, {self.loc})"
 
 
 class Lexer:
@@ -50,7 +48,7 @@ def __init__(self, mh, file_name):
         self.file_name = file_name
         self.mh        = mh
 
-        with open(file_name, "r", encoding="UTF-8") as fd:
+        with open(file_name, encoding="UTF-8") as fd:
             self.content = fd.read()
             self.length  = len(self.content)
 
@@ -114,7 +112,7 @@ def token(self):
             while self.nc.isalpha() or self.nc == "_":
                 self.advance()
         else:
-            self.error("unexpected character: '%s'" % self.cc)
+            self.error(f"unexpected character: '{self.cc}'")
 
         t_end = self.lexpos
 

lobster/common/parser.py

@@ -60,15 +60,13 @@ def match(self, kind, value=None):
         elif self.nt is None:
             self.error(
                 location.File_Reference(filename = self.lexer.file_name),
-                "expected %s, found EOF" % kind)
+                f"expected {kind}, found EOF")
         elif value is None:
             self.error(self.nt.loc,
-                       "expected %s, found %s %s" % (kind,
-                                                     self.nt.kind,
-                                                     self.nt.value()))
+                       f"expected {kind}, found {self.nt.kind} {self.nt.value()}")
         else:
             self.error(self.nt.loc,
-                       "expected %s, found %s" % (value, self.nt.value()))
+                       f"expected {value}, found {self.nt.value()}")
 
     def warning(self, loc, message):
         self.lexer.mh.warning(loc, message)
@@ -117,7 +115,7 @@ def parse_level_declaration(self):
                 }
                 if not os.path.isfile(source_info["file"]):
                     self.error(self.ct.loc,
-                               "cannot find file %s" % source_info["file"])
+                               f"cannot find file {source_info['file']}")
                 item.source.append(source_info)
 
                 if self.peek("KEYWORD", "with"):
@@ -135,7 +133,7 @@ def parse_level_declaration(self):
                                "cannot trace to yourself")
                 elif self.ct.value() not in self.levels:
                     self.error(self.ct.loc,
-                               "unknown item %s" % self.ct.value())
+                               f"unknown item {self.ct.value()}")
                 else:
                     self.levels[self.ct.value()].needs_tracing_down = True
                 item.traces.append(self.ct.value())
@@ -163,7 +161,7 @@ def parse_level_declaration(self):
 
             else:
                 self.error(self.nt.loc,
-                           "unexpected directive %s" % self.nt.value())
+                           f"unexpected directive {self.nt.value()}")
 
         self.match("C_KET")
 
@@ -180,12 +178,10 @@ def load(mh, file_name):
                 new_chain = []
                 for tok in chain:
                     if tok.value() not in ast:
-                        mh.error(tok.loc, "unknown level %s" % tok.value())
+                        mh.error(tok.loc, f"unknown level {tok.value()}")
                     if item.name not in ast[tok.value()].traces:
                         mh.error(tok.loc,
-                                 "%s cannot trace to %s items" %
-                                 (tok.value(),
-                                  item.name))
+                                 f"{tok.value()} cannot trace to {item.name} items")
                     new_chain.append(tok.value())
                 item.breakdown_requirements.append(new_chain)
         else:

lobster/common/report.py

@@ -80,7 +80,7 @@ def resolve_references_for_items(self):
             while src_item.unresolved_references:
                 dst_tag = src_item.unresolved_references.pop()
                 if dst_tag.key() not in self.items:
-                    src_item.error("unknown tracing target %s" % dst_tag.key())
+                    src_item.error(f"unknown tracing target {dst_tag.key()}")
                     continue
                 dst_item = self.items[dst_tag.key()]
                 # TODO: Check if policy allows this link
@@ -151,7 +151,7 @@ def load_report(self, filename):
         loc = File_Reference(filename)
 
         # Read and validate JSON
-        with open(filename, "r", encoding="UTF-8") as fd:
+        with open(filename, encoding="UTF-8") as fd:
             try:
                 data = json.load(fd)
             except json.decoder.JSONDecodeError as err:
@@ -231,10 +231,10 @@ def validate_indicated_schema(self, data, loc):
 
         """
         supported_schema = {
-            "lobster-report": set([2]),
+            "lobster-report": {2},
         }
         if data["schema"] not in supported_schema:
-            self.mh.error(loc, "unknown schema kind %s" % data["schema"])
+            self.mh.error(loc, f"unknown schema kind {data['schema']}")
         if data["version"] not in supported_schema[data["schema"]]:
             self.mh.error(loc,
                           "version %u for schema %s is not supported" %
@@ -262,6 +262,6 @@ def validate_basic_structure_of_lobster_file(self, data, loc):
                      dict: "an object"}
         for rkey, rvalue in rkey_dict.items():
             if rkey not in data:
-                self.mh.error(loc, "required top-level key %s not present" % rkey)
+                self.mh.error(loc, f"required top-level key {rkey} not present")
             if not isinstance(data[rkey], rvalue):
-                self.mh.error(loc, "%s is not %s." % (rkey, type_dict[rvalue]))
+                self.mh.error(loc, f"{rkey} is not {type_dict[rvalue]}.")

lobster/common/version.py

@@ -21,7 +21,7 @@
 VERSION_SUFFIX = "dev"
 
 LOBSTER_VERSION = ".".join(str(x) for x in VERSION_TUPLE) + (
-    "-%s" % VERSION_SUFFIX if VERSION_SUFFIX else ""
+    f"-{VERSION_SUFFIX}" if VERSION_SUFFIX else ""
 )
 
-FULL_NAME = "LOBSTER %s" % LOBSTER_VERSION
+FULL_NAME = f"LOBSTER {LOBSTER_VERSION}"

lobster/htmldoc/htmldoc.py

@@ -235,7 +235,7 @@ def __init__(self, title, subtitle):
             "h2" : {
                 "padding"       : "0.5em",
                 "margin"        : "0",
-                "border-bottom" : "0.25em solid %s" % self.primary_color,
+                "border-bottom" : f"0.25em solid {self.primary_color}",
                 "text-align"    : "right",
             },
             ".content" : {
@@ -298,13 +298,13 @@ def render(self):
             "<html>",
             "<head>",
             "<meta http-equiv='Content-Type' content='text/html; charset=utf-8'>",
-            "<title>%s</title>" % html.escape(self.title),
+            f"<title>{html.escape(self.title)}</title>",
             "<style>"
         ]
         for elem, style in self.style.items():
             rv.append("%s {" % elem)
             for attr, value in style.items():
-                rv.append("  %s: %s;" % (attr, value))
+                rv.append(f"  {attr}: {value};")
             rv.append("}")
 
         # add css files that are appended to self.files
@@ -315,9 +315,8 @@ def render(self):
         rv.append("<body>")
 
         rv.append('<div class="title">')
-        rv.append("<h1>%s</h1>" % html.escape(self.title))
-        rv.append('<div class="subtitle">%s</div>' %
-                  html.escape(self.subtitle))
+        rv.append(f"<h1>{html.escape(self.title)}</h1>")
+        rv.append(f'<div class="subtitle">{html.escape(self.subtitle)}</div>')
         rv.append('</div>')
 
         rv += navbar_content

lobster/tools/codebeamer/codebeamer.py

@@ -492,7 +492,7 @@ def load_config(file_name: str) -> Config:
         FileNotFoundError: If the file does not exist.
         KeyError: If required fields are missing or unsupported keys are present.
     """
-    with open(file_name, "r", encoding='utf-8') as file:
+    with open(file_name, encoding='utf-8') as file:
         return parse_config_data(yaml.safe_load(file) or {})
 
 

lobster/tools/core/html_report/html_report.py

@@ -107,17 +107,14 @@ def create_policy_diagram(doc, report, dot):
             style = 'shape=hexagon'
         style += f', href="#sec-{name_hash(level.name)}"'
 
-        graph += '  n_%s [label="%s", %s];\n' % \
-            (name_hash(level.name),
-             level.name,
-             style)
+        graph += f'  n_{name_hash(level.name)} [label="{level.name}", {style}];\n'
 
     for level in report.config.values():
         source = name_hash(level.name)
         for target in map(name_hash, level.traces):
             # Not a mistake; we want to show the tracing down, whereas
             # in the config file we indicate how we trace up.
-            graph += '  n_%s -> n_%s;\n' % (target, source)
+            graph += f'  n_{target} -> n_{source};\n'
     graph += "}\n"
 
     with tempfile.TemporaryDirectory() as tmp_dir:
@@ -157,11 +154,11 @@ def create_item_coverage(doc, report):
         doc.add_line('<td><a href="#sec-%s">%s</a></td>' %
                      (name_hash(level.name),
                       html.escape(level.name)))
-        doc.add_line("<td>%.1f%%</td>" % data.coverage)
+        doc.add_line(f"<td>{data.coverage:.1f}%</td>")
         doc.add_line("<td>")
         doc.add_line('<progress value="%u" max="%u">' %
                      (data.ok, data.items))
-        doc.add_line("%.2f%%" % data.coverage)
+        doc.add_line(f"{data.coverage:.2f}%")
         doc.add_line('</progress>')
         doc.add_line("</td>")
         doc.add_line('<td align="right">%u</td>' % data.ok)
@@ -232,30 +229,30 @@ def write_item_tracing(doc, report, item):
         doc.add_line("<div>Traces to:")
         doc.add_line("<ul>")
         for ref in item.ref_down:
-            doc.add_line("<li>%s</li>" % xref_item(report.items[ref.key()]))
+            doc.add_line(f"<li>{xref_item(report.items[ref.key()])}</li>")
         doc.add_line("</ul>")
         doc.add_line("</div>")
     if item.ref_up:
         doc.add_line("<div>Derived from:")
         doc.add_line("<ul>")
         for ref in item.ref_up:
-            doc.add_line("<li>%s</li>" % xref_item(report.items[ref.key()]))
+            doc.add_line(f"<li>{xref_item(report.items[ref.key()])}</li>")
         doc.add_line("</ul>")
         doc.add_line("</div>")
 
     if item.tracing_status == Tracing_Status.JUSTIFIED:
         doc.add_line("<div>Justifications:")
         doc.add_line("<ul>")
         for msg in item.just_global + item.just_up + item.just_down:
-            doc.add_line("<li>%s</li>" % html.escape(msg))
+            doc.add_line(f"<li>{html.escape(msg)}</li>")
         doc.add_line("</ul>")
         doc.add_line("</div>")
 
     if item.messages:
         doc.add_line("<div>Issues:")
         doc.add_line("<ul>")
         for msg in item.messages:
-            doc.add_line("<li>%s</li>" % html.escape(msg))
+            doc.add_line(f"<li>{html.escape(msg)}</li>")
         doc.add_line("</ul>")
         doc.add_line("</div>")
 
@@ -422,9 +419,9 @@ def write_html(report, dot, high_contrast, render_md) -> str:
         doc.add_line(f'<div id="custom-data-banner">{content}</div>')
     menu = doc.navbar.add_dropdown("LOBSTER", "right")
     menu.add_link("Documentation",
-                  "%s/blob/main/README.md" % LOBSTER_GH)
+                  f"{LOBSTER_GH}/blob/main/README.md")
     menu.add_link("License",
-                  "%s/blob/main/LICENSE.md" % LOBSTER_GH)
+                  f"{LOBSTER_GH}/blob/main/LICENSE.md")
     menu.add_link("Source", LOBSTER_GH)
 
     ### Summary (Coverage & Policy)
@@ -548,7 +545,7 @@ def write_html(report, dot, high_contrast, render_md) -> str:
                     write_item_box_begin(doc, item, report)
                     if isinstance(item, Requirement) and item.status:
                         doc.add_line('<div class="attribute">')
-                        doc.add_line("Status: %s" % html.escape(item.status))
+                        doc.add_line(f"Status: {html.escape(item.status)}")
                         doc.add_line('</div>')
                     if (isinstance(item, (Requirement, Activity)) and item.text):
                         if render_md: