Use f-strings in python3.6 code (#1437)

pipermerriam · web-flow · commit f074ec5cbc3d · 2018-10-25T14:36:32.000-06:00
diff --git a/trinity/__init__.py b/trinity/__init__.py
@@ -6,9 +6,7 @@
 try:
     __version__ = pkg_resources.get_distribution("trinity").version
 except pkg_resources.DistributionNotFound:
-    __version__ = "eth-{0}".format(
-        pkg_resources.get_distribution("py-evm").version,
-    )
+    __version__ = f"eth-{pkg_resources.get_distribution('py-evm').version}"
 
 # This is to ensure we call setup_trace_logging() before anything else.
 import eth as _eth_module  # noqa: F401
diff --git a/trinity/cli_parser.py b/trinity/cli_parser.py
@@ -74,11 +74,11 @@ def __call__(self,
             if not path or not raw_log_level:
                 raise argparse.ArgumentError(
                     self,
-                    "Invalid logging config: '{0}'.  Log level may be specified "
+                    f"Invalid logging config: '{value}'.  Log level may be specified "
                     "as a global logging level using the syntax `--log-level "
                     "<LEVEL-NAME>` or for to specify the logging level for an "
                     "individual logger, '--log-level "
-                    "<LOGGER-NAME>:<LEVEL-NAME>'".format(value)
+                    "<LOGGER-NAME>:<LEVEL-NAME>'"
                 )
 
             try:
@@ -87,11 +87,11 @@ def __call__(self,
                 raise argparse.ArgumentError(
                     self,
                     (
-                        "Invalid logging level.  Got '{0}'.  Must be one of\n"
+                        f"Invalid logging level.  Got '{raw_log_level}'.  Must be one of\n"
                         " - 5/10/20/30/40 (numeric logging levels)\n"
                         " - trace/debug/info/warn/warning/error/critical (lowercase)\n"
                         " - TRACE/DEBUG/INFO/WARN/WARNING/ERROR/CRITICAL (uppercase)\n"
-                    ).format(raw_log_level),
+                    )
                 )
 
         if getattr(namespace, self.dest) is None:
@@ -101,15 +101,13 @@ def __call__(self,
             if path is None:
                 raise argparse.ArgumentError(
                     self,
-                    "Global logging has already been configured to '{0}'.  The "
-                    "global logging level may only be specified once.".format(
-                        log_level,
-                    )
+                    f"Global logging has already been configured to '{log_level}'.  The "
+                    "global logging level may only be specified once."
                 )
             else:
                 raise argparse.ArgumentError(
                     self,
-                    "The logging level for '{0}' was provided more than once. "
+                    f"The logging level for '{path}' was provided more than once. "
                     "Please ensure the each name is provided only once"
                 )
         log_levels[path] = log_level
diff --git a/trinity/config.py b/trinity/config.py
@@ -181,7 +181,7 @@ def database_dir(self) -> Path:
         elif self.sync_mode == SYNC_LIGHT:
             return self.data_dir / DATABASE_DIR_NAME / "light"
         else:
-            raise ValueError("Unknown sync mode: {}".format(self.sync_mode))
+            raise ValueError(f"Unknown sync mode: {self.sync_mode}")
 
     @property
     def database_ipc_path(self) -> Path:
@@ -238,7 +238,7 @@ def nodekey(self, value: Union[bytes, PrivateKey]) -> None:
         else:
             raise TypeError(
                 "Nodekey must either be a raw byte-string or an eth_keys "
-                "`PrivateKey` instance"
+                f"`PrivateKey` instance: got {type(self._nodekey)}"
             )
 
     @classmethod
diff --git a/trinity/extensibility/plugin.py b/trinity/extensibility/plugin.py
@@ -127,7 +127,7 @@ def logger(self) -> logging.Logger:
         """
         Get the :class:`~logging.Logger` for this plugin.
         """
-        return logging.getLogger('trinity.extensibility.plugin.BasePlugin#{0}'.format(self.name))
+        return logging.getLogger(f'trinity.extensibility.plugin.BasePlugin#{self.name}')
 
     @property
     def event_bus(self) -> Endpoint:
diff --git a/trinity/initialization.py b/trinity/initialization.py
@@ -74,10 +74,8 @@ def initialize_data_dir(trinity_config: TrinityConfig) -> None:
     elif not trinity_config.data_dir.exists():
         # we don't lazily create the base dir for non-default base directories.
         raise MissingPath(
-            "The base chain directory provided does not exist: `{0}`".format(
-                trinity_config.data_dir,
-            ),
-            trinity_config.data_dir
+            f"The base chain directory provided does not exist: `{str(trinity_config.data_dir)}`",
+            trinity_config.data_dir,
         )
 
     # Logfile
diff --git a/trinity/main.py b/trinity/main.py
@@ -118,8 +118,8 @@ def main() -> None:
 
     if args.network_id not in PRECONFIGURED_NETWORKS:
         raise NotImplementedError(
-            "Unsupported network id: {0}.  Only the ropsten and mainnet "
-            "networks are supported.".format(args.network_id)
+            f"Unsupported network id: {args.network_id}.  Only the ropsten and mainnet "
+            "networks are supported."
         )
 
     has_ambigous_logging_config = (
diff --git a/trinity/plugins/builtin/tx_pool/pool.py b/trinity/plugins/builtin/tx_pool/pool.py
@@ -116,7 +116,7 @@ def _filter_tx_for_peer(
         ]
 
     def _construct_bloom_entry(self, peer: ETHPeer, tx: BaseTransactionFields) -> bytes:
-        return "{!r}-{}-{}".format(peer.remote, tx.hash, self._bloom_salt).encode()
+        return f"{repr(peer.remote)}-{tx.hash}-{self._bloom_salt}".encode()
 
     def _add_txs_to_bloom(self, peer: ETHPeer, txs: Iterable[BaseTransactionFields]) -> None:
         for val in txs:
diff --git a/trinity/protocol/common/handlers.py b/trinity/protocol/common/handlers.py
@@ -35,8 +35,8 @@ def __init__(self, peer: BasePeer) -> None:
         for attr, exchange_cls in self._exchange_config.items():
             if hasattr(self, attr):
                 raise AttributeError(
-                    "Unable to set manager on attribute `{0}` which is already "
-                    "present on the class: {1}".format(attr, getattr(self, attr))
+                    f"Unable to set manager on attribute `{attr}` which is already "
+                    f"present on the class: {getattr(self, attr)}"
                 )
             manager: ExchangeManager[Any, Any, Any]
             manager = ExchangeManager(self._peer, exchange_cls.response_cmd_type, peer.cancel_token)
diff --git a/trinity/protocol/common/managers.py b/trinity/protocol/common/managers.py
@@ -90,10 +90,8 @@ async def payload_candidates(
             await self.wait(self._lock.acquire(), timeout=timeout)
         except TimeoutError:
             raise AlreadyWaiting(
-                "Timed out waiting for {0} request lock for peer: {1}".format(
-                    self.response_msg_name,
-                    self._peer
-                )
+                f"Timed out waiting for {self.response_msg_name} request lock "
+                f"or peer: {self._peer}"
             )
 
         try:
diff --git a/trinity/protocol/common/validators.py b/trinity/protocol/common/validators.py
@@ -65,11 +65,9 @@ def validate_result(self, response: Tuple[BlockHeader, ...]) -> None:
             if first_header.hash != self.block_number_or_hash:
                 raise ValidationError(
                     "Returned headers cannot be matched to header request. "
-                    "Expected first header to have hash of {0} but instead got "
-                    "{1}.".format(
-                        encode_hex(self.block_number_or_hash),
-                        encode_hex(first_header.hash),
-                    )
+                    "Expected first header to have hash of "
+                    f"{encode_hex(self.block_number_or_hash)} but instead got "
+                    f"{encode_hex(first_header.hash)}."
                 )
 
         block_numbers: Tuple[BlockNumber, ...] = tuple(
@@ -115,8 +113,7 @@ def _validate_sequence(self, block_numbers: Tuple[BlockNumber, ...]) -> None:
         # check for numbers that should not be present.
         unexpected_numbers = set(block_numbers).difference(expected_numbers)
         if unexpected_numbers:
-            raise ValidationError(
-                'Unexpected numbers: {0}'.format(unexpected_numbers))
+            raise ValidationError(f'Unexpected numbers: {unexpected_numbers}')
 
         # check that the numbers are correctly ordered.
         expected_order = tuple(sorted(
@@ -126,8 +123,8 @@ def _validate_sequence(self, block_numbers: Tuple[BlockNumber, ...]) -> None:
         if block_numbers != expected_order:
             raise ValidationError(
                 'Returned headers are not correctly ordered.\n'
-                'Expected: {0}\n'
-                'Got     : {1}\n'.format(expected_order, block_numbers)
+                f'Expected: {expected_order}\n'
+                f'Got     : {block_numbers}\n'
             )
 
         # check that all provided numbers are an ordered subset of the master
@@ -140,6 +137,6 @@ def _validate_sequence(self, block_numbers: Tuple[BlockNumber, ...]) -> None:
             else:
                 raise ValidationError(
                     'Returned headers contain an unexpected block number.\n'
-                    'Unexpected Number: {0}\n'
-                    'Expected Numbers : {1}'.format(number, expected_numbers)
+                    f'Unexpected Number: {number}\n'
+                    f'Expected Numbers : {expected_numbers}'
                 )
diff --git a/trinity/protocol/eth/peer.py b/trinity/protocol/eth/peer.py
@@ -66,20 +66,21 @@ async def process_sub_proto_handshake(
             self, cmd: Command, msg: _DecodedMsgType) -> None:
         if not isinstance(cmd, Status):
             await self.disconnect(DisconnectReason.subprotocol_error)
-            raise HandshakeFailure(
-                "Expected a ETH Status msg, got {}, disconnecting".format(cmd))
+            raise HandshakeFailure(f"Expected a ETH Status msg, got {cmd}, disconnecting")
         msg = cast(Dict[str, Any], msg)
         if msg['network_id'] != self.network_id:
             await self.disconnect(DisconnectReason.useless_peer)
             raise HandshakeFailure(
-                "{} network ({}) does not match ours ({}), disconnecting".format(
-                    self, msg['network_id'], self.network_id))
+                f"{self} network ({msg['network_id']}) does not match ours "
+                f"({self.network_id}), disconnecting"
+            )
         genesis = await self.genesis
         if msg['genesis_hash'] != genesis.hash:
             await self.disconnect(DisconnectReason.useless_peer)
             raise HandshakeFailure(
-                "{} genesis ({}) does not match ours ({}), disconnecting".format(
-                    self, encode_hex(msg['genesis_hash']), genesis.hex_hash))
+                f"{self} genesis ({encode_hex(msg['genesis_hash'])}) does not "
+                f"match ours ({genesis.hex_hash}), disconnecting"
+            )
         self.head_td = msg['td']
         self.head_hash = msg['best_hash']
 
diff --git a/trinity/protocol/eth/validators.py b/trinity/protocol/eth/validators.py
@@ -45,9 +45,7 @@ def validate_result(self, response: NodeDataBundles) -> None:
         unexpected_keys = node_key_set.difference(self.node_hashes)
 
         if unexpected_keys:
-            raise ValidationError(
-                "Response contains {0} unexpected nodes".format(len(unexpected_keys))
-            )
+            raise ValidationError(f"Response contains {len(unexpected_keys)} unexpected nodes")
 
 
 class ReceiptsValidator(BaseValidator[ReceiptsBundles]):
@@ -69,9 +67,7 @@ def validate_result(self, result: ReceiptsBundles) -> None:
         unexpected_roots = actual_receipt_roots.difference(expected_receipt_roots)
 
         if unexpected_roots:
-            raise ValidationError(
-                "Got {0} unexpected receipt roots".format(len(unexpected_roots))
-            )
+            raise ValidationError(f"Got {len(unexpected_roots)} unexpected receipt roots")
 
 
 class GetBlockBodiesValidator(BaseValidator[BlockBodyBundles]):
@@ -90,6 +86,4 @@ def validate_result(self, response: BlockBodyBundles) -> None:
         }
         unexpected_keys = actual_keys.difference(expected_keys)
         if unexpected_keys:
-            raise ValidationError(
-                "Got {0} unexpected block bodies".format(len(unexpected_keys))
-            )
+            raise ValidationError(f"Got {len(unexpected_keys)} unexpected block bodies")
diff --git a/trinity/protocol/les/peer.py b/trinity/protocol/les/peer.py
@@ -77,20 +77,21 @@ async def process_sub_proto_handshake(
             self, cmd: Command, msg: _DecodedMsgType) -> None:
         if not isinstance(cmd, (Status, StatusV2)):
             await self.disconnect(DisconnectReason.subprotocol_error)
-            raise HandshakeFailure(
-                "Expected a LES Status msg, got {}, disconnecting".format(cmd))
+            raise HandshakeFailure(f"Expected a LES Status msg, got {cmd}, disconnecting")
         msg = cast(Dict[str, Any], msg)
         if msg['networkId'] != self.network_id:
             await self.disconnect(DisconnectReason.useless_peer)
             raise HandshakeFailure(
-                "{} network ({}) does not match ours ({}), disconnecting".format(
-                    self, msg['networkId'], self.network_id))
+                f"{self} network ({msg['networkId']}) does not match ours "
+                f"({self.network_id}), disconnecting"
+            )
         genesis = await self.genesis
         if msg['genesisHash'] != genesis.hash:
             await self.disconnect(DisconnectReason.useless_peer)
             raise HandshakeFailure(
-                "{} genesis ({}) does not match ours ({}), disconnecting".format(
-                    self, encode_hex(msg['genesisHash']), genesis.hex_hash))
+                f"{self} genesis ({encode_hex(msg['genesisHash'])}) does not "
+                f"match ours ({genesis.hex_hash}), disconnecting"
+            )
         # Eventually we might want to keep connections to peers where we are the only side serving
         # data, but right now both our chain syncer and the Peer.boot() method expect the remote
         # to reply to header requests, so if they don't we simply disconnect here.
diff --git a/trinity/protocol/les/proto.py b/trinity/protocol/les/proto.py
@@ -71,8 +71,8 @@ def send_handshake(self, chain_info: ChainInfo) -> None:
     def send_get_block_bodies(self, block_hashes: List[bytes], request_id: int) -> None:
         if len(block_hashes) > constants.MAX_BODIES_FETCH:
             raise ValueError(
-                "Cannot ask for more than {} blocks in a single request".format(
-                    constants.MAX_BODIES_FETCH))
+                f"Cannot ask for more than {constants.MAX_BODIES_FETCH} blocks in a single request"
+            )
         data = {
             'request_id': request_id,
             'block_hashes': block_hashes,
diff --git a/trinity/sync/light/service.py b/trinity/sync/light/service.py
@@ -171,7 +171,7 @@ async def coro_get_block_body_by_hash(self, block_hash: Hash32) -> BlockBody:
         peer.sub_proto.send_get_block_bodies([block_hash], request_id)
         reply = await self._wait_for_reply(request_id)
         if not reply['bodies']:
-            raise BlockNotFound("Peer {} has no block with hash {}".format(peer, block_hash))
+            raise BlockNotFound(f"Peer {peer} has no block with hash {block_hash}")
         return reply['bodies'][0]
 
     # TODO add a get_receipts() method to BaseChain API, and dispatch to this, as needed
@@ -185,7 +185,7 @@ async def coro_get_receipts(self, block_hash: Hash32) -> List[Receipt]:
         peer.sub_proto.send_get_receipts(block_hash, request_id)
         reply = await self._wait_for_reply(request_id)
         if not reply['receipts']:
-            raise BlockNotFound("No block with hash {} found".format(block_hash))
+            raise BlockNotFound(f"No block with hash {block_hash} found")
         return reply['receipts'][0]
 
     # TODO implement AccountDB exceptions that provide the info needed to
@@ -356,7 +356,7 @@ async def _get_block_header_by_hash(self, block_hash: Hash32, peer: LESPeer) ->
             reverse=False,
         )
         if not headers:
-            raise HeaderNotFound("Peer {} has no block with hash {}".format(peer, block_hash))
+            raise HeaderNotFound(f"Peer {peer} has no block with hash {block_hash}")
         header = headers[0]
         if header.hash != block_hash:
             raise BadLESResponse(
diff --git a/trinity/tools/async_process_runner.py b/trinity/tools/async_process_runner.py
@@ -61,7 +61,7 @@ async def _iterate_until_empty(
     async def kill_after_timeout(self, timeout_sec: int) -> None:
         await asyncio.sleep(timeout_sec)
         self.kill()
-        raise TimeoutError('Killed process after {} seconds'.format(timeout_sec))
+        raise TimeoutError(f'Killed process after {timeout_sec} seconds')
 
     def kill(self) -> None:
         os.killpg(os.getpgid(self.proc.pid), signal.SIGKILL)
diff --git a/trinity/utils/chains.py b/trinity/utils/chains.py
@@ -51,7 +51,7 @@ def get_data_dir_for_network_id(network_id: int, trinity_root_dir: Path) -> Path
     try:
         return get_local_data_dir(DEFAULT_DATA_DIRS[network_id], trinity_root_dir)
     except KeyError:
-        raise KeyError("Unknown network id: `{0}`".format(network_id))
+        raise KeyError(f"Unknown network id: `{network_id}`")
 
 
 LOG_DIRNAME = 'logs'
diff --git a/trinity/utils/headers.py b/trinity/utils/headers.py
@@ -23,7 +23,7 @@ def sequence_builder(start_number: T,
     # Ignore the cutoffs at 0 and UINT_256_MAX, because this is just a gut check anyway,
     # we should never be approaching this value.
     if max_length > MAXIMUM_OBJECT_MEMORY_BYTES // 8:
-        raise OversizeObject("Sequence is too big to fit in memory: {}".format(max_length))
+        raise OversizeObject(f"Sequence is too big to fit in memory: {max_length}")
 
     if reverse:
         step = -1 * (skip + 1)
diff --git a/trinity/utils/log_messages.py b/trinity/utils/log_messages.py
@@ -3,9 +3,9 @@
 
 def create_missing_ipc_error_message(ipc_path: Path) -> str:
     log_message = (
-        "The IPC path at {0} is not found. \n"
+        f"The IPC path at {str(ipc_path)} is not found. \n"
         "Please run "
         "'trinity --data-dir <path-to-running-nodes-data-dir> attach' "
         "to specify the IPC path."
-    ).format(str(ipc_path))
+    )
     return log_message
diff --git a/trinity/utils/logging.py b/trinity/utils/logging.py
@@ -151,9 +151,7 @@ def inner(*args: Any, **kwargs: Any) -> Any:
         try:
             log_queue = kwargs['log_queue']
         except KeyError:
-            raise KeyError("The `log_queue` argument is required when calling `{0}`".format(
-                fn.__name__,
-            ))
+            raise KeyError(f"The `log_queue` argument is required when calling `{fn.__name__}`")
         else:
             level = kwargs.get('log_level', logging.INFO)
             setup_queue_logging(log_queue, level)
diff --git a/trinity/utils/version.py b/trinity/utils/version.py
@@ -11,12 +11,12 @@ def construct_trinity_client_identifier() -> str:
 
     e.g. 'Trinity/v1.2.3/darwin-amd64/python3.6.5'
     """
-    return "Trinity/{0}/{platform}/{imp.name}{v.major}.{v.minor}.{v.micro}".format(
-        __version__,
-        platform=sys.platform,
-        v=sys.version_info,
-        # mypy Doesn't recognize the `sys` module as having an `implementation` attribute.
-        imp=sys.implementation,
+    return (
+        "Trinity/"
+        f"{__version__}/"
+        f"{sys.platform}/"
+        f"{sys.implementation}"
+        f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
     )
 
 

Original file line number	Diff line number	Diff line change
`@@ -118,8 +118,8 @@ def main() -> None:`
`118`	`118`
`119`	`119`	`if args.network_id not in PRECONFIGURED_NETWORKS:`
`120`	`120`	`raise NotImplementedError(`
`121`		`- "Unsupported network id: {0}. Only the ropsten and mainnet "`
`122`		`- "networks are supported.".format(args.network_id)`
	`121`	`+ f"Unsupported network id: {args.network_id}. Only the ropsten and mainnet "`
	`122`	`+ "networks are supported."`
`123`	`123`	`)`
`124`	`124`
`125`	`125`	`has_ambigous_logging_config = (`
Original file line number	Diff line number	Diff line change
`@@ -116,7 +116,7 @@ def _filter_tx_for_peer(`
`116`	`116`	`]`
`117`	`117`
`118`	`118`	`def _construct_bloom_entry(self, peer: ETHPeer, tx: BaseTransactionFields) -> bytes:`
`119`		`- return "{!r}-{}-{}".format(peer.remote, tx.hash, self._bloom_salt).encode()`
	`119`	`+ return f"{repr(peer.remote)}-{tx.hash}-{self._bloom_salt}".encode()`
`120`	`120`
`121`	`121`	`def _add_txs_to_bloom(self, peer: ETHPeer, txs: Iterable[BaseTransactionFields]) -> None:`
`122`	`122`	`for val in txs:`