Ruff typing from this morning. WIP

1 files changed, 126 insertions, 82 deletions

diff --git a/tests/managers/thl/test_ledger/test_lm_tx_locks.py b/tests/managers/thl/test_ledger/test_lm_tx_locks.py
index 020b74a..9158e15 100644
--- a/tests/managers/thl/test_ledger/test_lm_tx_locks.py
+++ b/tests/managers/thl/test_ledger/test_lm_tx_locks.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 from collections.abc import Callable
 from datetime import UTC, datetime, timedelta
@@ -5,6 +7,7 @@ from decimal import Decimal
 
 import pytest
 
+from generalresearch.currency import LedgerCurrency
 from generalresearch.managers.thl.ledger_manager.conditions import (
     generate_condition_mp_payment,
 )
@@ -13,8 +16,11 @@ from generalresearch.managers.thl.ledger_manager.exceptions import (
     LedgerTransactionCreateLockError,
     LedgerTransactionFlagAlreadyExistsError,
 )
+from generalresearch.managers.thl.ledger_manager.ledger import LedgerManager
+from generalresearch.managers.thl.ledger_manager.thl_ledger import ThlLedgerManager
 from generalresearch.models import Source
 from generalresearch.models.thl.ledger import LedgerTransaction
+from generalresearch.models.thl.product import Product
 from generalresearch.models.thl.session import (
     Session,
     Status,
@@ -31,17 +37,17 @@ class TestLedgerLocks:
 
     def test_a(
         self,
-        user_factory,
-        session_factory,
-        product_user_wallet_no,
-        create_main_accounts,
+        user_factory: Callable[..., User],
+        session_factory: Callable[..., Session],
+        product_user_wallet_no: Product,
+        create_main_accounts: Callable[..., None],
         caplog,
-        thl_lm,
-        lm,
-        utc_hour_ago,
-        currency,
-        wall_factory,
-        delete_ledger_db,
+        thl_ledger_manager: ThlLedgerManager,
+        ledger_manager: LedgerManager,
+        utc_hour_ago: datetime,
+        currency: LedgerCurrency,
+        wall_factory: Callable[..., Wall],
+        delete_ledger_db: Callable[..., None],
     ):
         """
         TODO: This whole test is confusing a I don't really understand.
@@ -61,12 +67,16 @@ class TestLedgerLocks:
 
         # A User does a Wall Completion in Session=1
         w1 = s1.wall_events[0]
-        tx = thl_lm.create_tx_task_complete(wall=w1, user=user, created=w1.started)
+        tx = thl_ledger_manager.create_tx_task_complete(
+            wall=w1, user=user, created=w1.started
+        )
         assert isinstance(tx, LedgerTransaction)
 
         # A User does another Wall Completion in Session=1
         w2 = s1.wall_events[1]
-        tx = thl_lm.create_tx_task_complete(wall=w2, user=user, created=w2.started)
+        tx = thl_ledger_manager.create_tx_task_complete(
+            wall=w2, user=user, created=w2.started
+        )
         assert isinstance(tx, LedgerTransaction)
 
         # That first Wall Complete was "adjusted" to instead be marked
@@ -76,7 +86,7 @@ class TestLedgerLocks:
             adjusted_cpi=0,
             adjusted_timestamp=utc_hour_ago + timedelta(hours=1),
         )
-        tx = thl_lm.create_tx_task_adjustment(wall=w1, user=user)
+        tx = thl_ledger_manager.create_tx_task_adjustment(wall=w1, user=user)
         assert isinstance(tx, LedgerTransaction)
 
         # A User does another! Wall Completion in Session=1; however, we
@@ -85,55 +95,57 @@ class TestLedgerLocks:
 
         # Make sure we clear any flags/locks first
         lock_key = f"{currency.value}:thl_wall:{w3.uuid}"
-        lock_name = f"{lm.cache_prefix}:transaction_lock:{lock_key}"
-        flag_name = f"{lm.cache_prefix}:transaction_flag:{lock_key}"
-        lm.redis_client.delete(lock_name)
-        lm.redis_client.delete(flag_name)
+        lock_name = f"{ledger_manager.cache_prefix}:transaction_lock:{lock_key}"
+        flag_name = f"{ledger_manager.cache_prefix}:transaction_flag:{lock_key}"
+        ledger_manager.redis_client.delete(lock_name)
+        ledger_manager.redis_client.delete(flag_name)
 
         # Despite the
         f1 = generate_condition_mp_payment(wall=w1)
         f2 = generate_condition_mp_payment(wall=w2)
         f3 = generate_condition_mp_payment(wall=w3)
-        assert f1(lm=lm) is False
-        assert f2(lm=lm) is False
-        assert f3(lm=lm) is True
+        assert f1(ledger_manager) is False
+        assert f2(lm=ledger_manager) is False
+        assert f3(lm=ledger_manager) is True
 
         condition = f3
-        create_tx_func = lambda: thl_lm.create_tx_task_complete_(wall=w3, user=user)
+        create_tx_func = lambda: thl_ledger_manager.create_tx_task_complete_(
+            wall=w3, user=user
+        )
         assert isinstance(create_tx_func, Callable)
-        assert f3(lm) is True
+        assert f3(ledger_manager) is True
 
-        lm.redis_client.delete(flag_name)
-        lm.redis_client.delete(lock_name)
+        ledger_manager.redis_client.delete(flag_name)
+        ledger_manager.redis_client.delete(lock_name)
 
-        tx = thl_lm.create_tx_protected(
+        tx = thl_ledger_manager.create_tx_protected(
             lock_key=lock_key, condition=condition, create_tx_func=create_tx_func
         )
-        assert f3(lm) is False
+        assert f3(ledger_manager) is False
 
         # purposely hold the lock open
         tx = None
-        lm.redis_client.set(lock_name, "1")
+        ledger_manager.redis_client.set(lock_name, "1")
         with caplog.at_level(logging.ERROR):
             with pytest.raises(expected_exception=LedgerTransactionCreateLockError):
-                tx = thl_lm.create_tx_protected(
+                tx = thl_ledger_manager.create_tx_protected(
                     lock_key=lock_key,
                     condition=condition,
                     create_tx_func=create_tx_func,
                 )
                 assert tx is None
         assert "Unable to acquire lock within the time specified" in caplog.text
-        lm.redis_client.delete(lock_name)
+        ledger_manager.redis_client.delete(lock_name)
 
     def test_locking(
         self,
-        user_factory,
-        product_user_wallet_no,
-        create_main_accounts,
-        delete_ledger_db,
+        user_factory: Callable[..., User],
+        product_user_wallet_no: Product,
+        create_main_accounts: Callable[..., None],
+        delete_ledger_db: Callable[..., None],
         caplog,
-        thl_lm,
-        lm,
+        thl_ledger_manager: ThlLedgerManager,
+        ledger_manager: LedgerManager,
     ):
         delete_ledger_db()
         create_main_accounts()
@@ -154,7 +166,9 @@ class TestLedgerLocks:
             started=now,
             finished=now + timedelta(seconds=1),
         )
-        thl_lm.create_tx_task_complete(wall=wall1, user=user, created=wall1.started)
+        thl_ledger_manager.create_tx_task_complete(
+            wall=wall1, user=user, created=wall1.started
+        )
 
         # A User does a Wall complete on Session.id=1 and the transaction is
         #   logged to the ledger
@@ -169,7 +183,9 @@ class TestLedgerLocks:
             started=now,
             finished=now + timedelta(seconds=1),
         )
-        thl_lm.create_tx_task_complete(wall=wall2, user=user, created=wall2.started)
+        thl_ledger_manager.create_tx_task_complete(
+            wall=wall2, user=user, created=wall2.started
+        )
 
         # An hour later, the first wall complete is adjusted to a Failure and
         #   it's tracked in the ledger
@@ -178,7 +194,7 @@ class TestLedgerLocks:
             adjusted_cpi=0,
             adjusted_timestamp=now + timedelta(hours=1),
         )
-        thl_lm.create_tx_task_adjustment(wall=wall1, user=user)
+        thl_ledger_manager.create_tx_task_adjustment(wall=wall1, user=user)
 
         # A User does a Wall complete on Session.id=1 and the transaction
         #   IS NOT logged to the ledger
@@ -195,52 +211,52 @@ class TestLedgerLocks:
             uuid="867a282d8b4d40d2a2093d75b802b629",
         )
 
-        revenue_account = thl_lm.get_account_task_complete_revenue()
-        assert 0 == thl_lm.get_account_filtered_balance(
+        revenue_account = thl_ledger_manager.get_account_task_complete_revenue()
+        assert 0 == thl_ledger_manager.get_account_filtered_balance(
             account=revenue_account,
             metadata_key="thl_wall",
             metadata_value=wall3.uuid,
         )
         # Make sure we clear any flags/locks first
         lock_key = f"test:thl_wall:{wall3.uuid}"
-        lock_name = f"{lm.cache_prefix}:transaction_lock:{lock_key}"
-        flag_name = f"{lm.cache_prefix}:transaction_flag:{lock_key}"
-        lm.redis_client.delete(lock_name)
-        lm.redis_client.delete(flag_name)
+        lock_name = f"{ledger_manager.cache_prefix}:transaction_lock:{lock_key}"
+        flag_name = f"{ledger_manager.cache_prefix}:transaction_flag:{lock_key}"
+        ledger_manager.redis_client.delete(lock_name)
+        ledger_manager.redis_client.delete(flag_name)
 
         # Purposely hold the lock open
-        lm.redis_client.set(name=lock_name, value="1")
+        ledger_manager.redis_client.set(name=lock_name, value="1")
         with caplog.at_level(logging.DEBUG):
             with pytest.raises(expected_exception=LedgerTransactionCreateLockError):
-                tx = thl_lm.create_tx_task_complete(
+                tx = thl_ledger_manager.create_tx_task_complete(
                     wall=wall3, user=user, created=wall3.started
                 )
                 assert isinstance(tx, LedgerTransaction)
         assert "Unable to acquire lock within the time specified" in caplog.text
 
         # Release the lock
-        lm.redis_client.delete(lock_name)
+        ledger_manager.redis_client.delete(lock_name)
 
         # Set the redis flag to indicate it has been run
-        lm.redis_client.set(flag_name, "1")
+        ledger_manager.redis_client.set(flag_name, "1")
         # with self.assertLogs(logger=logger, level=logging.DEBUG) as cm2:
         with pytest.raises(expected_exception=LedgerTransactionFlagAlreadyExistsError):
-            tx = thl_lm.create_tx_task_complete(
+            tx = thl_ledger_manager.create_tx_task_complete(
                 wall=wall3, user=user, created=wall3.started
             )
         # self.assertIn("entered_lock: True, flag_set: True", cm2.output[0])
 
         # Unset the flag
-        lm.redis_client.delete(flag_name)
+        ledger_manager.redis_client.delete(flag_name)
 
-        assert 0 == lm.get_account_filtered_balance(
+        assert 0 == ledger_manager.get_account_filtered_balance(
             account=revenue_account,
             metadata_key="thl_wall",
             metadata_value=wall3.uuid,
         )
 
         # Now actually run it
-        tx = thl_lm.create_tx_task_complete(
+        tx = thl_ledger_manager.create_tx_task_complete(
             wall=wall3, user=user, created=wall3.started
         )
         assert tx is not None
@@ -249,29 +265,34 @@ class TestLedgerLocks:
         # Confirm the Exception inheritance works
         tx = None
         with pytest.raises(expected_exception=LedgerTransactionCreateError):
-            tx = thl_lm.create_tx_task_complete(
+            tx = thl_ledger_manager.create_tx_task_complete(
                 wall=wall3, user=user, created=wall3.started
             )
         assert tx is None
 
         # clear the redis flag, it should query the db
-        assert lm.redis_client.get(flag_name) is not None
-        lm.redis_client.delete(flag_name)
-        assert lm.redis_client.get(flag_name) is None
+        assert ledger_manager.redis_client.get(flag_name) is not None
+        ledger_manager.redis_client.delete(flag_name)
+        assert ledger_manager.redis_client.get(flag_name) is None
 
         with pytest.raises(expected_exception=LedgerTransactionCreateError):
-            tx = thl_lm.create_tx_task_complete(
+            tx = thl_ledger_manager.create_tx_task_complete(
                 wall=wall3, user=user, created=wall3.started
             )
 
-        assert 400 == thl_lm.get_account_filtered_balance(
+        assert 400 == thl_ledger_manager.get_account_filtered_balance(
             account=revenue_account,
             metadata_key="thl_wall",
             metadata_value=wall3.uuid,
         )
 
     def test_bp_payment_without_locks(
-        self, user_factory, product_user_wallet_no, create_main_accounts, thl_lm, lm
+        self,
+        user_factory: Callable[..., User],
+        product_user_wallet_no: Product,
+        create_main_accounts: Callable[..., None],
+        thl_ledger_manager: ThlLedgerManager,
+        ledger_manager: LedgerManager,
     ):
         user: User = user_factory(product=product_user_wallet_no)
         wall1 = Wall(
@@ -286,29 +307,42 @@ class TestLedgerLocks:
             finished=datetime.now(UTC) + timedelta(seconds=1),
         )
 
-        thl_lm.create_tx_task_complete(wall=wall1, user=user, created=wall1.started)
+        thl_ledger_manager.create_tx_task_complete(
+            wall=wall1, user=user, created=wall1.started
+        )
         session = Session(started=wall1.started, user=user, wall_events=[wall1])
         status, status_code_1 = session.determine_session_status()
         thl_net, commission_amount, bp_pay, user_pay = session.determine_payments()
         session.update(
-            status=status, status_code_1=status_code_1, finished=session.started + timedelta(minutes=10), payout=bp_pay, user_payout=user_pay
+            status=status,
+            status_code_1=status_code_1,
+            finished=session.started + timedelta(minutes=10),
+            payout=bp_pay,
+            user_payout=user_pay,
         )
         print(thl_net, commission_amount, bp_pay, user_pay)
 
         # Run it 3 times without any checks, and it gets made three times!
-        thl_lm.create_tx_bp_payment(session=session, created=wall1.started)
-        thl_lm.create_tx_bp_payment_(session=session, created=wall1.started)
-        thl_lm.create_tx_bp_payment_(session=session, created=wall1.started)
+        thl_ledger_manager.create_tx_bp_payment(session=session, created=wall1.started)
+        thl_ledger_manager.create_tx_bp_payment_(session=session, created=wall1.started)
+        thl_ledger_manager.create_tx_bp_payment_(session=session, created=wall1.started)
 
-        bp_wallet = thl_lm.get_account_or_create_bp_wallet(product=user.product)
-        assert 48 * 3 == lm.get_account_balance(account=bp_wallet)
-        assert 48 * 3 == thl_lm.get_account_filtered_balance(
+        bp_wallet = thl_ledger_manager.get_account_or_create_bp_wallet(
+            product=user.product
+        )
+        assert 48 * 3 == ledger_manager.get_account_balance(account=bp_wallet)
+        assert 48 * 3 == thl_ledger_manager.get_account_filtered_balance(
             account=bp_wallet, metadata_key="thl_session", metadata_value=session.uuid
         )
-        assert lm.check_ledger_balanced()
+        assert ledger_manager.check_ledger_balanced()
 
     def test_bp_payment_with_locks(
-        self, user_factory, product_user_wallet_no, create_main_accounts, thl_lm, lm
+        self,
+        user_factory: Callable[..., User],
+        product_user_wallet_no: Product,
+        create_main_accounts: Callable[..., None],
+        thl_ledger_manager: ThlLedgerManager,
+        ledger_manager: LedgerManager,
     ):
         user: User = user_factory(product=product_user_wallet_no)
 
@@ -324,35 +358,45 @@ class TestLedgerLocks:
             finished=datetime.now(UTC) + timedelta(seconds=1),
         )
 
-        thl_lm.create_tx_task_complete(wall1, user, created=wall1.started)
+        thl_ledger_manager.create_tx_task_complete(wall1, user, created=wall1.started)
         session = Session(started=wall1.started, user=user, wall_events=[wall1])
         status, status_code_1 = session.determine_session_status()
         thl_net, commission_amount, bp_pay, user_pay = session.determine_payments()
         session.update(
-            status=status, status_code_1=status_code_1, finished=session.started + timedelta(minutes=10), payout=bp_pay, user_payout=user_pay
+            status=status,
+            status_code_1=status_code_1,
+            finished=session.started + timedelta(minutes=10),
+            payout=bp_pay,
+            user_payout=user_pay,
         )
         print(thl_net, commission_amount, bp_pay, user_pay)
 
         # Make sure we clear any flags/locks first
         lock_key = f"test:thl_wall:{wall1.uuid}"
-        lock_name = f"{lm.cache_prefix}:transaction_lock:{lock_key}"
-        flag_name = f"{lm.cache_prefix}:transaction_flag:{lock_key}"
-        lm.redis_client.delete(lock_name)
-        lm.redis_client.delete(flag_name)
+        lock_name = f"{ledger_manager.cache_prefix}:transaction_lock:{lock_key}"
+        flag_name = f"{ledger_manager.cache_prefix}:transaction_flag:{lock_key}"
+        ledger_manager.redis_client.delete(lock_name)
+        ledger_manager.redis_client.delete(flag_name)
 
         # Run it 3 times with check, and it gets made once!
-        thl_lm.create_tx_bp_payment(session=session, created=wall1.started)
+        thl_ledger_manager.create_tx_bp_payment(session=session, created=wall1.started)
         with pytest.raises(expected_exception=LedgerTransactionCreateError):
-            thl_lm.create_tx_bp_payment(session=session, created=wall1.started)
+            thl_ledger_manager.create_tx_bp_payment(
+                session=session, created=wall1.started
+            )
 
         with pytest.raises(expected_exception=LedgerTransactionCreateError):
-            thl_lm.create_tx_bp_payment(session=session, created=wall1.started)
+            thl_ledger_manager.create_tx_bp_payment(
+                session=session, created=wall1.started
+            )
 
-        bp_wallet = thl_lm.get_account_or_create_bp_wallet(product=user.product)
-        assert 48 == thl_lm.get_account_balance(bp_wallet)
-        assert 48 == thl_lm.get_account_filtered_balance(
+        bp_wallet = thl_ledger_manager.get_account_or_create_bp_wallet(
+            product=user.product
+        )
+        assert 48 == thl_ledger_manager.get_account_balance(bp_wallet)
+        assert 48 == thl_ledger_manager.get_account_filtered_balance(
             account=bp_wallet,
             metadata_key="thl_session",
             metadata_value=session.uuid,
         )
-        assert lm.check_ledger_balanced()
+        assert ledger_manager.check_ledger_balanced()