Sourcery refactored master branch

btclib_node/__init__.py

@@ -47,17 +47,11 @@ def sigint_handler(signal, frame):
 
         self.download_window = []
 
-        if config.p2p_port:
-            self.p2p_port = config.p2p_port
-        else:
-            self.p2p_port = None
+        self.p2p_port = config.p2p_port or None
         peer_db = PeerDB(self.chain, self.data_dir)
         self.p2p_manager = P2pManager(self, self.p2p_port, peer_db)
 
-        if config.rpc_port:
-            self.rpc_port = config.rpc_port
-        else:
-            self.rpc_port = None
+        self.rpc_port = config.rpc_port or None
         self.rpc_manager = RpcManager(self, self.rpc_port)
 
     def run(self):

btclib_node/block_db/__init__.py

@@ -20,12 +20,12 @@ def deserialize(cls, data, check_validity=False):
         stream = bytesio_from_binarydata(data)
         hash = stream.read(32)
         to_add = []
-        for x in range(var_int.parse(stream)):
+        for _ in range(var_int.parse(stream)):
             out_point = OutPoint.parse(stream, check_validity)
             tx_out = TxOut.parse(stream, check_validity)
             to_add.append([out_point, tx_out])
         to_remove = []
-        for x in range(var_int.parse(stream)):
+        for _ in range(var_int.parse(stream)):
             out_point = OutPoint.parse(stream, check_validity)
             to_remove.append(out_point)
         return cls(hash, to_add, to_remove)
@@ -175,8 +175,7 @@ def __add_data_to_file(self, file, data):
 
     def __get_data_from_file(self, file, index, size):
         file.seek(index)
-        data = file.read(size)
-        return data
+        return file.read(size)
 
     def add_block(self, block):
         block_hash = block.header.hash

btclib_node/chainstate.py

@@ -49,13 +49,12 @@ def add_block(self, block):
                     self.updated_utxo_set.pop(prevout_bytes)
                 else:
                     prevout = self.db.get(prevout_bytes)
-                    if prevout:
-                        prevout = TxOut.parse(prevout, check_validity=False)
-                        prev_outputs.append(prevout)
-                        self.removed_utxos.add(prevout_bytes)
-                    else:
+                    if not prevout:
                         raise Exception
 
+                    prevout = TxOut.parse(prevout, check_validity=False)
+                    prev_outputs.append(prevout)
+                    self.removed_utxos.add(prevout_bytes)
                 removed.append((tx_in.prev_out, prevout))
 
             for i, tx_out in enumerate(tx.vout):
@@ -80,11 +79,10 @@ def apply_rev_block(self, rev_block):
                 raise Exception
             if out_point_bytes in self.updated_utxo_set:
                 self.updated_utxo_set.pop(out_point_bytes)
+            elif self.db.get(out_point_bytes):
+                self.removed_utxos.add(out_point_bytes)
             else:
-                if self.db.get(out_point_bytes):
-                    self.removed_utxos.add(out_point_bytes)
-                else:
-                    raise Exception
+                raise Exception
 
         for out_point, tx_out in rev_block.to_add:
             self.updated_utxo_set[out_point.serialize(check_validity=False)] = tx_out

btclib_node/config.py

