lint: Don't use "else" when it's not needed

Reflow some related error message formatting as well: no functional changes

Author: jku

securesystemslib/ecdsa_keys.py

@@ -327,15 +327,11 @@ def verify_signature(public_key, scheme, signature, data):
             f"Failed to load PEM key {public_key}"
         ) from e
 
-    if not isinstance(  # pylint: disable=no-else-raise
-        ecdsa_key, ec.EllipticCurvePublicKey
-    ):
+    if not isinstance(ecdsa_key, ec.EllipticCurvePublicKey):
         raise exceptions.FormatError(
             "Invalid ECDSA public" " key: " + repr(public_key)
         )
-
-    else:
-        logger.debug("Loaded a valid ECDSA public key.")
+    logger.debug("Loaded a valid ECDSA public key.")
 
     # verify() raises an 'InvalidSignature' exception if 'signature'
     # is invalid.

securesystemslib/gpg/common.py

@@ -210,7 +210,7 @@ def parse_pubkey_bundle(data):
             # - there must be least one User ID packet, or
             # - order and type of signatures, or
             # - disallow duplicate packets
-            if (  # pylint: disable=no-else-raise
+            if (
                 packet_type != PACKET_TYPE_PRIMARY_KEY
                 and not key_bundle[PACKET_TYPE_PRIMARY_KEY]["key"]
             ):
@@ -219,7 +219,7 @@ def parse_pubkey_bundle(data):
                     "got '{}'.".format(PACKET_TYPE_PRIMARY_KEY, packet_type)
                 )
 
