refactor(settings): remove some calls to HathorSettings

Author: glevco

hathor/conf/settings.py

@@ -395,10 +395,6 @@ def GENESIS_TX2_TIMESTAMP(self) -> int:
     # Identifier used in metadata's voided_by to mark a tx as partially validated.
     PARTIALLY_VALIDATED_ID: bytes = b'pending-validation'
 
-    EVENT_API_DEFAULT_BATCH_SIZE: int = 100
-
-    EVENT_API_MAX_BATCH_SIZE: int = 1000
-
     # Maximum number of sync running simultaneously.
     MAX_ENABLED_SYNC: int = 16
 

hathor/event/resources/event.py

@@ -19,12 +19,12 @@
 
 from hathor.api_util import Resource, set_cors
 from hathor.cli.openapi_files.register import register_resource
-from hathor.conf import HathorSettings
 from hathor.event import EventManager
 from hathor.event.model.base_event import BaseEvent
 from hathor.utils.api import ErrorResponse, QueryParams, Response
 
-settings = HathorSettings()
+EVENT_API_DEFAULT_BATCH_SIZE: int = 100
+EVENT_API_MAX_BATCH_SIZE: int = 1000
 
 
 @register_resource
@@ -66,7 +66,7 @@ def render_GET(self, request):
 
 class GetEventsParams(QueryParams):
     last_ack_event_id: Optional[NonNegativeInt]
-    size: int = Field(default=settings.EVENT_API_DEFAULT_BATCH_SIZE, ge=0, le=settings.EVENT_API_MAX_BATCH_SIZE)
+    size: int = Field(default=EVENT_API_DEFAULT_BATCH_SIZE, ge=0, le=EVENT_API_MAX_BATCH_SIZE)
 
 
 class GetEventsResponse(Response):

hathor/transaction/resources/graphviz.py

@@ -20,15 +20,13 @@
 
 from hathor.api_util import Resource, get_args, parse_int, set_cors, validate_tx_hash
 from hathor.cli.openapi_files.register import register_resource
-from hathor.conf import HathorSettings
+from hathor.conf.get_settings import get_global_settings
 from hathor.graphviz import GraphvizVisualizer
 from hathor.util import json_dumpb
 
 if TYPE_CHECKING:
     from hathor.manager import HathorManager  # noqa: F401
 
-settings = HathorSettings()
-
 
 class FileFormat(Enum):
     PDF = 'pdf'
@@ -59,6 +57,7 @@ def __init__(self, manager: 'HathorManager', *, format: Union[FileFormat, str]):
         # Important to have the manager so we can know the tx_storage
         self.manager = manager
         self.format: FileFormat = FileFormat(format)
+        self._settings = get_global_settings()
 
     def render_GET(self, request):
         deferred = threads.deferToThread(self._render_GET_thread, request)
@@ -238,7 +237,7 @@ def _render_GET_thread(self, request: Request) -> bytes:
             return json_dumpb({'success': False, 'message': message})
 
         graph_type = args[b'graph_type'][0].decode('utf-8')
-        max_level = parse_int(args[b'max_level'][0], cap=settings.MAX_GRAPH_LEVEL)
+        max_level = parse_int(args[b'max_level'][0], cap=self._settings.MAX_GRAPH_LEVEL)
         tx = tx_storage.get_transaction(bytes.fromhex(tx_hex))
 
         graphviz = GraphvizVisualizer(tx_storage)