@@ -40,10 +40,7 @@ def __init__(
         else:
             raise ValueError
 
-        if data_dir:
-            data_dir = Path(data_dir)
-        else:
-            data_dir = Path.home() / ".btclib"
+        data_dir = Path(data_dir) if data_dir else Path.home() / ".btclib"
         self.data_dir = data_dir.absolute() / self.chain.name
 
         self.p2p_port = None

btclib_node/download.py

@@ -5,46 +5,47 @@
 
 
 def block_download(node):
-    if node.status >= NodeStatus.HeaderSynced:
+    if node.status < NodeStatus.HeaderSynced:
+        return
+    if not node.download_window:
+        node.download_window = node.index.get_download_candidates()
+    node.download_window = [
+        x
+        for x in node.download_window
+        if not node.index.get_block_info(x).downloaded
+    ]
+    if not node.download_window:
+        return
 
-        if not node.download_window:
-            node.download_window = node.index.get_download_candidates()
-        node.download_window = [
-            x
-            for x in node.download_window
-            if not node.index.get_block_info(x).downloaded
+    connections = list(node.p2p_manager.connections.values())
+    pending = []
+    exit = True
+    for conn in connections:
+        conn_queue = conn.block_download_queue
+        new_queue = [
+            header
+            for header in conn_queue
+            if not node.index.get_block_info(header).downloaded
         ]
-        if not node.download_window:
-            return
+        conn.block_download_queue = new_queue
+        pending.extend(new_queue)
+        if not new_queue:
+            exit = False
+    if exit:
+        return
 
-        connections = list(node.p2p_manager.connections.values())
-        pending = []
-        exit = True
-        for conn in connections:
-            conn_queue = conn.block_download_queue
-            new_queue = []
-            for header in conn_queue:
-                if not node.index.get_block_info(header).downloaded:
-                    new_queue.append(header)
-            conn.block_download_queue = new_queue
-            pending.extend(new_queue)
-            if not new_queue:
-                exit = False
-        if exit:
-            return
+    waiting = [header for header in node.download_window if header not in pending]
+    pending = [x[0] for x in Counter(pending).most_common()[::-1]]
 
-        waiting = [header for header in node.download_window if header not in pending]
-        pending = [x[0] for x in Counter(pending).most_common()[::-1]]
-
-        for conn in connections:
-            if conn.block_download_queue == []:
-                if waiting:
-                    new = waiting[:16]
-                    waiting = waiting[16:]
-                elif pending:
-                    new = pending[:4]
-                    pending = pending[4:]
-                else:
-                    return
-                conn.block_download_queue = new
-                conn.send(Getdata([(0x40000002, hash) for hash in new]))
+    for conn in connections:
+        if conn.block_download_queue == []:
+            if waiting:
+                new = waiting[:16]
+                waiting = waiting[16:]
+            elif pending:
+                new = pending[:4]
+                pending = pending[4:]
+            else:
+                return
+            conn.block_download_queue = new
+            conn.send(Getdata([(0x40000002, hash) for hash in new]))

btclib_node/index/__init__.py

@@ -110,10 +110,11 @@ def calculate_chainwork(self):
             block_info.chainwork = old_work + calculate_work(block_info.header)
 
     def generate_active_chain(self):
-        chain_dict = {}
-        for block_hash, block_info in self.header_dict.items():
-            if block_info.status == BlockStatus.in_active_chain:
-                chain_dict[block_info.index] = block_hash
+        chain_dict = {
+            block_info.index: block_hash
+            for block_hash, block_info in self.header_dict.items()
+            if block_info.status == BlockStatus.in_active_chain
+        }
         for index in sorted(chain_dict.keys()):
             self.active_chain.append(chain_dict[index])
 
@@ -264,17 +265,15 @@ def get_download_candidates(self):
                         break
                     if not block_info.downloaded:
                         new_candidates.append(candidate)
-                candidates = candidates + new_candidates[::-1]
+                candidates += new_candidates[::-1]
         return candidates[:1024]
 
     # return a list of block hashes looking at the current best chain
     def get_block_locator_hashes(self):
         i = 1
         step = 1
         block_locators = []
-        while True:
-            if i > len(self.header_index):
-                break
+        while i <= len(self.header_index):
             block_locators.append(self.header_index[-i])
             if i >= 10:
                 step *= 2

btclib_node/log.py

@@ -4,10 +4,7 @@
 class Logger(logging.Logger):
     def __init__(self, filepath=None, debug=False, **kwargs):
         super().__init__(name="Logger", level=logging.DEBUG, **kwargs)
-        if debug:
-            handler = logging.StreamHandler()
-        else:
-            handler = logging.FileHandler(filepath)
+        handler = logging.StreamHandler() if debug else logging.FileHandler(filepath)
         formatter = logging.Formatter("%(asctime)s - %(message)s")
         handler.setFormatter(formatter)
         self.addHandler(handler)

btclib_node/mempool.py

@@ -15,15 +15,11 @@ def is_full(self):
     def get_missing(self, transactions):
         missing = []
         if not self.is_full():
-            for tx in transactions:
-                if tx not in self.transactions:
-                    missing.append(tx)
+            missing.extend(tx for tx in transactions if tx not in self.transactions)
         return missing
 
     def get_tx(self, txid):
-        if txid in self.transactions:
-            return self.transactions[txid]
-        return None
+        return self.transactions[txid] if txid in self.transactions else None
 
     def add_tx(self, tx):
         if not self.is_full():

btclib_node/p2p/address.py

@@ -11,7 +11,7 @@ def to_ipv6(ip):
     try:
         return IPv6Address(ip)
     except AddressValueError:
-        return IPv6Address("::ffff:" + ip)
+        return IPv6Address(f"::ffff:{ip}")
 
 
 @dataclass
@@ -24,10 +24,7 @@ class NetworkAddress:
     @classmethod
     def deserialize(cls, data, version_msg=False):
         stream = bytesio_from_binarydata(data)
-        if not version_msg:
-            time = int.from_bytes(stream.read(4), "little")
-        else:
-            time = 0
+        time = 0 if version_msg else int.from_bytes(stream.read(4), "little")
         services = int.from_bytes(stream.read(8), "little")
         a = stream.read(16)
         ip = IPv6Address(a)

btclib_node/p2p/callbacks.py

@@ -110,28 +110,24 @@ def inv(node, msg, conn):
     if node.status < NodeStatus.BlockSynced:
         return
 
-    transactions = [x[1] for x in inv.inventory if x[0] == 1 or x[0] == 0x40000001]
-    blocks = [x[1] for x in inv.inventory if x[0] == 2 or x[0] == 0x40000002]
-    if blocks:
+    transactions = [x[1] for x in inv.inventory if x[0] in [1, 0x40000001]]
+    if blocks := [x[1] for x in inv.inventory if x[0] in [2, 0x40000002]]:
         block_locators = node.index.get_block_locator_hashes()
         conn.send(Getheaders(ProtocolVersion, block_locators, blocks[-1]))
 
-    missing_tx = node.mempool.get_missing(transactions)
-    if missing_tx:
+    if missing_tx := node.mempool.get_missing(transactions):
         conn.send(Getdata([(0x40000001, tx) for tx in missing_tx]))
 
 
 def getdata(node, msg, conn):
     getdata = Getdata.deserialize(msg)
-    transactions = [x[1] for x in getdata.inventory if x[0] == 1 or x[0] == 0x40000001]
-    blocks = [x[1] for x in getdata.inventory if x[0] == 2 or x[0] == 0x40000002]
+    transactions = [x[1] for x in getdata.inventory if x[0] in [1, 0x40000001]]
+    blocks = [x[1] for x in getdata.inventory if x[0] in [2, 0x40000002]]
     for txid in transactions:
-        tx = node.mempool.get_tx(txid)
-        if tx:
+        if tx := node.mempool.get_tx(txid):
             conn.send(TxMsg(tx))
     for block_hash in blocks:
-        block = node.block_db.get_block(block_hash)
-        if block:
+        if block := node.block_db.get_block(block_hash):
             conn.send(BlockMsg(block))
 
 
@@ -149,17 +145,15 @@ def headers(node, msg, conn):
     if len(headers) == 2000 and added:  # we have to require more headers
         block_locators = node.index.get_block_locator_hashes()
         conn.send(Getheaders(ProtocolVersion, block_locators, b"\x00" * 32))
-    else:
-        if node.status == NodeStatus.SyncingHeaders:
-            node.status = NodeStatus.HeaderSynced
+    elif node.status == NodeStatus.SyncingHeaders:
+        node.status = NodeStatus.HeaderSynced
 
 
 def getheaders(node, msg, conn):
     getheaders = Getheaders.deserialize(msg)
-    headers = node.index.get_headers_from_locators(
+    if headers := node.index.get_headers_from_locators(
         getheaders.block_hashes, getheaders.hash_stop
-    )
-    if headers:
+    ):
         conn.send(Headers(headers))
 
 

btclib_node/p2p/main.py

@@ -10,9 +10,7 @@ def handle_p2p_handshake(node):
         try:
             if conn.status == P2pConnStatus.Open:
                 handshake_callbacks[msg_type](node, msg, conn)
-            elif conn.status == P2pConnStatus.Closed:
-                pass
-            else:
+            elif conn.status != P2pConnStatus.Closed:
                 conn.stop()
         except Exception:
             conn.stop()
@@ -28,9 +26,7 @@ def handle_p2p(node):
             if msg_type in callbacks:
                 if conn.status == P2pConnStatus.Connected:
                     callbacks[msg_type](node, msg, conn)
-                elif conn.status == P2pConnStatus.Closed:
-                    pass
-                else:
+                elif conn.status != P2pConnStatus.Closed:
                     conn.stop()
                 node.logger.debug("Finished p2p\n")
         except Exception:

btclib_node/p2p/manager.py

@@ -66,10 +66,7 @@ async def manage_connections(self, loop):
                         conn.ping_nonce = ping_msg.nonce
                     elif now - conn.ping_sent > 120:
                         self.remove_connection(conn.id)
-            if self.node.status < NodeStatus.HeaderSynced:
-                connection_num = 1
-            else:
-                connection_num = 10
+            connection_num = 1 if self.node.status < NodeStatus.HeaderSynced else 10
             if len(self.connections) < connection_num and not self.peer_db.is_empty():
                 already_connected = [conn.address for conn in self.connections.values()]
                 try:

btclib_node/p2p/messages/address.py

@@ -16,9 +16,7 @@ class Addr:
     def deserialize(cls, data):
         stream = bytesio_from_binarydata(data)
         len_addresses = var_int.parse(stream)
-        addresses = []
-        for x in range(len_addresses):
-            addresses.append(NetworkAddress.deserialize(stream))
+        addresses = [NetworkAddress.deserialize(stream) for _ in range(len_addresses)]
         return cls(addresses=addresses)
 
     def serialize(self):

btclib_node/p2p/messages/compact.py

@@ -40,13 +40,11 @@ def deserialize(cls, data):
         stream = bytesio_from_binarydata(data)
         header = BlockHeader.parse(stream)
         nonce = int.from_bytes(stream.read(8), "little")
-        short_ids = []
         short_ids_length = var_int.parse(stream)
-        for x in range(short_ids_length):
-            short_ids.append(stream.read(6)[::-1])
+        short_ids = [stream.read(6)[::-1] for _ in range(short_ids_length)]
         prefilled_tx_list = []
         prefilled_tx_num = var_int.parse(stream)
-        for x in range(prefilled_tx_num):
+        for _ in range(prefilled_tx_num):
             tx_index = var_int.parse(stream)
             tx = Tx.parse(stream)
             prefilled_tx_list.append((tx_index, tx))