From bced51cef7b7ee82c6108e75c670b0877236de11 Mon Sep 17 00:00:00 2001 From: Moul <moul@moul.re> Date: Thu, 12 Aug 2021 20:23:30 +0200 Subject: [PATCH] [mod] #146: documents/grammars: Use f-string Change format() and "%" formats to f-string format --- duniterpy/documents/block.py | 70 +++++++++------------------- duniterpy/documents/block_id.py | 6 +-- duniterpy/documents/certification.py | 39 +++++----------- duniterpy/documents/document.py | 2 +- duniterpy/documents/identity.py | 32 ++++--------- duniterpy/documents/membership.py | 40 ++++------------ duniterpy/documents/peer.py | 15 +++--- duniterpy/documents/revocation.py | 29 ++++-------- duniterpy/documents/transaction.py | 32 ++++--------- duniterpy/documents/ws2p/heads.py | 17 ++----- duniterpy/documents/ws2p/messages.py | 7 +-- duniterpy/grammars/output.py | 16 ++----- 12 files changed, 88 insertions(+), 217 deletions(-) diff --git a/duniterpy/documents/block.py b/duniterpy/documents/block.py index 7a298daf..18db3284 100644 --- a/duniterpy/documents/block.py +++ b/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) diff --git a/duniterpy/documents/block_id.py b/duniterpy/documents/block_id.py index 2791f56c..0cc28060 100644 --- a/duniterpy/documents/block_id.py +++ b/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: diff --git a/duniterpy/documents/certification.py b/duniterpy/documents/certification.py index dfd5225d..9b3b857b 100644 --- a/duniterpy/documents/certification.py +++ b/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}" diff --git a/duniterpy/documents/document.py b/duniterpy/documents/document.py index d81fcf15..ea66d44e 100644 --- a/duniterpy/documents/document.py +++ b/duniterpy/documents/document.py @@ -89,7 +89,7 @@ class Document: :param key: Libnacl key instance """ signature = base64.b64encode(key.signature(bytes(self.raw(), "ascii"))) - logging.debug("Signature : \n%s", signature.decode("ascii")) + logging.debug("Signature:\n%s", signature.decode("ascii")) self.signature = signature.decode("ascii") def raw(self) -> str: diff --git a/duniterpy/documents/identity.py b/duniterpy/documents/identity.py index b473e936..a526d9bd 100644 --- a/duniterpy/documents/identity.py +++ b/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( diff --git a/duniterpy/documents/membership.py b/duniterpy/documents/membership.py index f92dad8a..592858af 100644 --- a/duniterpy/documents/membership.py +++ b/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}" diff --git a/duniterpy/documents/peer.py b/duniterpy/documents/peer.py index 8431f393..e1d00a1c 100644 --- a/duniterpy/documents/peer.py +++ b/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" diff --git a/duniterpy/documents/revocation.py b/duniterpy/documents/revocation.py index 70d2bdd4..aaab2297 100644 --- a/duniterpy/documents/revocation.py +++ b/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: """ diff --git a/duniterpy/documents/transaction.py b/duniterpy/documents/transaction.py index 9220f1da..e61b9e34 100644 --- a/duniterpy/documents/transaction.py +++ b/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" @@ -944,7 +932,7 @@ Currency: {} for key in keys: signature = base64.b64encode(key.signature(bytes(self.raw(), "ascii"))) - logging.debug("Signature : \n%s", signature.decode("ascii")) + logging.debug("Signature:\n%s", signature.decode("ascii")) self.signatures.append(signature.decode("ascii")) def check_signature(self, pubkey: str) -> bool: diff --git a/duniterpy/documents/ws2p/heads.py b/duniterpy/documents/ws2p/heads.py index 15e83141..2bca5429 100644 --- a/duniterpy/documents/ws2p/heads.py +++ b/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: """ diff --git a/duniterpy/documents/ws2p/messages.py b/duniterpy/documents/ws2p/messages.py index 7312c80f..665e90e7 100644 --- a/duniterpy/documents/ws2p/messages.py +++ b/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: """ diff --git a/duniterpy/grammars/output.py b/duniterpy/grammars/output.py index 11bbfa13..e82e9685 100644 --- a/duniterpy/grammars/output.py +++ b/duniterpy/grammars/output.py @@ -390,21 +390,13 @@ class Condition: :param grammar: Grammar :param attr_of: Attribute of... """ + left = parser.compose(self.left, grammar=grammar, attr_of=attr_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) - + left = f"({left})" if getattr(self, "op", None): - + right = parser.compose(self.right, grammar=grammar, attr_of=attr_of) 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) + right = f"({right})" op = parser.compose(self.op, grammar=grammar, attr_of=attr_of) result = f"{left} {op} {right}" else: -- GitLab