#146: Use f-string

• Fix local blockchain code
• Delete empty api.elasticsearch module
• Use f-string as much as possible:
  • Replace .format(), %, str + str formats to f-string format
  • Done as much as possible without putting too horrible operations in the f-string
  • Kept % format into the logging for now, since it causes errors with pylint and mypy

Close #146 (closed).

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)