[mod] #146: documents/grammars: Use f-string

Change format() and "%" formats to f-string format

duniterpy/documents/block.py

@@ -214,9 +214,7 @@ class Block(Document):
         )
         if self.version < documents_versions:
             raise MalformedDocumentError(
-                "Block version is too low : {} < {}".format(
-                    self.version, documents_versions
-                )
+                f"Block version is too low: {self.version} < {documents_versions}"
             )
         self.number = number
         self.powmin = powmin
@@ -300,39 +298,39 @@ class Block(Document):
             arguments["parameters"] = arguments["parameters"].split(":")
         # identities: List[Identity]
         arguments["identities"] = [
-            Identity.from_inline(i + "\n", version=version, currency=currency)
+            Identity.from_inline(f"{i}\n", version=version, currency=currency)
             for i in arguments["identities"]
         ]
         # joiners: List[Membership]
         arguments["joiners"] = [
             Membership.from_inline(
-                i + "\n", version=version, currency=currency, membership_type="IN"
+                f"{i}\n", version=version, currency=currency, membership_type="IN"
             )
             for i in arguments["joiners"]
         ]
         # actives: List[Membership]
         arguments["actives"] = [
             Membership.from_inline(
-                i + "\n", version=version, currency=currency, membership_type="IN"
+                f"{i}\n", version=version, currency=currency, membership_type="IN"
             )
             for i in arguments["actives"]
         ]
         # leavers: List[Membership]
         arguments["leavers"] = [
             Membership.from_inline(
-                i + "\n", version=version, currency=currency, membership_type="OUT"
+                f"{i}\n", version=version, currency=currency, membership_type="OUT"
             )
             for i in arguments["leavers"]
         ]
         # revokations: List[Revocation]
         arguments["revokations"] = [
-            Revocation.from_inline(i + "\n", version=version, currency=currency)
+            Revocation.from_inline(f"{i}\n", version=version, currency=currency)
             for i in arguments["revokations"]
         ]
         # certifications: List[Certification]
         arguments["certifications"] = [
             Certification.from_inline(
-                arguments["inner_hash"], i + "\n", version=version, currency=currency
+                arguments["inner_hash"], f"{i}\n", version=version, currency=currency
             )
             for i in arguments["certifications"]
         ]
@@ -571,21 +569,13 @@ class Block(Document):
 
         :return:
         """
-        doc = """Version: {version}
-Type: Block
-Currency: {currency}
-Number: {number}
-PoWMin: {powmin}
-Time: {time}
-MedianTime: {mediantime}
-""".format(
-            version=self.version,
-            currency=self.currency,
-            number=self.number,
-            powmin=self.powmin,
-            time=self.time,
-            mediantime=self.mediantime,
-        )
+        doc = f"Version: {self.version}\n\
+Type: Block\n\
+Currency: {self.currency}\n\
+Number: {self.number}\n\
+PoWMin: {self.powmin}\n\
+Time: {self.time}\n\
+MedianTime: {self.mediantime}\n"
         if self.ud:
             doc += f"UniversalDividend: {self.ud}\n"
 
@@ -593,21 +583,16 @@ MedianTime: {mediantime}
 
         doc += f"Issuer: {self.issuer}\n"
 
-        doc += """IssuersFrame: {}
-IssuersFrameVar: {}
-DifferentIssuersCount: {}
-""".format(
-            self.issuers_frame, self.issuers_frame_var, self.different_issuers_count
-        )
+        doc += f"IssuersFrame: {self.issuers_frame}\n\
+IssuersFrameVar: {self.issuers_frame_var}\n\
+DifferentIssuersCount: {self.different_issuers_count}\n"
 
         if self.number == 0 and self.parameters is not None:
             str_params = ":".join([str(p) for p in self.parameters])
             doc += f"Parameters: {str_params}\n"
         else:
-            doc += "PreviousHash: {}\n\
-PreviousIssuer: {}\n".format(
-                self.prev_hash, self.prev_issuer
-            )
+            doc += f"PreviousHash: {self.prev_hash}\n\
+PreviousIssuer: {self.prev_issuer}\n"
 
         doc += f"MembersCount: {self.members_count}\n"
 
@@ -655,11 +640,8 @@ PreviousIssuer: {}\n".format(
 
         :return:
         """
