diff --git a/duniterpy/api/bma/blockchain.py b/duniterpy/api/bma/blockchain.py index 2357755e82e485896480a08930c7500d34908a13..047a254d43237cb7a6ad6c3a0370061fa1131443 100644 --- a/duniterpy/api/bma/blockchain.py +++ b/duniterpy/api/bma/blockchain.py @@ -226,7 +226,7 @@ def parameters(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/parameters", schema=PARAMETERS_SCHEMA) + return client.get(f"{MODULE}/parameters", schema=PARAMETERS_SCHEMA) def memberships(client: Client, search: str) -> dict: @@ -237,7 +237,7 @@ def memberships(client: Client, search: str) -> dict: :param search: UID/Public key :return: """ - return client.get(MODULE + "/memberships/%s" % search, schema=MEMBERSHIPS_SCHEMA) + return client.get(f"{MODULE}/memberships/{search}", schema=MEMBERSHIPS_SCHEMA) def membership(client: Client, membership_signed_raw: str) -> HTTPResponse: @@ -249,7 +249,7 @@ def membership(client: Client, membership_signed_raw: str) -> HTTPResponse: :return: """ return client.post( - MODULE + "/membership", + f"{MODULE}/membership", {"membership": membership_signed_raw}, rtype=RESPONSE_HTTP, ) @@ -262,7 +262,7 @@ def current(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/current", schema=BLOCK_SCHEMA) + return client.get(f"{MODULE}/current", schema=BLOCK_SCHEMA) def block( @@ -280,12 +280,12 @@ def block( # POST block if block_raw is not None and signature is not None: return client.post( - MODULE + "/block", + f"{MODULE}/block", {"block": block_raw, "signature": signature}, rtype=RESPONSE_HTTP, ) # GET block - return client.get(MODULE + "/block/%d" % number, schema=BLOCK_SCHEMA) + return client.get(f"{MODULE}/block/{number}", schema=BLOCK_SCHEMA) def blocks(client: Client, count: int, start: int) -> list: @@ -300,7 +300,7 @@ def blocks(client: Client, count: int, start: int) -> list: assert type(count) is int assert type(start) is int - return client.get(MODULE + "/blocks/%d/%d" % (count, start), schema=BLOCKS_SCHEMA) + return client.get(f"{MODULE}/blocks/{count}/{start}", schema=BLOCKS_SCHEMA) def hardship(client: Client, pubkey: str) -> dict: @@ -311,7 +311,7 @@ def hardship(client: Client, pubkey: str) -> dict: :param pubkey: Public key of the member :return: """ - return client.get(MODULE + "/hardship/%s" % pubkey, schema=HARDSHIP_SCHEMA) + return client.get(f"{MODULE}/hardship/{pubkey}", schema=HARDSHIP_SCHEMA) def difficulties(client: Client) -> dict: @@ -321,7 +321,7 @@ def difficulties(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/difficulties", schema=DIFFICULTIES_SCHEMA) + return client.get(f"{MODULE}/difficulties", schema=DIFFICULTIES_SCHEMA) def branches(client: Client) -> list: @@ -331,7 +331,7 @@ def branches(client: Client) -> list: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/branches", schema=BRANCHES_SCHEMA) + return client.get(f"{MODULE}/branches", schema=BRANCHES_SCHEMA) def newcomers(client: Client) -> dict: @@ -341,7 +341,7 @@ def newcomers(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/with/newcomers", schema=BLOCK_NUMBERS_SCHEMA) + return client.get(f"{MODULE}/with/newcomers", schema=BLOCK_NUMBERS_SCHEMA) def certifications(client: Client) -> dict: @@ -351,7 +351,7 @@ def certifications(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/with/certs", schema=BLOCK_NUMBERS_SCHEMA) + return client.get(f"{MODULE}/with/certs", schema=BLOCK_NUMBERS_SCHEMA) def joiners(client: Client) -> dict: @@ -361,7 +361,7 @@ def joiners(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/with/joiners", schema=BLOCK_NUMBERS_SCHEMA) + return client.get(f"{MODULE}/with/joiners", schema=BLOCK_NUMBERS_SCHEMA) def actives(client: Client) -> dict: @@ -371,7 +371,7 @@ def actives(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/with/actives", schema=BLOCK_NUMBERS_SCHEMA) + return client.get(f"{MODULE}/with/actives", schema=BLOCK_NUMBERS_SCHEMA) def leavers(client: Client) -> dict: @@ -381,7 +381,7 @@ def leavers(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/with/leavers", schema=BLOCK_NUMBERS_SCHEMA) + return client.get(f"{MODULE}/with/leavers", schema=BLOCK_NUMBERS_SCHEMA) def revoked(client: Client) -> dict: @@ -391,7 +391,7 @@ def revoked(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/with/revoked", schema=BLOCK_NUMBERS_SCHEMA) + return client.get(f"{MODULE}/with/revoked", schema=BLOCK_NUMBERS_SCHEMA) def excluded(client: Client) -> dict: @@ -401,7 +401,7 @@ def excluded(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/with/excluded", schema=BLOCK_NUMBERS_SCHEMA) + return client.get(f"{MODULE}/with/excluded", schema=BLOCK_NUMBERS_SCHEMA) def ud(client: Client) -> dict: @@ -411,7 +411,7 @@ def ud(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/with/ud", schema=BLOCK_NUMBERS_SCHEMA) + return client.get(f"{MODULE}/with/ud", schema=BLOCK_NUMBERS_SCHEMA) def tx(client: Client) -> dict: @@ -421,4 +421,4 @@ def tx(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/with/tx", schema=BLOCK_NUMBERS_SCHEMA) + return client.get(f"{MODULE}/with/tx", schema=BLOCK_NUMBERS_SCHEMA) diff --git a/duniterpy/api/bma/network.py b/duniterpy/api/bma/network.py index 581264bb230a7bf6b646c297ad31d3853667b8fb..c6476efafb4d9409d199bdd55718c9e9740c4d0b 100644 --- a/duniterpy/api/bma/network.py +++ b/duniterpy/api/bma/network.py @@ -125,7 +125,7 @@ def peers(client: Client) -> dict: :return: """ - return client.get(MODULE + "/peers", schema=PEERS_SCHEMA) + return client.get(f"{MODULE}/peers", schema=PEERS_SCHEMA) def peering(client: Client) -> dict: @@ -135,7 +135,7 @@ def peering(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/peering", schema=PEERING_SCHEMA) + return client.get(f"{MODULE}/peering", schema=PEERING_SCHEMA) def peering_peers(client: Client, leaves: bool = False, leaf: str = "") -> dict: @@ -149,11 +149,11 @@ def peering_peers(client: Client, leaves: bool = False, leaf: str = "") -> dict: """ if leaves is True: response = client.get( - MODULE + "/peering/peers", {"leaves": "true"}, schema=PEERING_PEERS_SCHEMA + f"{MODULE}/peering/peers", {"leaves": "true"}, schema=PEERING_PEERS_SCHEMA ) else: response = client.get( - MODULE + "/peering/peers", {"leaf": leaf}, schema=PEERING_PEERS_SCHEMA + f"{MODULE}/peering/peers", {"leaf": leaf}, schema=PEERING_PEERS_SCHEMA ) return response @@ -167,7 +167,7 @@ def peer(client: Client, peer_signed_raw: str) -> HTTPResponse: :return: """ return client.post( - MODULE + "/peering/peers", {"peer": peer_signed_raw}, rtype=RESPONSE_HTTP + f"{MODULE}/peering/peers", {"peer": peer_signed_raw}, rtype=RESPONSE_HTTP ) @@ -178,4 +178,4 @@ def ws2p_heads(client: Client) -> dict: :param client: Client to connect to the api :rtype: dict """ - return client.get(MODULE + "/ws2p/heads", schema=WS2P_HEADS_SCHEMA) + return client.get(f"{MODULE}/ws2p/heads", schema=WS2P_HEADS_SCHEMA) diff --git a/duniterpy/api/bma/node.py b/duniterpy/api/bma/node.py index 573c3669697e4ba238b66e776a6c18527920ad78..0f0cecbf9fc0ddc2384837a9f0809ab7fa5249bd 100644 --- a/duniterpy/api/bma/node.py +++ b/duniterpy/api/bma/node.py @@ -61,7 +61,7 @@ def summary(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/summary", schema=SUMMARY_SCHEMA) + return client.get(f"{MODULE}/summary", schema=SUMMARY_SCHEMA) def sandboxes(client: Client) -> dict: @@ -71,4 +71,4 @@ def sandboxes(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/sandboxes", schema=SANDBOXES_SCHEMA) + return client.get(f"{MODULE}/sandboxes", schema=SANDBOXES_SCHEMA) diff --git a/duniterpy/api/bma/tx.py b/duniterpy/api/bma/tx.py index 17fe68caa28ff8c5ab29d002134f90ae4133222e..83e539d6d9a7ee04ae3933591350162e4bb37c28 100644 --- a/duniterpy/api/bma/tx.py +++ b/duniterpy/api/bma/tx.py @@ -130,7 +130,7 @@ def history(client: Client, pubkey: str) -> dict: :param pubkey: Public key :return: """ - return client.get(MODULE + "/history/%s" % pubkey, schema=HISTORY_SCHEMA) + return client.get(f"{MODULE}/history/{pubkey}", schema=HISTORY_SCHEMA) def process(client: Client, transaction_signed_raw: str) -> HTTPResponse: @@ -142,7 +142,7 @@ def process(client: Client, transaction_signed_raw: str) -> HTTPResponse: :return: """ return client.post( - MODULE + "/process", + f"{MODULE}/process", {"transaction": transaction_signed_raw}, rtype=RESPONSE_HTTP, ) @@ -156,7 +156,7 @@ def sources(client: Client, pubkey: str) -> dict: :param pubkey: Public key :return: """ - return client.get(MODULE + "/sources/%s" % pubkey, schema=SOURCES_SCHEMA) + return client.get(f"{MODULE}/sources/{pubkey}", schema=SOURCES_SCHEMA) def pending(client: Client, pubkey: str) -> dict: @@ -167,7 +167,7 @@ def pending(client: Client, pubkey: str) -> dict: :param pubkey: Public key :return: """ - return client.get(MODULE + "/history/%s/pending" % pubkey, schema=HISTORY_SCHEMA) + return client.get(f"{MODULE}/history/{pubkey}/pending", schema=HISTORY_SCHEMA) def blocks(client: Client, pubkey: str, start: int, end: int) -> dict: @@ -181,7 +181,7 @@ def blocks(client: Client, pubkey: str, start: int, end: int) -> dict: :return: """ return client.get( - MODULE + f"/history/{pubkey}/blocks/{start}/{end}", + f"{MODULE}/history/{pubkey}/blocks/{start}/{end}", schema=HISTORY_SCHEMA, ) @@ -197,5 +197,5 @@ def times(client: Client, pubkey: str, start: int, end: int) -> dict: :return: """ return client.get( - MODULE + f"/history/{pubkey}/times/{start}/{end}", schema=HISTORY_SCHEMA + f"{MODULE}/history/{pubkey}/times/{start}/{end}", schema=HISTORY_SCHEMA ) diff --git a/duniterpy/api/bma/ud.py b/duniterpy/api/bma/ud.py index b4cb2e7053f4a9b86a304a39b574295c2ce270cc..1980218aba26579c51dafa3c4afa201acae2357d 100644 --- a/duniterpy/api/bma/ud.py +++ b/duniterpy/api/bma/ud.py @@ -57,4 +57,4 @@ def history(client: Client, pubkey: str) -> dict: :param pubkey: Public key of the member :return: """ - return client.get(MODULE + "/history/%s" % pubkey, schema=UD_SCHEMA) + return client.get(f"{MODULE}/history/{pubkey}", schema=UD_SCHEMA) diff --git a/duniterpy/api/bma/wot.py b/duniterpy/api/bma/wot.py index 56c8d2802aff0dc0907b5afdf075937886163982..f43334fbb7322907cf5b7137a82d31179aa92a68 100644 --- a/duniterpy/api/bma/wot.py +++ b/duniterpy/api/bma/wot.py @@ -236,7 +236,7 @@ def add(client: Client, identity_signed_raw: str) -> HTTPResponse: :return: """ return client.post( - MODULE + "/add", {"identity": identity_signed_raw}, rtype=RESPONSE_HTTP + f"{MODULE}/add", {"identity": identity_signed_raw}, rtype=RESPONSE_HTTP ) @@ -249,7 +249,7 @@ def certify(client: Client, certification_signed_raw: str) -> HTTPResponse: :return: """ return client.post( - MODULE + "/certify", {"cert": certification_signed_raw}, rtype=RESPONSE_HTTP + f"{MODULE}/certify", {"cert": certification_signed_raw}, rtype=RESPONSE_HTTP ) @@ -262,7 +262,7 @@ def revoke(client: Client, revocation_signed_raw: str) -> HTTPResponse: :return: """ return client.post( - MODULE + "/revoke", + f"{MODULE}/revoke", {"revocation": revocation_signed_raw}, rtype=RESPONSE_HTTP, ) @@ -276,7 +276,7 @@ def lookup(client: Client, search: str) -> dict: :param search: UID or public key :return: """ - return client.get(MODULE + "/lookup/%s" % search, schema=LOOKUP_SCHEMA) + return client.get(f"{MODULE}/lookup/{search}", schema=LOOKUP_SCHEMA) def certifiers_of(client: Client, search: str) -> dict: @@ -287,9 +287,7 @@ def certifiers_of(client: Client, search: str) -> dict: :param search: UID or public key :return: """ - return client.get( - MODULE + "/certifiers-of/%s" % search, schema=CERTIFICATIONS_SCHEMA - ) + return client.get(f"{MODULE}/certifiers-of/{search}", schema=CERTIFICATIONS_SCHEMA) def certified_by(client: Client, search: str) -> dict: @@ -300,9 +298,7 @@ def certified_by(client: Client, search: str) -> dict: :param search: UID or public key :return: """ - return client.get( - MODULE + "/certified-by/%s" % search, schema=CERTIFICATIONS_SCHEMA - ) + return client.get(f"{MODULE}/certified-by/{search}", schema=CERTIFICATIONS_SCHEMA) def members(client: Client) -> dict: @@ -312,7 +308,7 @@ def members(client: Client) -> dict: :param client: Client to connect to the api :return: """ - return client.get(MODULE + "/members", schema=MEMBERS_SCHEMA) + return client.get(f"{MODULE}/members", schema=MEMBERS_SCHEMA) def requirements(client: Client, search: str) -> dict: @@ -323,7 +319,7 @@ def requirements(client: Client, search: str) -> dict: :param search: UID or public key :return: """ - return client.get(MODULE + "/requirements/%s" % search, schema=REQUIREMENTS_SCHEMA) + return client.get(f"{MODULE}/requirements/{search}", schema=REQUIREMENTS_SCHEMA) def requirements_of_pending(client: Client, minsig: int) -> dict: @@ -335,7 +331,7 @@ def requirements_of_pending(client: Client, minsig: int) -> dict: :return: """ return client.get( - MODULE + "/requirements-of-pending/%d" % minsig, schema=REQUIREMENTS_SCHEMA + f"{MODULE}/requirements-of-pending/{minsig}", schema=REQUIREMENTS_SCHEMA ) @@ -347,4 +343,4 @@ def identity_of(client: Client, search: str) -> dict: :param search: UID or public key :return: """ - return client.get(MODULE + "/identity-of/%s" % search, schema=IDENTITY_OF_SCHEMA) + return client.get(f"{MODULE}/identity-of/{search}", schema=IDENTITY_OF_SCHEMA) diff --git a/duniterpy/api/bma/ws.py b/duniterpy/api/bma/ws.py index adbfcc911d5c4754e934a5eb157542dff3c1f21c..54af6dec55b6baa330cc7cf7b7a1ad679857470b 100644 --- a/duniterpy/api/bma/ws.py +++ b/duniterpy/api/bma/ws.py @@ -34,7 +34,7 @@ def block(client: Client) -> WSConnection: :param client: Client to connect to the api :return: """ - return client.connect_ws(MODULE + "/block") + return client.connect_ws(f"{MODULE}/block") def peer(client: Client) -> WSConnection: @@ -44,4 +44,4 @@ def peer(client: Client) -> WSConnection: :param client: Client to connect to the api :return: """ - return client.connect_ws(MODULE + "/peer") + return client.connect_ws(f"{MODULE}/peer") diff --git a/duniterpy/api/client.py b/duniterpy/api/client.py index f0264c020101c0b4f80825543972b7d4459c14cd..e0fac12a6d492b14e4e9c34898c3b57624e1c81c 100644 --- a/duniterpy/api/client.py +++ b/duniterpy/api/client.py @@ -189,16 +189,9 @@ class API: address, port = self.connection_handler.address, self.connection_handler.port if self.connection_handler.path: - url = "{scheme}://{address}:{port}/{api_path}".format( - scheme=scheme, - address=address, - port=port, - api_path=self.connection_handler.path, - ) + url = f"{scheme}://{address}:{port}/{self.connection_handler.path}" else: - url = "{scheme}://{address}:{port}".format( - scheme=scheme, address=address, port=port - ) + url = f"{scheme}://{address}:{port}" if len(path.strip()) > 0: return f"{url}/{path}" @@ -228,7 +221,7 @@ class API: :return: """ logging.debug( - "Request : %s", self.reverse_url(self.connection_handler.http_scheme, path) + "Request: %s", self.reverse_url(self.connection_handler.http_scheme, path) ) url = self.reverse_url(self.connection_handler.http_scheme, path) duniter_request = request.Request(url, method=method) @@ -266,12 +259,10 @@ class API: raise DuniterError(error_data) except (TypeError, jsonschema.ValidationError) as exception: raise ValueError( - "status code != 200 => %d (%s)" % (response.status, content) + f"status code != 200 => {response.status} ({content})" ) from exception - raise ValueError( - "status code != 200 => %d (%s)" % (response.status, content) - ) + raise ValueError(f"status code != 200 => {response.status} ({content})") # get response content return_response = copy.copy(response) diff --git a/duniterpy/api/endpoint.py b/duniterpy/api/endpoint.py index d82977ba36f7e59f80fe39e63e63fce5341cb7c8..02ae356059948a846d0d58edb418a35a55672e08 100644 --- a/duniterpy/api/endpoint.py +++ b/duniterpy/api/endpoint.py @@ -52,7 +52,7 @@ class ConnectionHandler: self.proxy = proxy def __str__(self) -> str: - return "connection info: %s:%d" % (self.address, self.port) + return f"connection info: {self.address}:{self.port}" # required to type hint cls in classmethod @@ -124,7 +124,8 @@ class UnknownEndpoint(Endpoint): return ConnectionHandler("", "", "", 0, "") def __str__(self) -> str: - return "{} {}".format(self.api, " ".join([f"{p}" for p in self.properties])) + properties = " ".join([f"{p}" for p in self.properties]) + return f"{self.api} {properties}" def __eq__(self, other: Any) -> bool: if not isinstance(other, UnknownEndpoint): @@ -182,12 +183,10 @@ class BMAEndpoint(Endpoint): :return: """ - return BMAEndpoint.API + "{DNS}{IPv4}{IPv6}{PORT}".format( - DNS=(f" {self.host}" if self.host else ""), - IPv4=(f" {self.ipv4}" if self.ipv4 else ""), - IPv6=(f" {self.ipv6}" if self.ipv6 else ""), - PORT=(f" {self.port}" if self.port else ""), - ) + inlined = [ + str(info) for info in (self.host, self.ipv4, self.ipv6, self.port) if info + ] + return f'{self.API} {" ".join(inlined)}' def conn_handler(self, proxy: str = None) -> ConnectionHandler: """ @@ -284,7 +283,7 @@ class SecuredBMAEndpoint(BMAEndpoint): for info in (self.host, self.ipv4, self.ipv6, self.port, self.path) if info ] - return SecuredBMAEndpoint.API + " " + " ".join(inlined) + return f'{self.API} {" ".join(inlined)}' def conn_handler(self, proxy: str = None) -> ConnectionHandler: """ @@ -353,7 +352,7 @@ class WS2PEndpoint(Endpoint): inlined = [ str(info) for info in (self.ws2pid, self.host, self.port, self.path) if info ] - return WS2PEndpoint.API + " " + " ".join(inlined) + return f'{self.API} {" ".join(inlined)}' def conn_handler(self, proxy: str = None) -> ConnectionHandler: """ @@ -424,7 +423,7 @@ class ESCoreEndpoint(Endpoint): :return: """ inlined = [str(info) for info in (self.host, self.port) if info] - return ESCoreEndpoint.API + " " + " ".join(inlined) + return f'{self.API} {" ".join(inlined)}' def conn_handler(self, proxy: str = None) -> ConnectionHandler: """ @@ -483,7 +482,7 @@ class ESUserEndpoint(Endpoint): :return: """ inlined = [str(info) for info in (self.host, self.port) if info] - return ESUserEndpoint.API + " " + " ".join(inlined) + return f'{self.API} {" ".join(inlined)}' def conn_handler(self, proxy: str = None) -> ConnectionHandler: """ @@ -546,7 +545,7 @@ class ESSubscribtionEndpoint(Endpoint): :return: """ inlined = [str(info) for info in (self.host, self.port) if info] - return ESSubscribtionEndpoint.API + " " + " ".join(inlined) + return f'{self.API} {" ".join(inlined)}' def conn_handler(self, proxy: str = None) -> ConnectionHandler: """ @@ -645,7 +644,7 @@ class GVAEndpoint(Endpoint): ) if info ] - return self.API + " " + " ".join(inlined) + return f'{self.API} {" ".join(inlined)}' def conn_handler(self, proxy: str = None) -> ConnectionHandler: """ @@ -722,7 +721,7 @@ def endpoint(value: Any) -> Any: elif isinstance(value, str): # find Endpoint instance for api, cls in MANAGED_API.items(): - if value.startswith(api + " "): + if value.startswith(f"{api} "): result = cls.from_inline(value) else: raise TypeError(f"Cannot convert {value} to endpoint") diff --git a/duniterpy/api/errors.py b/duniterpy/api/errors.py index e1b6dd5d3b1990d58753635ee4de94afe6f7c39b..f5ee16d06b9a5335d13a962ff89d49978894a06c 100644 --- a/duniterpy/api/errors.py +++ b/duniterpy/api/errors.py @@ -25,7 +25,7 @@ class DuniterError(Exception): :param data: Error informations """ - super().__init__("Error code {} - {}".format(data["ucode"], data["message"])) + super().__init__(f'Error code {data["ucode"]} - {data["message"]}') self.ucode = data["ucode"] self.message = data["message"] diff --git a/duniterpy/constants.py b/duniterpy/constants.py index dc64f472e4a120b07d1797acc449f0cab74dd081..e0f8b022266ab7c1e8bdbc3e6b49c0a3069cd523 100644 --- a/duniterpy/constants.py +++ b/duniterpy/constants.py @@ -20,13 +20,9 @@ BLOCK_HASH_REGEX = "[0-9a-fA-F]{5,64}" TRANSACTION_HASH_REGEX = "[0-9a-fA-F]{5,64}" HASH_REGEX = "[A-F0-9]{64}" BLOCK_NUMBER_REGEX = "[0-9]+" -BLOCK_ID_REGEX = "{block_number_regex}-{block_hash_regex}".format( - block_number_regex=BLOCK_NUMBER_REGEX, block_hash_regex=BLOCK_HASH_REGEX -) +BLOCK_ID_REGEX = f"{BLOCK_NUMBER_REGEX}-{BLOCK_HASH_REGEX}" CONDITIONS_REGEX = ( - "(&&|\\|\\|| |[()]|(SIG\\({pubkey_regex}\\)|(XHX\\({hash_regex}\\))))*".format( - pubkey_regex=PUBKEY_REGEX, hash_regex=HASH_REGEX - ) + f"(&&|\\|\\|| |[()]|(SIG\\({PUBKEY_REGEX}\\)|(XHX\\({HASH_REGEX}\\))))*" ) # https://stackoverflow.com/a/17871737 IPV4SEG = "(?:25[0-5]|(?:2[0-4]|1?\\d)?\\d)"