@@ -319,7 +318,7 @@ def _render_GET_thread(self, request: Request) -> bytes:
                     'name': 'max_level',
                     'in': 'query',
                     'description': ('How many levels the neighbor can appear in the graph.'
-                                    'Max level is {}'.format(settings.MAX_GRAPH_LEVEL)),
+                                    'Max level is 3'),
                     'required': True,
                     'schema': {
                         'type': 'int'

tests/resources/wallet/test_search_address.py

@@ -1,6 +1,5 @@
 from twisted.internet.defer import inlineCallbacks
 
-from hathor.conf import HathorSettings
 from hathor.crypto.util import decode_address
 from hathor.simulator.utils import add_new_blocks
 from hathor.transaction.scripts import parse_address_script
@@ -9,8 +8,6 @@
 from tests.resources.base_resource import StubSite, _BaseResourceTest
 from tests.utils import add_blocks_unlock_reward, create_tokens
 
-settings = HathorSettings()
-
 
 class BaseSearchAddressTest(_BaseResourceTest._ResourceTest):
     __test__ = False
@@ -108,12 +105,12 @@ def test_address_balance(self):
         data = response.json_value()
         self.assertTrue(data['success'])
         # Genesis - token deposit + blocks mined
-        HTR_value = settings.GENESIS_TOKENS - 1 + (settings.INITIAL_TOKENS_PER_BLOCK * 5)
+        HTR_value = self._settings.GENESIS_TOKENS - 1 + (self._settings.INITIAL_TOKENS_PER_BLOCK * 5)
         self.assertEqual(data['total_transactions'], 6)  # 5 blocks mined + token creation tx
-        self.assertIn(settings.HATHOR_TOKEN_UID.hex(), data['tokens_data'])
+        self.assertIn(self._settings.HATHOR_TOKEN_UID.hex(), data['tokens_data'])
         self.assertIn(self.token_uid.hex(), data['tokens_data'])
-        self.assertEqual(HTR_value, data['tokens_data'][settings.HATHOR_TOKEN_UID.hex()]['received'])
-        self.assertEqual(0, data['tokens_data'][settings.HATHOR_TOKEN_UID.hex()]['spent'])
+        self.assertEqual(HTR_value, data['tokens_data'][self._settings.HATHOR_TOKEN_UID.hex()]['received'])
+        self.assertEqual(0, data['tokens_data'][self._settings.HATHOR_TOKEN_UID.hex()]['spent'])
         self.assertEqual(100, data['tokens_data'][self.token_uid.hex()]['received'])
         self.assertEqual(0, data['tokens_data'][self.token_uid.hex()]['spent'])
 

tests/resources/wallet/test_thin_wallet.py

@@ -2,7 +2,6 @@
 
 from twisted.internet.defer import inlineCallbacks
 
-from hathor.conf import HathorSettings
 from hathor.crypto.util import decode_address
 from hathor.simulator.utils import add_new_blocks
 from hathor.transaction import Transaction, TxInput, TxOutput
@@ -17,8 +16,6 @@
 from tests.resources.base_resource import StubSite, TestDummyRequest, _BaseResourceTest
 from tests.utils import add_blocks_unlock_reward, add_new_tx, create_tokens
 
-settings = HathorSettings()
-
 
 class BaseSendTokensTest(_BaseResourceTest._ResourceTest):
     __test__ = False
@@ -44,7 +41,7 @@ def test_post(self):
         add_blocks_unlock_reward(self.manager)
         blocks_tokens = [sum(txout.value for txout in blk.outputs) for blk in blocks]
 
-        self.assertEqual(self.manager.wallet.balance[settings.HATHOR_TOKEN_UID].available, sum(blocks_tokens))
+        self.assertEqual(self.manager.wallet.balance[self._settings.HATHOR_TOKEN_UID].available, sum(blocks_tokens))
 
         # Options
         yield self.web.options('thin_wallet/send_tokens')
@@ -116,7 +113,10 @@ def test_post(self):
         self.clock.advance(5)
 
         # Check if tokens were really sent
-        self.assertEqual(self.manager.wallet.balance[settings.HATHOR_TOKEN_UID].available, sum(blocks_tokens[:-1]))
+        self.assertEqual(
+            self.manager.wallet.balance[self._settings.HATHOR_TOKEN_UID].available,
+            sum(blocks_tokens[:-1])
+        )
 
         response_history = yield self.web_address_history.get(
             'thin_wallet/address_history', {
@@ -151,7 +151,7 @@ def test_post(self):
 #
 #        # Making pow threads full
 #        deferreds = []
-#        for x in range(settings.MAX_POW_THREADS):
+#        for x in range(self._settings.MAX_POW_THREADS):
 #            d = self.web.post('thin_wallet/send_tokens', {'tx_hex': get_new_tx_struct(50)})
 #            d.addErrback(lambda err: None)
 #            deferreds.append(d)
@@ -208,7 +208,7 @@ def test_history_paginate(self):
 
         new_blocks = add_new_blocks(
             self.manager,
-            settings.MAX_TX_ADDRESSES_HISTORY,
+            self._settings.MAX_TX_ADDRESSES_HISTORY,
             advance_clock=1,
             address=address_bytes
         )
@@ -222,16 +222,16 @@ def test_history_paginate(self):
         )
 
         response_data = response_history.json_value()
-        self.assertEqual(len(response_data['history']), settings.MAX_TX_ADDRESSES_HISTORY)
+        self.assertEqual(len(response_data['history']), self._settings.MAX_TX_ADDRESSES_HISTORY)
         self.assertTrue(response_data['has_more'])
         self.assertEqual(response_data['first_address'], address)
 
         # Test paginate with big txs
-        tx_count = math.ceil(settings.MAX_INPUTS_OUTPUTS_ADDRESS_HISTORY / settings.MAX_NUM_INPUTS)
+        tx_count = math.ceil(self._settings.MAX_INPUTS_OUTPUTS_ADDRESS_HISTORY / self._settings.MAX_NUM_INPUTS)
         blocks.extend(new_blocks)
         new_blocks = add_new_blocks(
             self.manager,
-            tx_count*settings.MAX_NUM_INPUTS - len(blocks),
+            tx_count*self._settings.MAX_NUM_INPUTS - len(blocks),
             advance_clock=1,
             address=address_bytes
         )
@@ -240,8 +240,8 @@ def test_history_paginate(self):
         add_blocks_unlock_reward(self.manager)
 
         for i in range(tx_count):
-            start_index = i*settings.MAX_NUM_INPUTS
-            end_index = start_index + settings.MAX_NUM_INPUTS
+            start_index = i*self._settings.MAX_NUM_INPUTS
+            end_index = start_index + self._settings.MAX_NUM_INPUTS
             amount = sum([b.outputs[0].value for b in blocks[start_index:end_index]])
             add_new_tx(self.manager, random_address, amount, advance_clock=1)
 

tests/tx/test_blockchain.py

@@ -1,15 +1,12 @@
 from itertools import chain
 
-from hathor.conf import HathorSettings
 from hathor.daa import DifficultyAdjustmentAlgorithm, TestMode
 from hathor.simulator.utils import add_new_blocks
 from hathor.transaction import sum_weights
 from hathor.transaction.storage import TransactionMemoryStorage
 from tests import unittest
 from tests.utils import add_new_transactions
 
-settings = HathorSettings()
-
 
 class BaseBlockchainTestCase(unittest.TestCase):
     __test__ = False
@@ -31,7 +28,7 @@ def setUp(self):
         self.genesis = self.tx_storage.get_all_genesis()
         self.genesis_blocks = [tx for tx in self.genesis if tx.is_block]
         self.genesis_txs = [tx for tx in self.genesis if not tx.is_block]
-        self.daa = DifficultyAdjustmentAlgorithm(settings=settings)
+        self.daa = DifficultyAdjustmentAlgorithm(settings=self._settings)
 
     def test_single_chain(self):
         """ All new blocks belong to case (i).
@@ -358,20 +355,20 @@ def test_block_height(self):
     def test_tokens_issued_per_block(self):
         manager = self.create_peer('testnet', tx_storage=self.tx_storage)
         # this test is pretty dumb in that it test every possible height until halving has long stopped
-        initial_reward = settings.INITIAL_TOKENS_PER_BLOCK
-        final_reward = settings.MINIMUM_TOKENS_PER_BLOCK
+        initial_reward = self._settings.INITIAL_TOKENS_PER_BLOCK
+        final_reward = self._settings.MINIMUM_TOKENS_PER_BLOCK
         expected_reward = initial_reward
         height = 1
         # check that there are BLOCKS_PER_HALVING with each reward, starting at the first rewardable block (height=1)
-        for _i_halving in range(0, settings.MAXIMUM_NUMBER_OF_HALVINGS):
-            for _i_block in range(0, settings.BLOCKS_PER_HALVING):
+        for _i_halving in range(0, self._settings.MAXIMUM_NUMBER_OF_HALVINGS):
+            for _i_block in range(0, self._settings.BLOCKS_PER_HALVING):
                 reward = manager.get_tokens_issued_per_block(height)
                 self.assertEqual(reward, expected_reward, f'reward at height {height}')
                 height += 1
             expected_reward /= 2
         self.assertEqual(expected_reward, final_reward)
         # check that halving stops, for at least two "halving rounds"
-        for _i_block in range(0, 2 * settings.BLOCKS_PER_HALVING):
+        for _i_block in range(0, 2 * self._settings.BLOCKS_PER_HALVING):
             reward = manager.get_tokens_issued_per_block(height)
             self.assertEqual(reward, expected_reward, f'reward at height {height}')
             height += 1
@@ -380,7 +377,7 @@ def test_block_rewards(self):
         # even dumber test that only check if manager.get_tokens_issued_per_block was used correctly for a really large
         # number of blocks, probably not worth running all the time
         manager = self.create_peer('testnet', tx_storage=self.tx_storage)
-        block_count = (settings.MAXIMUM_NUMBER_OF_HALVINGS + 1) * settings.BLOCKS_PER_HALVING
+        block_count = (self._settings.MAXIMUM_NUMBER_OF_HALVINGS + 1) * self._settings.BLOCKS_PER_HALVING
         blocks = add_new_blocks(manager, block_count, advance_clock=block_count * 30)
         for block in blocks:
             outputs = block.outputs
@@ -393,8 +390,8 @@ def test_daa_sanity(self):
         # sanity test the DAA
         manager = self.create_peer('testnet', tx_storage=self.tx_storage)
         manager.daa.TEST_MODE = TestMode.DISABLED
-        N = settings.BLOCK_DIFFICULTY_N_BLOCKS
-        T = settings.AVG_TIME_BETWEEN_BLOCKS
+        N = self._settings.BLOCK_DIFFICULTY_N_BLOCKS
+        T = self._settings.AVG_TIME_BETWEEN_BLOCKS
         manager.avg_time_between_blocks = T
         # stabilize weight on 2 and lower the minimum to 1, so it can vary around 2
         manager.min_block_weight = 2
@@ -419,52 +416,56 @@ def test_daa_sanity(self):
 
     def test_daa_weight_decay_amount(self):
         self.daa.TEST_MODE = TestMode.DISABLED
-        amount = settings.WEIGHT_DECAY_AMOUNT
+        amount = self._settings.WEIGHT_DECAY_AMOUNT
 
-        for distance in range(0, settings.WEIGHT_DECAY_ACTIVATE_DISTANCE, 10):
+        for distance in range(0, self._settings.WEIGHT_DECAY_ACTIVATE_DISTANCE, 10):
             self.assertEqual(self.daa.get_weight_decay_amount(distance), 0)
 
-        distance = settings.WEIGHT_DECAY_ACTIVATE_DISTANCE - 1
+        distance = self._settings.WEIGHT_DECAY_ACTIVATE_DISTANCE - 1
         self.assertAlmostEqual(self.daa.get_weight_decay_amount(distance), 0)
 
-        distance = settings.WEIGHT_DECAY_ACTIVATE_DISTANCE
+        distance = self._settings.WEIGHT_DECAY_ACTIVATE_DISTANCE
         for k in range(1, 11):
-            for _ in range(settings.WEIGHT_DECAY_WINDOW_SIZE):
+            for _ in range(self._settings.WEIGHT_DECAY_WINDOW_SIZE):
                 self.assertAlmostEqual(self.daa.get_weight_decay_amount(distance), k * amount)
                 distance += 1
         self.assertAlmostEqual(self.daa.get_weight_decay_amount(distance), 11 * amount)
 
     def test_daa_weight_decay_blocks(self):
         manager = self.create_peer('testnet', tx_storage=self.tx_storage)
         manager.daa.TEST_MODE = TestMode.DISABLED
-        amount = settings.WEIGHT_DECAY_AMOUNT
+        amount = self._settings.WEIGHT_DECAY_AMOUNT
 
-        manager.daa.AVG_TIME_BETWEEN_BLOCKS = settings.AVG_TIME_BETWEEN_BLOCKS
-        manager.daa.MIN_BLOCK_WEIGHT = 2 + 2 * settings.WEIGHT_DECAY_AMOUNT
-        add_new_blocks(manager, 2 * settings.BLOCK_DIFFICULTY_N_BLOCKS, advance_clock=settings.AVG_TIME_BETWEEN_BLOCKS)
+        manager.daa.AVG_TIME_BETWEEN_BLOCKS = self._settings.AVG_TIME_BETWEEN_BLOCKS
+        manager.daa.MIN_BLOCK_WEIGHT = 2 + 2 * self._settings.WEIGHT_DECAY_AMOUNT
+        add_new_blocks(
+            manager,
+            2 * self._settings.BLOCK_DIFFICULTY_N_BLOCKS,
+            advance_clock=self._settings.AVG_TIME_BETWEEN_BLOCKS
+        )
 
         manager.daa.MIN_BLOCK_WEIGHT = 1
         base_weight = manager.generate_mining_block().weight
         self.assertGreater(base_weight, manager.daa.MIN_BLOCK_WEIGHT)
 
-        add_new_blocks(manager, 20, advance_clock=settings.AVG_TIME_BETWEEN_BLOCKS)
+        add_new_blocks(manager, 20, advance_clock=self._settings.AVG_TIME_BETWEEN_BLOCKS)
 
-        dt = settings.AVG_TIME_BETWEEN_BLOCKS  # the latest call to add_new_blocks will advance the clock
-        while dt < settings.WEIGHT_DECAY_ACTIVATE_DISTANCE:
+        dt = self._settings.AVG_TIME_BETWEEN_BLOCKS  # the latest call to add_new_blocks will advance the clock
+        while dt < self._settings.WEIGHT_DECAY_ACTIVATE_DISTANCE:
             weight = manager.generate_mining_block().weight
             self.assertAlmostEqual(weight, base_weight)
             manager.reactor.advance(1)
             dt += 1
 
         dt = 0
-        while dt < settings.WEIGHT_DECAY_WINDOW_SIZE:
+        while dt < self._settings.WEIGHT_DECAY_WINDOW_SIZE:
             weight = manager.generate_mining_block().weight
             self.assertAlmostEqual(weight, base_weight - amount)
             manager.reactor.advance(1)
             dt += 1
 
         dt = 0
-        while dt < settings.WEIGHT_DECAY_WINDOW_SIZE:
+        while dt < self._settings.WEIGHT_DECAY_WINDOW_SIZE:
             weight = manager.generate_mining_block().weight
             self.assertAlmostEqual(weight, base_weight - 2*amount)
             manager.reactor.advance(1)