-        doc_str = """InnerHash: {inner_hash}
-Nonce: {nonce}
-{signature}
-""".format(
-            inner_hash=self.inner_hash, nonce=self.nonce, signature=self.signature
+        doc_str = (
+            f"InnerHash: {self.inner_hash}\nNonce: {self.nonce}\n{self.signature}\n"
         )
         return hashlib.sha256(doc_str.encode("ascii")).hexdigest().upper()
 
@@ -681,10 +663,7 @@ Nonce: {nonce}
 
         :return:
         """
-        string_to_sign = "InnerHash: {inner_hash}\nNonce: {nonce}\n".format(
-            inner_hash=self.inner_hash,
-            nonce=self.nonce,
-        )
+        string_to_sign = f"InnerHash: {self.inner_hash}\nNonce: {self.nonce}\n"
         signature = base64.b64encode(key.signature(bytes(string_to_sign, "ascii")))
         self.signature = signature.decode("ascii")
 
@@ -724,9 +703,6 @@ Nonce: {nonce}
         if self.signature is None:
             raise Exception("Signature is None, can not verify signature")
 
-        content_to_verify = "InnerHash: {}\nNonce: {}\n".format(
-            self.inner_hash, self.nonce
-        )
-
+        content_to_verify = f"InnerHash: {self.inner_hash}\nNonce: {self.nonce}\n"
         verifying_key = VerifyingKey(pubkey)
         return verifying_key.check_signature(content_to_verify, self.signature)

duniterpy/documents/block_id.py

@@ -28,11 +28,7 @@ class BlockID:
     A simple block id
     """
 
-    re_block_id = re.compile(
-        "({block_number_regex})-({block_hash_regex})".format(
-            block_number_regex=BLOCK_NUMBER_REGEX, block_hash_regex=BLOCK_HASH_REGEX
-        )
-    )
+    re_block_id = re.compile(f"({BLOCK_NUMBER_REGEX})-({BLOCK_HASH_REGEX})")
     re_hash = re.compile(f"({BLOCK_HASH_REGEX})")
 
     def __init__(self, number: int, sha_hash: str) -> None:

duniterpy/documents/certification.py

@@ -41,12 +41,7 @@ class Certification(Document):
     """
 
     re_inline = re.compile(
-        "({certifier_regex}):({certified_regex}):({block_number_regex}):({signature_regex})\n".format(
-            certifier_regex=PUBKEY_REGEX,
-            certified_regex=PUBKEY_REGEX,
-            block_number_regex=BLOCK_NUMBER_REGEX,
-            signature_regex=SIGNATURE_REGEX,
-        )
+        f"({PUBKEY_REGEX}):({PUBKEY_REGEX}):({BLOCK_NUMBER_REGEX}):({SIGNATURE_REGEX})\n"
     )
     re_type = re.compile("Type: (Certification)")
     re_issuer = re.compile(f"Issuer: ({PUBKEY_REGEX})\n")
@@ -176,25 +171,15 @@ class Certification(Document):
                 "Can not return full certification document created from inline"
             )
 
-        return """Version: {version}
-Type: Certification
-Currency: {currency}
-Issuer: {issuer}
-IdtyIssuer: {certified_pubkey}
-IdtyUniqueID: {certified_uid}
-IdtyTimestamp: {certified_block_id}
-IdtySignature: {certified_signature}
-CertTimestamp: {block_id}
-""".format(
-            version=self.version,
-            currency=self.currency,
-            issuer=self.pubkey_from,
-            certified_pubkey=self.identity.pubkey,
-            certified_uid=self.identity.uid,
-            certified_block_id=self.identity.block_id,
-            certified_signature=self.identity.signature,
-            block_id=self.block_id,
-        )
+        return f"Version: {self.version}\n\
+Type: Certification\n\
+Currency: {self.currency}\n\
+Issuer: {self.pubkey_from}\n\
+IdtyIssuer: {self.identity.pubkey}\n\
+IdtyUniqueID: {self.identity.uid}\n\
+IdtyTimestamp: {self.identity.block_id}\n\
+IdtySignature: {self.identity.signature}\n\
+CertTimestamp: {self.block_id}\n"
 
     def sign(self, key: SigningKey) -> None:
         """
@@ -231,6 +216,4 @@ CertTimestamp: {block_id}
 
         :return:
         """
-        return "{}:{}:{}:{}".format(
-            self.pubkey_from, self.pubkey_to, self.block_id.number, self.signature
-        )
+        return f"{self.pubkey_from}:{self.pubkey_to}:{self.block_id.number}:{self.signature}"

duniterpy/documents/identity.py

@@ -40,11 +40,7 @@ class Identity(Document):
     """
 
     re_inline = re.compile(
-        "({pubkey_regex}):({signature_regex}):({block_id_regex}):([^\n]+)\n".format(
-            pubkey_regex=PUBKEY_REGEX,
-            signature_regex=SIGNATURE_REGEX,
-            block_id_regex=BLOCK_ID_REGEX,
-        )
+        f"({PUBKEY_REGEX}):({SIGNATURE_REGEX}):({BLOCK_ID_REGEX}):([^\n]+)\n"
     )
     re_type = re.compile("Type: (Identity)")
     re_issuer = re.compile(f"Issuer: ({PUBKEY_REGEX})\n")
@@ -172,19 +168,12 @@ class Identity(Document):
 
         :return:
         """
-        return """Version: {version}
-Type: Identity
-Currency: {currency}
-Issuer: {pubkey}
-UniqueID: {uid}
-Timestamp: {block_id}
-""".format(
-            version=self.version,
-            currency=self.currency,
-            pubkey=self.pubkey,
-            uid=self.uid,
-            block_id=self.block_id,
-        )
+        return f"Version: {self.version}\n\
+Type: Identity\n\
+Currency: {self.currency}\n\
+Issuer: {self.pubkey}\n\
+UniqueID: {self.uid}\n\
+Timestamp: {self.block_id}\n"
 
     def inline(self) -> str:
         """
@@ -192,12 +181,7 @@ Timestamp: {block_id}
 
         :return:
         """
-        return "{pubkey}:{signature}:{block_id}:{uid}".format(
-            pubkey=self.pubkey,
-            signature=self.signature,
-            block_id=self.block_id,
-            uid=self.uid,
-        )
+        return f"{self.pubkey}:{self.signature}:{self.block_id}:{self.uid}"
 
     @classmethod
     def from_certification_raw(

duniterpy/documents/membership.py

@@ -50,12 +50,7 @@ class Membership(Document):
 
     # PUBLIC_KEY:SIGNATURE:NUMBER:HASH:TIMESTAMP:USER_ID
     re_inline = re.compile(
-        "({pubkey_regex}):({signature_regex}):({ms_block_id_regex}):({identity_block_id_regex}):([^\n]+)\n".format(
-            pubkey_regex=PUBKEY_REGEX,
-            signature_regex=SIGNATURE_REGEX,
-            ms_block_id_regex=BLOCK_ID_REGEX,
-            identity_block_id_regex=BLOCK_ID_REGEX,
-        )
+        f"({PUBKEY_REGEX}):({SIGNATURE_REGEX}):({BLOCK_ID_REGEX}):({BLOCK_ID_REGEX}):([^\n]+)\n"
     )
     re_type = re.compile("Type: (Membership)")
     re_issuer = re.compile(f"Issuer: ({PUBKEY_REGEX})\n")
@@ -209,33 +204,18 @@ class Membership(Document):
 
         :return:
         """
-        return """Version: {}
-Type: Membership
-Currency: {}
-Issuer: {}
-Block: {}
-Membership: {}
-UserID: {}
-CertTS: {}
-""".format(
-            self.version,
-            self.currency,
-            self.issuer,
-            self.membership_block_id,
-            self.membership_type,
-            self.uid,
-            self.identity_block_id,
-        )
+        return f"Version: {self.version}\n\
+Type: Membership\n\
+Currency: {self.currency}\n\
+Issuer: {self.issuer}\n\
+Block: {self.membership_block_id}\n\
+Membership: {self.membership_type}\n\
+UserID: {self.uid}\n\
+CertTS: {self.identity_block_id}\n"
 
     def inline(self) -> str:
         """
         Return inline string format of the Membership instance
         :return:
         """
-        return "{}:{}:{}:{}:{}".format(
-            self.issuer,
-            self.signature,
-            self.membership_block_id,
-            self.identity_block_id,
-            self.uid,
-        )
+        return f"{self.issuer}:{self.signature}:{self.membership_block_id}:{self.identity_block_id}:{self.uid}"

duniterpy/documents/peer.py

@@ -141,15 +141,12 @@ class Peer(Document):
 
         :return:
         """
-        doc = """Version: {}
-Type: Peer
-Currency: {}
-PublicKey: {}
-Block: {}
-Endpoints:
-""".format(
-            self.version, self.currency, self.pubkey, self.block_id
-        )
+        doc = f"Version: {self.version}\n\
+Type: Peer\n\
+Currency: {self.currency}\n\
+PublicKey: {self.pubkey}\n\
+Block: {self.block_id}\n\
+Endpoints:\n"
 
         for _endpoint in self.endpoints:
             doc += f"{_endpoint.inline()}\n"

duniterpy/documents/revocation.py

@@ -38,12 +38,7 @@ class Revocation(Document):
     A document describing a self-revocation.
     """
 
-    re_inline = re.compile(
-        "({pubkey_regex}):({signature_regex})\n".format(
-            pubkey_regex=PUBKEY_REGEX, signature_regex=SIGNATURE_REGEX
-        )
-    )
-
+    re_inline = re.compile(f"({PUBKEY_REGEX}):({SIGNATURE_REGEX})\n")
     re_type = re.compile("Type: (Revocation)")
     re_issuer = re.compile(f"Issuer: ({PUBKEY_REGEX})\n")
     re_uniqueid = re.compile("IdtyUniqueID: ([^\n]+)\n")
@@ -172,21 +167,13 @@ class Revocation(Document):
                 "Can not return full revocation document created from inline"
             )
 