-            elif (
+            if (
                 packet_type == PACKET_TYPE_PRIMARY_KEY
                 and key_bundle[PACKET_TYPE_PRIMARY_KEY]["key"]
             ):
@@ -228,7 +228,7 @@ def parse_pubkey_bundle(data):
             # Fully parse master key to fail early, e.g. if key is malformed
             # or not supported, but also retain original packet for subkey binding
             # signature verification
-            elif packet_type == PACKET_TYPE_PRIMARY_KEY:
+            if packet_type == PACKET_TYPE_PRIMARY_KEY:
                 key_bundle[PACKET_TYPE_PRIMARY_KEY] = {
                     "key": parse_pubkey_payload(bytearray(payload)),
                     "packet": packet,

securesystemslib/keys.py

@@ -454,24 +454,21 @@ def format_keyval_to_metadata(keytype, scheme, key_value, private=False):
         # key in the returned dictionary, ensure the private key is actually
         # present in 'key_val' (a private key is optional for 'KEYVAL_SCHEMA'
         # dicts).
-        if "private" not in key_value:  # pylint: disable=no-else-raise
+        if "private" not in key_value:
             raise exceptions.FormatError(
-                "The required private key"
-                " is missing from: " + repr(key_value)
+                "The required private key is missing from: " + repr(key_value)
             )
 
-        else:
-            return {"keytype": keytype, "scheme": scheme, "keyval": key_value}
+        return {"keytype": keytype, "scheme": scheme, "keyval": key_value}
 
-    else:
-        public_key_value = {"public": key_value["public"]}
+    public_key_value = {"public": key_value["public"]}
 
-        return {
-            "keytype": keytype,
-            "scheme": scheme,
-            "keyid_hash_algorithms": settings.HASH_ALGORITHMS,
-            "keyval": public_key_value,
-        }
+    return {
+        "keytype": keytype,
+        "scheme": scheme,
+        "keyid_hash_algorithms": settings.HASH_ALGORITHMS,
+        "keyval": public_key_value,
+    }
 
 
 def format_metadata_to_key(
@@ -830,15 +827,14 @@ def verify_signature(
 
     # Verify that the KEYID in 'key_dict' matches the KEYID listed in the
     # 'signature'.
-    if key_dict["keyid"] != signature["keyid"]:  # pylint: disable=no-else-raise
+    if key_dict["keyid"] != signature["keyid"]:
         raise exceptions.CryptoError(
             "The KEYID ("
             " " + repr(key_dict["keyid"]) + " ) in the given key does not match"
             " the KEYID ( " + repr(signature["keyid"]) + " ) in the signature."
         )
 
-    else:
-        logger.debug("The KEYIDs of key_dict and the signature match.")
+    logger.debug("The KEYIDs of key_dict and the signature match.")
 
     # Using the public key belonging to 'key_dict'
     # (i.e., rsakey_dict['keyval']['public']), verify whether 'signature'
@@ -1235,42 +1231,40 @@ def extract_pem(pem, private_pem=False):
 
     except ValueError:
         # Be careful not to print private key material in exception message.
-        if not private_pem:  # pylint: disable=no-else-raise
-            raise exceptions.FormatError(  # pylint: disable=raise-missing-from
-                "Required PEM"
-                " header " + repr(pem_header) + "\n not found in PEM"
-                " string: " + repr(pem)
-            )
-
-        else:
+        if not private_pem:
             raise exceptions.FormatError(  # pylint: disable=raise-missing-from
-                "Required PEM"
-                " header "
+                "Required PEM header "
                 + repr(pem_header)
-                + "\n not found in private PEM string."
+                + "\n not found in PEM string: "
+                + repr(pem)
             )
 
+        raise exceptions.FormatError(  # pylint: disable=raise-missing-from
+            "Required PEM header "
+            + repr(pem_header)
+            + "\n not found in private PEM string."
+        )
+
     try:
         # Search for 'pem_footer' after the PEM header.
         footer_start = pem.index(pem_footer, header_start + len(pem_header))
 
     except ValueError:
         # Be careful not to print private key material in exception message.
-        if not private_pem:  # pylint: disable=no-else-raise
+        if not private_pem:
             raise exceptions.FormatError(  # pylint: disable=raise-missing-from
-                "Required PEM"
-                " footer " + repr(pem_footer) + "\n not found in PEM"
-                " string " + repr(pem)
-            )
-
-        else:
-            raise exceptions.FormatError(  # pylint: disable=raise-missing-from
-                "Required PEM"
-                " footer "
+                "Required PEM footer "
                 + repr(pem_footer)
-                + "\n not found in private PEM string."
+                + "\n not found in PEM string "
+                + repr(pem)
             )
 
+        raise exceptions.FormatError(  # pylint: disable=raise-missing-from
+            "Required PEM footer "
+            + repr(pem_footer)
+            + "\n not found in private PEM string."
+        )
+
     # Extract only the public portion of 'pem'.  Leading or trailing whitespace
     # is excluded.
     pem = pem[header_start : footer_start + len(pem_footer)]

securesystemslib/schema.py

@@ -597,16 +597,14 @@ def __init__(self, lo=-2147483648, hi=2147483647):
         self._hi = hi
 
     def check_match(self, object):  # pylint: disable=redefined-builtin
-        if isinstance(  # pylint: disable=no-else-raise
-            object, bool
-        ) or not isinstance(object, int):
+        if isinstance(object, bool) or not isinstance(object, int):
             # We need to check for bool as a special case, since bool
             # is for historical reasons a subtype of int.
             raise exceptions.FormatError(
                 "Got " + repr(object) + " instead of an integer."
             )
 
-        elif not (self._lo <= object <= self._hi):
+        if not (self._lo <= object <= self._hi):
             int_range = "[" + repr(self._lo) + ", " + repr(self._hi) + "]."
             raise exceptions.FormatError(
                 repr(object) + " not in range " + int_range
@@ -886,22 +884,20 @@ def __init__(
         self._struct_name = struct_name
 
     def check_match(self, object):  # pylint: disable=redefined-builtin
-        if not isinstance(  # pylint: disable=no-else-raise
-            object, (list, tuple)
-        ):
+        if not isinstance(object, (list, tuple)):
             raise exceptions.FormatError(
                 "Expected "
                 + repr(self._struct_name)
                 + "; but got "
                 + repr(object)
             )
 
-        elif len(object) < self._min:
+        if len(object) < self._min:
             raise exceptions.FormatError(
                 "Too few fields in " + self._struct_name
             )
 
-        elif len(object) > len(self._sub_schemas) and not self._allow_more:
+        if len(object) > len(self._sub_schemas) and not self._allow_more:
             raise exceptions.FormatError(
                 "Too many fields in " + self._struct_name
             )