chore: refactor code quality issues (#1995)

Author: akshgpt7

.deepsource.toml

@@ -0,0 +1,12 @@
+version = 1
+
+test_patterns = ["tests/**"]
+
+exclude_patterns = ["fixtures/**"]
+
+[[analyzers]]
+name = "python"
+enabled = true
+
+  [analyzers.meta]
+  runtime_version = "3.x.x"

eth/_utils/blake2/coders.py

@@ -55,6 +55,6 @@ def _get_64_bit_little_endian_words(compact_bytes: bytes) -> Iterable[int]:
             f"{len(remaining_bytes)}"
         )
 
-    while len(remaining_bytes):
+    while remaining_bytes:
         word, remaining_bytes = remaining_bytes[:8], remaining_bytes[8:]
         yield to_int(bytes(reversed(word)))

eth/_utils/transactions.py

@@ -37,10 +37,7 @@
 
 
 def is_eip_155_signed_transaction(transaction: BaseTransaction) -> bool:
-    if transaction.v >= EIP155_CHAIN_ID_OFFSET:
-        return True
-    else:
-        return False
+    return transaction.v >= EIP155_CHAIN_ID_OFFSET
 
 
 def extract_chain_id(v: int) -> int:

eth/consensus/clique/encoding.py

@@ -84,7 +84,7 @@ def encode_snapshot(snapshot: Snapshot) -> bytes:
     return rlp.encode(
         [
             snapshot.block_hash,
-            [signer for signer in snapshot.signers],
+            list(snapshot.signers),
             [encode_vote(vote) for vote in snapshot.votes],
             [
                 encode_address_tally_pair((address, tally))

eth/db/account.py

@@ -533,12 +533,12 @@ def _get_meta_witness(self) -> MetaWitness:
 
     def _validate_generated_root(self) -> None:
         db_diff = self._journaldb.diff()
-        if len(db_diff):
+        if db_diff:
             raise ValidationError(
                 f"AccountDB had a dirty db when it needed to be clean: {db_diff!r}"
             )
         trie_diff = self._journaltrie.diff()
-        if len(trie_diff):
+        if trie_diff:
             raise ValidationError(
                 f"AccountDB had a dirty trie when it needed to be clean: {trie_diff!r}"
             )

eth/db/header.py

@@ -358,7 +358,7 @@ def _persist_header_chain(
         try:
             first_header = first(headers_iterator)
         except StopIteration:
-            return tuple(), tuple()
+            return (), ()
 
         is_genesis = first_header.parent_hash == genesis_parent_hash
         if not is_genesis and not cls._header_exists(db, first_header.parent_hash):
@@ -410,7 +410,7 @@ def _persist_header_chain(
         if score > head_score:
             return cls._set_as_canonical_chain_head(db, curr_chain_head, genesis_parent_hash)
 
-        return tuple(), tuple()
+        return (), ()
 
     @classmethod
     def _handle_gap_change(cls,
@@ -473,10 +473,8 @@ def _canonicalize_header(
 
         # Reject if this would make a checkpoint non-canonical
         checkpoints = cls._get_checkpoints(db)
-        attempted_checkpoint_overrides = set(
-            old for old in old_canonical_headers
-            if old.hash in checkpoints
-        )
+        attempted_checkpoint_overrides = {old for old in old_canonical_headers
+                                          if old.hash in checkpoints}
         if len(attempted_checkpoint_overrides):
             raise CheckpointsMustBeCanonical(
                 f"Tried to switch chain away from checkpoint(s) {attempted_checkpoint_overrides!r}"

eth/tools/builder/chain/builders.py

@@ -147,7 +147,7 @@ class FrontierOnlyChain(MiningChain):
     if chain_class.vm_configuration is not None:
         base_configuration = chain_class.vm_configuration
     else:
-        base_configuration = tuple()
+        base_configuration = ()
 
     vm_configuration = base_configuration + ((BlockNumber(at_block), vm_class),)
     validate_vm_configuration(vm_configuration)

eth/tools/fixtures/generation.py

@@ -81,7 +81,7 @@ def generate_fixture_tests(metafunc: Any,
         else:
             all_fixtures = cached_fixture_data
 
-        if not len(all_fixtures):
+        if not all_fixtures:
             raise AssertionError(
                 f"Suspiciously found zero fixtures: {base_fixture_path}"
             )

eth/vm/computation.py

@@ -410,7 +410,7 @@ def register_account_for_deletion(self, beneficiary: Address) -> None:
 
     def get_accounts_for_deletion(self) -> Tuple[Tuple[Address, Address], ...]:
         if self.is_error:
-            return tuple()
+            return ()
         else:
             return tuple(dict(itertools.chain(
                 self.accounts_to_delete.items(),
@@ -555,14 +555,14 @@ def apply_computation(cls,
     @property
     def precompiles(self) -> Dict[Address, Callable[[ComputationAPI], Any]]:
         if self._precompiles is None:
-            return dict()
+            return {}
         else:
             return self._precompiles
 
     @classmethod
     def get_precompiles(cls) -> Dict[Address, Callable[[ComputationAPI], Any]]:
         if cls._precompiles is None:
-            return dict()
+            return {}
         else:
             return cls._precompiles
 

tests/core/chain-object/test_chain_get_ancestors.py

@@ -30,7 +30,7 @@ def test_chain_get_ancestors_from_genesis_block(chain, limit):
     assert header.block_number == 0
 
     ancestors = chain.get_ancestors(limit, header)
-    assert ancestors == tuple()
+    assert ancestors == ()
 
 
 def test_chain_get_ancestors_from_block_1(chain):
@@ -39,7 +39,7 @@ def test_chain_get_ancestors_from_block_1(chain):
     header = block_1.header
     assert header.block_number == 1
 
-    assert chain.get_ancestors(0, header) == tuple()
+    assert chain.get_ancestors(0, header) == ()
     assert chain.get_ancestors(1, header) == (genesis,)
     assert chain.get_ancestors(2, header) == (genesis,)
     assert chain.get_ancestors(5, header) == (genesis,)
@@ -58,7 +58,7 @@ def test_chain_get_ancestors_from_block_5(chain):
     header = block_5.header
     assert header.block_number == 5
 
-    assert chain.get_ancestors(0, header) == tuple()
+    assert chain.get_ancestors(0, header) == ()
     assert chain.get_ancestors(1, header) == (block_4,)
     assert chain.get_ancestors(2, header) == (block_4, block_3)
     assert chain.get_ancestors(3, header) == (block_4, block_3, block_2)
@@ -103,14 +103,14 @@ def test_chain_get_ancestors_for_fork_chains(chain, fork_chain):
     # import the fork blocks into the main chain (ensuring they don't cause a reorg)
     block_import_result = chain.import_block(f_block_4)
     new_chain = block_import_result.new_canonical_blocks
-    assert new_chain == tuple()
+    assert new_chain == ()
 
     block_import_result = chain.import_block(f_block_5)
     new_chain = block_import_result.new_canonical_blocks
-    assert new_chain == tuple()
+    assert new_chain == ()
 
     # check with a block that has been imported
-    assert chain.get_ancestors(0, f_block_5.header) == tuple()
+    assert chain.get_ancestors(0, f_block_5.header) == ()
     assert chain.get_ancestors(1, f_block_5.header) == (f_block_4,)
     assert chain.get_ancestors(2, f_block_5.header) == (f_block_4, block_3)
     assert chain.get_ancestors(3, f_block_5.header) == (f_block_4, block_3, block_2)
@@ -121,7 +121,7 @@ def test_chain_get_ancestors_for_fork_chains(chain, fork_chain):
     assert chain.get_ancestors(20, f_block_5.header) == (f_block_4, block_3, block_2, block_1, genesis)  # noqa: E501
 
     # check with a block that has NOT been imported
-    assert chain.get_ancestors(0, f_block_6.header) == tuple()
+    assert chain.get_ancestors(0, f_block_6.header) == ()
     assert chain.get_ancestors(1, f_block_6.header) == (f_block_5,)
     assert chain.get_ancestors(2, f_block_6.header) == (f_block_5, f_block_4)
     assert chain.get_ancestors(3, f_block_6.header) == (f_block_5, f_block_4, block_3)

tests/core/chain-object/test_header_chain.py

@@ -103,15 +103,15 @@ def test_header_chain_import_block(header_chain, genesis_header):
 
     for header in chain_b:
         res, _ = header_chain.import_header(header)
-        assert res == tuple()
+        assert res == ()
         assert_headers_eq(header_chain.header, chain_a[-1])
 
     for idx, header in enumerate(chain_c, 1):
         res, _ = header_chain.import_header(header)
         if idx <= 3:
             # prior to passing up `chain_a` each import should not return new
             # canonical headers.
-            assert res == tuple()
+            assert res == ()
             assert_headers_eq(header_chain.header, chain_a[-1])
         elif idx == 4:
             # at the point where `chain_c` passes `chain_a` we should get the

tests/core/consensus/test_clique_encoding.py

@@ -50,7 +50,7 @@
 )
 
 
-ADDRESS_TALLY_PAIRS = [(key, val) for key, val in SNAPSHOT_1.tallies.items()]
+ADDRESS_TALLY_PAIRS = list(SNAPSHOT_1.tallies.items())
 
 
 @pytest.mark.parametrize(

tests/core/tester/test_generate_vm_configuration.py

@@ -30,7 +30,7 @@ class CustomFrontierVM(FrontierVM):
     "args,kwargs,expected",
     (
         (
-            tuple(),
+            (),
             {},
             ((0, Forks.Berlin),),
         ),

tests/core/validation/test_eth1_validation.py

@@ -37,7 +37,7 @@
 @pytest.mark.parametrize(
     "value,is_valid",
     (
-        (tuple(), True),
+        ((), True),
         ([], True),
         ({}, True),
         (set(), True),
@@ -60,7 +60,7 @@ def test_validate_unique(value, is_valid):
 @pytest.mark.parametrize(
     "value,is_valid",
     (
-        (tuple(), False),
+        ((), False),
         ([], False),
         ({}, False),
         (set(), False),
@@ -81,7 +81,7 @@ def test_validate_is_bytes(value, is_valid):
 @pytest.mark.parametrize(
     "value,is_valid",
     (
-        (tuple(), False),
+        ((), False),
         ([], False),
         ({}, False),
         (set(), False),
@@ -101,7 +101,7 @@ def test_validate_is_integer(value, is_valid):
 @pytest.mark.parametrize(
     "value,is_valid",
     (
-        (tuple(), False),
+        ((), False),
         ([], False),
         ({}, False),
         (set(), False),
@@ -122,7 +122,7 @@ def test_validate_is_boolean(value, is_valid):
 @pytest.mark.parametrize(
     "value,length,is_valid",
     (
-        (tuple(), 0, True),
+        ((), 0, True),
         ([1], 1, True),
         ({'A': 'B', 'C': 1}, 3, False),
         ({'A', 'B', 1, 2}, 4, True),
@@ -142,7 +142,7 @@ def test_validate_length(value, length, is_valid):
 @pytest.mark.parametrize(
     "value,maximum_length,is_valid",
     (
-        (tuple(), 0, True),
+        ((), 0, True),
         ([1], 0, False),
         ({'A': 'B', 'C': 1}, 3, True),
         ({'A', 'B', 1, 2}, 2, False),
@@ -280,7 +280,7 @@ def test_validate_word(value, is_valid):
 @pytest.mark.parametrize(
     "value,is_valid",
     (
-        (tuple(), False),
+        ((), False),
         ('a', False),
         (-1, False),
         (0, True),
@@ -371,7 +371,7 @@ def test_validate_lt_secpk1n2(value, is_valid):
 @pytest.mark.parametrize(
     "block_number,is_valid",
     (
-        (tuple(), False),
+        ((), False),
         ([], False),
         ({}, False),
         (set(), False),

tests/core/vm/test_base_computation.py

@@ -184,7 +184,7 @@ def test_get_accounts_for_deletion_returns(computation):
 
 
 def test_add_log_entry_starts_empty(computation):
-    assert computation.get_log_entries() == tuple()
+    assert computation.get_log_entries() == ()
 
 
 def test_add_log_entry_raises_if_address_isnt_canonical(computation):

tests/database/test_db_diff.py

@@ -104,7 +104,7 @@ def test_database_api_deleted_key_for_deletion(db):
 @pytest.mark.parametrize(
     'db, series_of_diffs, expected',
     (
-        ({b'0': b'0'}, tuple(), {b'0': b'0'}),
+        ({b'0': b'0'}, (), {b'0': b'0'}),
         ({b'0': b'0'}, ({}, {}), {b'0': b'0'}),
         (
             {},
@@ -156,7 +156,7 @@ def test_join_diffs(db, series_of_diffs, expected):
 @pytest.mark.parametrize(
     'series_of_diffs, expected_updates, expected_deletions',
     (
-        (tuple(), {}, []),
+        ((), {}, []),
         (({}, {}), {}, []),
         (
             (
@@ -205,7 +205,7 @@ def test_db_diff_inspection(series_of_diffs, expected_updates, expected_deletion
     if expected_updates:
         expected_keys, _ = zip(*expected_updates.items())
     else:
-        expected_keys = tuple()
+        expected_keys = ()
     assert actual_diff.pending_keys() == expected_keys
     assert actual_diff.pending_items() == tuple(expected_updates.items())
     assert actual_diff.deleted_keys() == tuple(expected_deletions)

tests/database/test_header_db.py

@@ -818,14 +818,14 @@ def test_headerdb_persist_header_returns_new_canonical_chain(headerdb, genesis_h
 
     for header in chain_b:
         res, _ = headerdb.persist_header(header)
-        assert res == tuple()
+        assert res == ()
 
     for idx, header in enumerate(chain_c, 1):
         res, _ = headerdb.persist_header(header)
         if idx <= 3:
             # prior to passing up `chain_a` each import should not return new
             # canonical headers.
-            assert res == tuple()
+            assert res == ()
         elif idx == 4:
             # at the point where `chain_c` passes `chain_a` we should get the
             # headers from `chain_c` up through current.