-        return """Version: {version}
-Type: Revocation
-Currency: {currency}
-Issuer: {pubkey}
-IdtyUniqueID: {uid}
-IdtyTimestamp: {block_id}
-IdtySignature: {signature}
-""".format(
-            version=self.version,
-            currency=self.currency,
-            pubkey=self.identity.pubkey,
-            uid=self.identity.uid,
-            block_id=self.identity.block_id,
-            signature=self.identity.signature,
-        )
+        return f"Version: {self.version}\n\
+Type: Revocation\n\
+Currency: {self.currency}\n\
+Issuer: {self.identity.pubkey}\n\
+IdtyUniqueID: {self.identity.uid}\n\
+IdtyTimestamp: {self.identity.block_id}\n\
+IdtySignature: {self.identity.signature}\n"
 
     def sign(self, key: SigningKey) -> None:
         """

duniterpy/documents/transaction.py

@@ -77,12 +77,8 @@ class InputSource:
     """
 
     re_inline = re.compile(
-        "([0-9]+):([0-9]):(?:(?:(D):({pubkey_regex}):({block_number_regex}))|(?:(T):({transaction_hash_regex}):\
-([0-9]+)))".format(
-            pubkey_regex=PUBKEY_REGEX,
-            block_number_regex=BLOCK_NUMBER_REGEX,
-            transaction_hash_regex=TRANSACTION_HASH_REGEX,
-        )
+        f"([0-9]+):([0-9]):(?:(?:(D):({PUBKEY_REGEX}):({BLOCK_NUMBER_REGEX}))|\
+(?:(T):({TRANSACTION_HASH_REGEX}):([0-9]+)))"
     )
 
     def __init__(
@@ -152,9 +148,7 @@ class InputSource:
 
         :return:
         """
-        return "{}:{}:{}:{}:{}".format(
-            self.amount, self.base, self.source, self.origin_id, self.index
-        )
+        return f"{self.amount}:{self.base}:{self.source}:{self.origin_id}:{self.index}"
 
 
 # required to type hint cls in classmethod
@@ -218,9 +212,7 @@ class OutputSource:
 
         :return:
         """
-        return "{}:{}:{}".format(
-            self.amount, self.base, pypeg2.compose(self.condition, output.Condition)
-        )
+        return f"{self.amount}:{self.base}:{pypeg2.compose(self.condition, output.Condition)}"
 
     def inline_condition(self) -> str:
         """
@@ -458,9 +450,8 @@ class Unlock:
 
         :return:
         """
-        return "{}:{}".format(
-            self.index, " ".join([str(parameter) for parameter in self.parameters])
-        )
+        params = " ".join([str(parameter) for parameter in self.parameters])
+        return f"{self.index}:{params}"
 
 
 # required to type hint cls in classmethod
@@ -837,12 +828,9 @@ Comment: {comment}
 
         :return:
         """
-        doc = """Version: {}
-Type: Transaction
-Currency: {}
-""".format(
-            self.version, self.currency
-        )
+        doc = f"Version: {self.version}\n\
+Type: Transaction\n\
+Currency: {self.currency}\n"
 
         doc += f"Blockstamp: {self.block_id}\n"
 

duniterpy/documents/ws2p/heads.py

@@ -36,9 +36,7 @@ class API:
     public = attr.ib(type=str)
 
     re_inline = re.compile(
-        "WS2P({ws2p_private})?({ws2p_public})?".format(
-            ws2p_private=WS2P_PRIVATE_PREFIX_REGEX, ws2p_public=WS2P_PUBLIC_PREFIX_REGEX
-        )
+        f"WS2P({WS2P_PRIVATE_PREFIX_REGEX})?({WS2P_PUBLIC_PREFIX_REGEX})?"
     )
 
     @classmethod
@@ -51,7 +49,7 @@ class API:
         return cls(private, public)
 
     def __str__(self) -> str:
-        return "WS2P" + self.private + self.public
+        return f"WS2P{self.private}{self.public}"
 
 
 @attr.s()
@@ -85,13 +83,8 @@ class HeadV0(Head):
     block_id = attr.ib(type=BlockID)
 
     re_inline = re.compile(
-        "^(WS2P(?:{ws2p_private})?(?:{ws2p_public})?):({head}):({pubkey}):({block_id})(?::)?(.*)".format(
-            ws2p_private=WS2P_PRIVATE_PREFIX_REGEX,
-            ws2p_public=WS2P_PUBLIC_PREFIX_REGEX,
-            head=WS2P_HEAD_REGEX,
-            pubkey=PUBKEY_REGEX,
-            block_id=BLOCK_ID_REGEX,
-        )
+        f"^(WS2P(?:{WS2P_PRIVATE_PREFIX_REGEX})?(?:{WS2P_PUBLIC_PREFIX_REGEX})?):\
+({WS2P_HEAD_REGEX}):({PUBKEY_REGEX}):({BLOCK_ID_REGEX})(?::)?(.*)"
     )
 
     re_signature = re.compile(SIGNATURE_REGEX)
@@ -124,7 +117,7 @@ class HeadV0(Head):
                 ),
             )
         )
-        return "{}:{}".format(str(self.api), ":".join(values))
+        return f'{str(self.api)}:{":".join(values)}'
 
     def check_signature(self, pubkey: str) -> bool:
         """

duniterpy/documents/ws2p/messages.py

@@ -61,12 +61,7 @@ class HandshakeMessage(Document):
 
         :return:
         """
-        return "WS2P:{auth}:{currency}:{pub}:{challenge}".format(
-            auth=self.auth,
-            currency=self.currency,
-            pub=self.pubkey,
-            challenge=self.challenge,
-        )
+        return f"WS2P:{self.auth}:{self.currency}:{self.pubkey}:{self.challenge}"
 
     def get_signed_json(self, signing_key: SigningKey) -> str:
         """

duniterpy/grammars/output.py

@@ -390,21 +390,13 @@ class Condition:
         :param grammar: Grammar
         :param attr_of: Attribute of...
         """
-        if type(self.left) is Condition:
-            left = "({})".format(
-                parser.compose(self.left, grammar=grammar, attr_of=attr_of)
-            )
-        else:
         left = parser.compose(self.left, grammar=grammar, attr_of=attr_of)
-
+        if type(self.left) is Condition:
+            left = f"({left})"
         if getattr(self, "op", None):
-
-            if type(self.right) is Condition:
-                right = "({})".format(
-                    parser.compose(self.right, grammar=grammar, attr_of=attr_of)
-                )
-            else:
             right = parser.compose(self.right, grammar=grammar, attr_of=attr_of)
+            if type(self.right) is Condition:
+                right = f"({right})"
             op = parser.compose(self.op, grammar=grammar, attr_of=attr_of)
             result = f"{left} {op} {right}"
         else: