Merge branch 'master' into dev-greg

4 files changed, 898 insertions, 835 deletions

diff --git a/tests/models/gr/test_authentication.py b/tests/models/gr/test_authentication.py
index 6c84a5d..21e07a4 100644
--- a/tests/models/gr/test_authentication.py
+++ b/tests/models/gr/test_authentication.py
@@ -1,21 +1,30 @@
+from __future__ import annotations
+
 import binascii
 import json
 import os
-from datetime import datetime, timezone
+from collections.abc import Callable
+from datetime import UTC, datetime
 from random import randint
-from typing import Callable
+from typing import TYPE_CHECKING
 from uuid import uuid4
 
 import pytest
 
-from generalresearch.models.gr.authentication import GRUser
-from generalresearch.models.gr.team import Membership, Team
+from generalresearch.models.gr.authentication import Claims, GRToken, GRUser
+from generalresearch.models.gr.team import Team
+
+if TYPE_CHECKING:
+    from generalresearch.models.gr.business import Business
+    from generalresearch.models.gr.team import Membership
+    from generalresearch.models.thl.product import Product
+    from generalresearch.pg_helper import PostgresConfig
+    from generalresearch.redis_helper import RedisConfig
 
 SSO_ISSUER = ""
 
 
 class TestGRUser:
-
     def test_init(self, gr_user: GRUser):
 
         assert isinstance(gr_user, GRUser)
@@ -29,7 +38,13 @@ class TestGRUser:
     def test_businesses(self):
         pass
 
-    def test_teams(self, gr_user: GRUser, membership, gr_db, gr_redis_config):
+    def test_teams(
+        self,
+        gr_user: GRUser,
+        gr_membership: Membership,
+        gr_db: PostgresConfig,
+        gr_redis_config: RedisConfig,
+    ):
 
         assert gr_user.teams is None
 
@@ -41,18 +56,18 @@ class TestGRUser:
 
     def test_prefetch_team_duplicates(
         self,
-        gr_user_token,
+        gr_user_token: GRToken,
         gr_user: GRUser,
-        membership: Membership,
-        product_factory,
-        membership_factory,
-        team: Team,
-        thl_web_rr,
-        gr_redis_config,
-        gr_db,
+        gr_membership: Membership,
+        product_factory: Callable[..., Product],
+        gr_membership_factory: Callable[..., Membership],
+        gr_team: Team,
+        thl_web_rr: PostgresConfig,
+        gr_redis_config: RedisConfig,
+        gr_db: PostgresConfig,
     ):
-        product_factory(team=team)
-        membership_factory(team=team, gr_user=gr_user)
+        product_factory(team=gr_team)
+        gr_membership_factory(gr_team=gr_team, gr_user=gr_user)
 
         gr_user.prefetch_teams(
             pg_config=gr_db,
@@ -64,12 +79,12 @@ class TestGRUser:
     def test_products(
         self,
         gr_user: GRUser,
-        product_factory,
-        team: Team,
-        membership: Membership,
-        gr_db,
-        thl_web_rr,
-        gr_redis_config,
+        product_factory: Callable[..., Product],
+        gr_team: Team,
+        gr_membership: Membership,
+        gr_db: PostgresConfig,
+        thl_web_rr: PostgresConfig,
+        gr_redis_config: RedisConfig,
     ):
         from generalresearch.models.thl.product import Product
 
@@ -77,13 +92,15 @@ class TestGRUser:
 
         # Create a new Team membership, and then create a Product that
         #    is  part of that team
-        membership.prefetch_team(pg_config=gr_db, redis_config=gr_redis_config)
-        p: Product = product_factory(team=team)
+        gr_membership.prefetch_team(pg_config=gr_db, redis_config=gr_redis_config)
+        assert isinstance(gr_membership.team, Team)
+
+        p: Product = product_factory(team=gr_team)
         assert p.id_int
-        assert team.uuid == membership.team.uuid
-        assert p.team_id == team.uuid
-        assert p.team_uuid == membership.team.uuid
-        assert gr_user.id == membership.user_id
+        assert gr_team.uuid == gr_membership.team.uuid
+        assert p.team_id == gr_team.uuid
+        assert p.team_uuid == gr_membership.team.uuid
+        assert gr_user.id == gr_membership.user_id
 
         gr_user.prefetch_products(
             pg_config=gr_db,
@@ -96,8 +113,7 @@ class TestGRUser:
 
 
 class TestGRUserMethods:
-
-    def test_cache_key(self, gr_user, gr_redis):
+    def test_cache_key(self, gr_user: GRUser):
         assert isinstance(gr_user.cache_key, str)
         assert ":" in gr_user.cache_key
         assert str(gr_user.id) in gr_user.cache_key
@@ -105,14 +121,13 @@ class TestGRUserMethods:
     def test_to_redis(
         self,
         gr_user: GRUser,
-        gr_redis,
-        team: Team,
-        business,
-        product_factory,
-        membership_factory: Callable[Membership],
+        gr_team: Team,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        gr_membership_factory: Callable[..., Membership],
     ):
-        product_factory(team=team, business=business)
-        membership_factory(team=team, gr_user=gr_user)
+        product_factory(team=gr_team, business=gr_business)
+        gr_membership_factory(gr_team=gr_team, gr_user=gr_user)
 
         res = gr_user.to_redis()
         assert isinstance(res, str)
@@ -125,49 +140,50 @@ class TestGRUserMethods:
     def test_set_cache(
         self,
         gr_user: GRUser,
-        gr_user_token,
-        gr_redis,
-        gr_db,
-        thl_web_rr,
-        gr_redis_config,
+        gr_db: PostgresConfig,
+        thl_web_rr: PostgresConfig,
+        gr_redis_config: RedisConfig,
     ):
-        assert gr_redis.get(name=gr_user.cache_key) is None
-        assert gr_redis.get(name=f"{gr_user.cache_key}:team_uuids") is None
-        assert gr_redis.get(name=f"{gr_user.cache_key}:business_uuids") is None
-        assert gr_redis.get(name=f"{gr_user.cache_key}:product_uuids") is None
+
+        client = gr_redis_config.create_redis_client()
+
+        assert client.get(name=gr_user.cache_key) is None
+        assert client.get(name=f"{gr_user.cache_key}:team_uuids") is None
+        assert client.get(name=f"{gr_user.cache_key}:business_uuids") is None
+        assert client.get(name=f"{gr_user.cache_key}:product_uuids") is None
 
         gr_user.set_cache(
             pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
         )
 
-        assert gr_redis.get(name=gr_user.cache_key) is not None
-        assert gr_redis.get(name=f"{gr_user.cache_key}:team_uuids") is not None
-        assert gr_redis.get(name=f"{gr_user.cache_key}:business_uuids") is not None
-        assert gr_redis.get(name=f"{gr_user.cache_key}:product_uuids") is not None
+        assert client.get(name=gr_user.cache_key) is not None
+        assert client.get(name=f"{gr_user.cache_key}:team_uuids") is not None
+        assert client.get(name=f"{gr_user.cache_key}:business_uuids") is not None
+        assert client.get(name=f"{gr_user.cache_key}:product_uuids") is not None
 
     def test_set_cache_gr_user(
         self,
         gr_user: GRUser,
-        gr_user_token,
-        gr_redis,
-        gr_redis_config,
-        gr_db,
-        thl_web_rr,
-        product_factory,
-        team,
-        membership_factory,
-        thl_redis_config,
+        gr_redis_config: RedisConfig,
+        gr_db: PostgresConfig,
+        thl_web_rr: PostgresConfig,
+        product_factory: Callable[..., Product],
+        gr_team: Team,
+        gr_membership_factory: Callable[..., Membership],
+        thl_redis_config: RedisConfig,
     ):
         from generalresearch.models.gr.authentication import GRUser
 
-        p1 = product_factory(team=team)
-        membership_factory(team=team, gr_user=gr_user)
+        client = gr_redis_config.create_redis_client()
+
+        p1 = product_factory(team=gr_team)
+        gr_membership_factory(gr_team=gr_team, gr_user=gr_user)
 
         gr_user.set_cache(
             pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
         )
 
-        res: str = gr_redis.get(name=gr_user.cache_key)
+        res: str = client.get(name=gr_user.cache_key)
         gru2 = GRUser.from_redis(res)
 
         assert gr_user.model_dump_json(
@@ -183,22 +199,21 @@ class TestGRUserMethods:
 
     def test_set_cache_team_uuids(
         self,
-        gr_user,
-        membership,
-        gr_user_token,
-        gr_redis,
-        gr_db,
-        thl_web_rr,
-        product_factory,
-        team,
-        gr_redis_config,
+        gr_user: GRUser,
+        gr_db: PostgresConfig,
+        thl_web_rr: PostgresConfig,
+        product_factory: Callable[..., Product],
+        gr_team: Team,
+        gr_redis_config: RedisConfig,
+        gr_membership,
     ):
-        product_factory(team=team)
+        product_factory(team=gr_team)
+        client = gr_redis_config.create_redis_client()
 
         gr_user.set_cache(
             pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
         )
-        res = json.loads(gr_redis.get(name=f"{gr_user.cache_key}:team_uuids"))
+        res = json.loads(client.get(name=f"{gr_user.cache_key}:team_uuids"))
         assert len(res) == 1
         assert gr_user.team_uuids == res
 
@@ -206,81 +221,74 @@ class TestGRUserMethods:
     def test_set_cache_business_uuids(
         self,
         gr_user: GRUser,
-        gr_redis,
-        gr_db,
-        thl_web_rr,
-        product_factory,
-        business,
-        team,
-        gr_redis_config,
+        gr_db: PostgresConfig,
+        thl_web_rr: PostgresConfig,
+        product_factory: Callable[..., Product],
+        gr_business: Business,
+        gr_team: Team,
+        gr_redis_config: RedisConfig,
     ):
-        product_factory(team=team, business=business)
+        product_factory(team=gr_team, business=gr_business)
 
         gr_user.set_cache(
             pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
         )
-        res = json.loads(gr_redis.get(name=f"{gr_user.cache_key}:business_uuids"))
+
+        client = gr_redis_config.create_redis_client()
+        res = json.loads(client.get(name=f"{gr_user.cache_key}:business_uuids"))
         assert len(res) == 1
         assert gr_user.business_uuids == res
 
     def test_set_cache_product_uuids(
         self,
-        gr_user,
-        membership,
-        gr_user_token,
-        gr_redis,
-        gr_db,
-        thl_web_rr,
-        product_factory,
-        team,
-        gr_redis_config,
+        gr_user: GRUser,
+        gr_db: PostgresConfig,
+        thl_web_rr: PostgresConfig,
+        product_factory: Callable[..., Product],
+        gr_team: Team,
+        gr_redis_config: RedisConfig,
+        gr_membership,
     ):
-        product_factory(team=team)
+        product_factory(team=gr_team)
 
         gr_user.set_cache(
             pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
         )
-        res = json.loads(gr_redis.get(name=f"{gr_user.cache_key}:product_uuids"))
+        client = gr_redis_config.create_redis_client()
+        res = json.loads(client.get(name=f"{gr_user.cache_key}:product_uuids"))
         assert len(res) == 1
         assert gr_user.product_uuids == res
 
 
 class TestGRToken:
-
     @pytest.fixture
-    def gr_token(self, gr_user):
-        from generalresearch.models.gr.authentication import GRToken
-
-        now = datetime.now(tz=timezone.utc)
+    def gr_token(self, gr_user: GRUser):
+        now = datetime.now(tz=UTC)
         token = binascii.hexlify(os.urandom(20)).decode()
 
         gr_token = GRToken(key=token, created=now, user_id=gr_user.id)
 
         return gr_token
 
-    def test_init(self, gr_token):
-        from generalresearch.models.gr.authentication import GRToken
-
+    def test_init(self, gr_token: GRToken):
         assert isinstance(gr_token, GRToken)
         assert gr_token.created
 
-    def test_user(self, gr_token, gr_db, gr_redis_config):
-        from generalresearch.models.gr.authentication import GRUser
-
+    def test_user(
+        self, gr_token: GRToken, gr_db: PostgresConfig, gr_redis_config: RedisConfig
+    ):
         assert gr_token.user is None
 
         gr_token.prefetch_user(pg_config=gr_db, redis_config=gr_redis_config)
 
         assert isinstance(gr_token.user, GRUser)
 
-    def test_auth_header(self, gr_token):
+    def test_auth_header(self, gr_token: GRToken):
         assert isinstance(gr_token.auth_header, dict)
 
 
 class TestClaims:
-
     def test_init(self):
-        from generalresearch.models.gr.authentication import Claims
 
         d = {
             "iss": SSO_ISSUER,
diff --git a/tests/models/gr/test_base.py b/tests/models/gr/test_base.py
index a9f01a8..5ab5dff 100644
--- a/tests/models/gr/test_base.py
+++ b/tests/models/gr/test_base.py
@@ -1,16 +1,20 @@
+from __future__ import annotations
+
 import subprocess
+from collections.abc import Callable
 from pathlib import Path
-from typing import Callable
+from typing import TYPE_CHECKING
 
 import pytest
 from pydantic import PostgresDsn
 
-from generalresearch.pg_helper import PostgresConfig
+if TYPE_CHECKING:
+    from generalresearch.pg_helper import PostgresConfig
 
 
 class TestGRPostgresDjangoCreation:
 
-    def test_git(self, git_key_path: Path, gr_repo: Callable[..., Path]):
+    def test_git(self, gr_repo: Callable[..., Path]):
         repo_path = gr_repo()
 
         try:
@@ -33,14 +37,5 @@ class TestGRPostgresDjangoCreation:
         django_db_factory: Callable[..., None],
     ):
 
-        dsn = django_db_factory("gr")
+        dsn = django_db_factory("gr.common")
         assert isinstance(dsn, PostgresDsn)
-
-    # def test_django_tables(self, thl_web_rw: PostgresConfig):
-    #     res = thl_web_rw.execute_sql_query(query="""
-    #         SELECT COUNT(*)
-    #         FROM information_schema.tables
-    #         WHERE table_schema = 'public';
-    #     """)
-    #     assert len(res) == 1
-    #     assert res[0]["count"] == 56
diff --git a/tests/models/gr/test_business.py b/tests/models/gr/test_business.py
index 7a84f23..e38850d 100644
--- a/tests/models/gr/test_business.py
+++ b/tests/models/gr/test_business.py
@@ -1,7 +1,11 @@
+from __future__ import annotations
+
 import os
-from datetime import datetime, timedelta, timezone
+from collections.abc import Callable
+from datetime import UTC, datetime, timedelta
 from decimal import Decimal
-from typing import Optional
+from pathlib import Path
+from typing import TYPE_CHECKING
 from uuid import uuid4
 
 import pandas as pd
@@ -15,34 +19,55 @@ from distributed.utils_test import (
 from pytest import approx
 
 from generalresearch.currency import USDCent
-from generalresearch.managers.gr.business import BusinessBankAccountManager
 from generalresearch.models.gr.business import (
     Business,
     BusinessAddress,
-    BusinessBankAccount,
     BusinessContact,
 )
 from generalresearch.models.thl.finance import (
     BusinessBalances,
     ProductBalances,
 )
-from generalresearch.pg_helper import PostgresConfig
+from generalresearch.models.thl.product import Product
+
+if TYPE_CHECKING:
+    from generalresearch.incite.base import GRLDatasets
+    from generalresearch.incite.collections.thl_web import (
+        SessionDFCollection,
+        WallDFCollection,
+    )
+    from generalresearch.incite.mergers.pop_ledger import PopLedgerMerge
+    from generalresearch.managers.gr.business import BusinessBankAccountManager
+    from generalresearch.managers.gr.team import TeamManager
+    from generalresearch.managers.thl.ledger_manager.ledger import LedgerManager
+    from generalresearch.managers.thl.ledger_manager.thl_ledger import ThlLedgerManager
+    from generalresearch.managers.thl.payout import (
+        BusinessPayoutEventManager,
+        PayoutEventManager,
+    )
+    from generalresearch.managers.thl.product import ProductManager
+    from generalresearch.models.gr.business import (
+        BusinessBankAccount,
+    )
+    from generalresearch.models.gr.team import Team
+    from generalresearch.models.thl.product import BrokerageProductPayoutEvent
+    from generalresearch.models.thl.session import Session
+    from generalresearch.models.thl.user import User
+    from generalresearch.pg_helper import PostgresConfig
+    from generalresearch.redis_helper import RedisConfig
 
 
 class TestBusinessBankAccount:
-
     def test_init(
         self,
-        business: Business,
-        business_bank_account_manager: BusinessBankAccountManager,
+        gr_business: Business,
+        gr_business_bank_account_manager: BusinessBankAccountManager,
     ):
-        from generalresearch.models.gr.business import (
-            BusinessBankAccount,
-            TransferMethod,
-        )
+        from generalresearch.models.gr.business import BusinessBankAccount
+        from generalresearch.models.gr.definitions import TransferMethod
 
-        instance = business_bank_account_manager.create(
-            business_id=business.id,
+        instance = gr_business_bank_account_manager.create(
+            business_id=gr_business.id,
             uuid=uuid4().hex,
             transfer_method=TransferMethod.ACH,
         )
@@ -50,30 +75,28 @@ class TestBusinessBankAccount:
 
     def test_business(
         self,
-        business_bank_account: BusinessBankAccount,
-        business: Business,
-        gr_db,
-        gr_redis_config,
+        gr_business_bank_account: BusinessBankAccount,
+        gr_business: Business,
+        gr_db: PostgresConfig,
+        gr_redis_config: RedisConfig,
     ):
         from generalresearch.models.gr.business import Business
 
-        assert business_bank_account.business is None
+        assert gr_business_bank_account.business is None
 
-        business_bank_account.prefetch_business(
+        gr_business_bank_account.prefetch_business(
             pg_config=gr_db, redis_config=gr_redis_config
         )
-        assert isinstance(business_bank_account.business, Business)
-        assert business_bank_account.business.uuid == business.uuid
+        assert isinstance(gr_business_bank_account.business, Business)
+        assert gr_business_bank_account.business.uuid == gr_business.uuid
 
 
 class TestBusinessAddress:
-
-    def test_init(self, business_address: BusinessAddress):
-        assert isinstance(business_address, BusinessAddress)
+    def test_init(self, gr_business_address: BusinessAddress):
+        assert isinstance(gr_business_address, BusinessAddress)
 
 
 class TestBusinessContact:
-
     def test_init(self):
 
         bc = BusinessContact(name="abc", email="test@abc.com")
@@ -82,346 +105,352 @@ class TestBusinessContact:
 
 class TestBusiness:
     @pytest.fixture
-    def start(self) -> "datetime":
-        return datetime(year=2018, month=3, day=14, hour=0, tzinfo=timezone.utc)
+    def start(self) -> datetime:
+        return datetime(year=2018, month=3, day=14, hour=0, tzinfo=UTC)
 
     @pytest.fixture
     def offset(self) -> str:
-        return "30d"
+        return "30D"
 
     @pytest.fixture
-    def duration(self) -> Optional["timedelta"]:
+    def duration(self) -> timedelta | None:
         return None
 
-    def test_init(self, business):
-        from generalresearch.models.gr.business import Business
+    def test_init(self, gr_business: Business):
 
-        assert isinstance(business, Business)
-        assert isinstance(business.id, int)
-        assert isinstance(business.uuid, str)
+        assert isinstance(gr_business, Business)
+        assert isinstance(gr_business.id, int)
+        assert isinstance(gr_business.uuid, str)
 
     def test_str_and_repr(
         self,
-        business,
-        product_factory,
-        thl_web_rr,
-        lm,
-        thl_lm,
-        business_payout_event_manager,
-        bp_payout_factory,
-        start,
-        user_factory,
-        session_with_tx_factory,
-        pop_ledger_merge,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        thl_web_rr: PostgresConfig,
+        ledger_manager: LedgerManager,
+        thl_ledger_manager: ThlLedgerManager,
+        product_manager: ProductManager,
+        business_payout_event_manager: BusinessPayoutEventManager,
+        brokerage_product_payout_event_factory: Callable[
+            ..., BusinessPayoutEventManager
+        ],
+        start: datetime,
+        user_factory: Callable[..., User],
+        session_with_tx_factory: Callable[..., Session],
+        pop_ledger_merge: PopLedgerMerge,
         client_no_amm: DaskClient,
         ledger_collection,
-        mnt_filepath,
-        create_main_accounts,
+        mnt_filepath: GRLDatasets,
+        create_main_accounts: Callable[..., None],
     ):
         create_main_accounts()
-        p1 = product_factory(business=business)
+        p1 = product_factory(business=gr_business)
         u1 = user_factory(product=p1)
-        p2 = product_factory(business=business)
-        thl_lm.get_account_or_create_bp_wallet(product=p1)
-        thl_lm.get_account_or_create_bp_wallet(product=p2)
+        p2 = product_factory(business=gr_business)
+        thl_ledger_manager.get_account_or_create_bp_wallet(product=p1)
+        thl_ledger_manager.get_account_or_create_bp_wallet(product=p2)
 
-        res1 = repr(business)
+        res1 = repr(gr_business)
 
-        assert business.uuid in res1
+        assert gr_business.uuid in res1
         assert "<Business: " in res1
 
-        res2 = str(business)
+        res2 = str(gr_business)
 
-        assert business.uuid in res2
+        assert gr_business.uuid in res2
         assert "Name:" in res2
         assert "Not Loaded" in res2
 
-        business.prefetch_products(thl_pg_config=thl_web_rr)
-        business.prefetch_bp_accounts(thl_lm=thl_lm, thl_pg_config=thl_web_rr)
-        res3 = str(business)
+        gr_business.prefetch_products(product_manager=product_manager)
+        gr_business.prefetch_bp_accounts(
+            thl_lm=thl_ledger_manager, product_manager=product_manager
+        )
+        res3 = str(gr_business)
         assert "Products: 2" in res3
         assert "Ledger Accounts: 2" in res3
 
         # -- need some tx to make these interesting
-        business_payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
         session_with_tx_factory(
             user=u1,
             wall_req_cpi=Decimal("2.50"),
             started=start + timedelta(days=5),
         )
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=p1,
             amount=USDCent(50),
             created=start + timedelta(days=4),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
 
         ledger_collection.initial_load(client=None, sync=True)
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
-        business.prebuild_payouts(
-            thl_pg_config=thl_web_rr,
-            thl_lm=thl_lm,
+        gr_business.prebuild_payouts(
             bpem=business_payout_event_manager,
         )
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
         )
-        res4 = str(business)
+        res4 = str(gr_business)
         assert "Payouts: 1" in res4
         assert "Available Balance: 141" in res4
 
-    def test_addresses(self, business, business_address, gr_db):
+    def test_addresses(
+        self, gr_business: Business, gr_db: PostgresConfig, gr_business_address
+    ):
         from generalresearch.models.gr.business import BusinessAddress
 
-        assert business.addresses is None
+        assert gr_business.addresses is None
 
-        business.prefetch_addresses(pg_config=gr_db)
-        assert isinstance(business.addresses, list)
-        assert len(business.addresses) == 1
-        assert isinstance(business.addresses[0], BusinessAddress)
+        gr_business.prefetch_addresses(pg_config=gr_db)
+        assert isinstance(gr_business.addresses, list)
+        assert len(gr_business.addresses) == 1
+        assert isinstance(gr_business.addresses[0], BusinessAddress)
 
-    def test_teams(self, business, team, team_manager, gr_db):
-        assert business.teams is None
+    def test_teams(
+        self,
+        gr_business: Business,
+        gr_team: Team,
+        gr_team_manager: TeamManager,
+        gr_db: PostgresConfig,
+    ):
+        assert gr_business.teams is None
 
-        business.prefetch_teams(pg_config=gr_db)
-        assert isinstance(business.teams, list)
-        assert len(business.teams) == 0
+        gr_business.prefetch_teams(pg_config=gr_db)
+        assert isinstance(gr_business.teams, list)
+        assert len(gr_business.teams) == 0
 
-        team_manager.add_business(team=team, business=business)
-        assert len(business.teams) == 0
-        business.prefetch_teams(pg_config=gr_db)
-        assert len(business.teams) == 1
+        gr_team_manager.add_business(team=gr_team, business=gr_business)
+        assert len(gr_business.teams) == 0
+        gr_business.prefetch_teams(pg_config=gr_db)
+        assert len(gr_business.teams) == 1
 
-    def test_products(self, business, product_factory, thl_web_rr):
-        from generalresearch.models.thl.product import Product
+    def test_products(
+        self,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        product_manager: ProductManager,
+    ):
 
-        p1 = product_factory(business=business)
-        assert business.products is None
+        p1 = product_factory(business=gr_business)
+        assert gr_business.products is None
 
-        business.prefetch_products(thl_pg_config=thl_web_rr)
-        assert isinstance(business.products, list)
-        assert len(business.products) == 1
-        assert isinstance(business.products[0], Product)
+        gr_business.prefetch_products(product_manager=product_manager)
+        assert isinstance(gr_business.products, list)
+        assert len(gr_business.products) == 1
+        assert isinstance(gr_business.products[0], Product)
 
-        assert business.products[0].uuid == p1.uuid
+        assert gr_business.products[0].uuid == p1.uuid
 
         # Add two more, but list is still one until we prefetch
-        p2 = product_factory(business=business)
-        p3 = product_factory(business=business)
-        assert len(business.products) == 1
+        product_factory(business=gr_business)
+        product_factory(business=gr_business)
+        assert len(gr_business.products) == 1
 
-        business.prefetch_products(thl_pg_config=thl_web_rr)
-        assert len(business.products) == 3
+        gr_business.prefetch_products(product_manager=product_manager)
+        assert len(gr_business.products) == 3
 
-    def test_bank_accounts(self, business, business_bank_account, gr_db):
-        assert business.products is None
+    def test_bank_accounts(
+        self,
+        gr_business: Business,
+        gr_business_bank_account,
+        gr_business_bank_account_manager: BusinessBankAccountManager,
+    ):
+        assert gr_business.products is None
 
         # It's an empty list after prefetch
-        business.prefetch_bank_accounts(pg_config=gr_db)
-        assert isinstance(business.bank_accounts, list)
-        assert len(business.bank_accounts) == 1
+        gr_business.prefetch_bank_accounts(
+            business_bank_account_manager=gr_business_bank_account_manager
+        )
+        assert isinstance(gr_business.bank_accounts, list)
+        assert len(gr_business.bank_accounts) == 1
 
     def test_balance(
         self,
-        business: Business,
-        mnt_filepath,
+        gr_business: Business,
+        mnt_filepath: GRLDatasets,
         client_no_amm: DaskClient,
         thl_web_rr: PostgresConfig,
-        ledger_manager,
-        pop_ledger_merge,
+        ledger_manager: LedgerManager,
+        pop_ledger_merge: PopLedgerMerge,
+        product_manager: ProductManager,
     ):
-        assert business.balance is None
+        assert gr_business.balance is None
 
         with pytest.raises(expected_exception=AssertionError) as cm:
-            business.prebuild_balance(
-                thl_pg_config=thl_web_rr,
+            gr_business.prebuild_balance(
+                product_manager=product_manager,
                 lm=ledger_manager,
                 ds=mnt_filepath,
                 client=client_no_amm,
                 pop_ledger=pop_ledger_merge,
             )
         assert "Cannot build Business Balance" in str(cm.value)
-        assert business.balance is None
+        assert gr_business.balance is None
 
         # TODO: Add parquet building so that this doesn't fail and we can
         #    properly assign a business.balance
 
     def test_payouts_no_accounts(
         self,
-        business,
-        product_factory,
-        thl_web_rr,
-        thl_ledger_manager,
-        business_payout_event_manager,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        thl_ledger_manager: ThlLedgerManager,
+        business_payout_event_manager: BusinessPayoutEventManager,
     ):
-        assert business.payouts is None
+        assert gr_business.payouts is None
 
         with pytest.raises(expected_exception=AssertionError) as cm:
-            business.prebuild_payouts(
-                thl_pg_config=thl_web_rr,
-                thl_lm=thl_ledger_manager,
+            gr_business.prebuild_payouts(
                 bpem=business_payout_event_manager,
             )
         assert "Must provide product_uuids" in str(cm.value)
 
-        p = product_factory(business=business)
+        p = product_factory(business=gr_business)
         thl_ledger_manager.get_account_or_create_bp_wallet(product=p)
 
-        business.prebuild_payouts(
-            thl_pg_config=thl_web_rr,
-            thl_lm=thl_ledger_manager,
+        gr_business.prebuild_payouts(
             bpem=business_payout_event_manager,
         )
-        assert isinstance(business.payouts, list)
-        assert len(business.payouts) == 0
+        assert isinstance(gr_business.payouts, list)
+        assert len(gr_business.payouts) == 0
 
     def test_payouts(
         self,
-        business: Business,
-        product_factory: Callable[Product],
-        bp_payout_factory,
-        thl_ledger_manager,
-        thl_web_rr,
-        business_payout_event_manager,
-        create_main_accounts,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        brokerage_product_payout_event_factory: Callable[
+            ..., BrokerageProductPayoutEvent
+        ],
+        thl_ledger_manager: ThlLedgerManager,
+        business_payout_event_manager: BusinessPayoutEventManager,
+        create_main_accounts: Callable[..., None],
     ):
         create_main_accounts()
-        p = product_factory(business=business)
+        p = product_factory(business=gr_business)
         thl_ledger_manager.get_account_or_create_bp_wallet(product=p)
-        business_payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
 
-        bp_payout_factory(
-            product=p, amount=USDCent(123), skip_wallet_balance_check=True
-        )
+        brokerage_product_payout_event_factory(product=p, amount=USDCent(123))
 
-        business.prebuild_payouts(
-            thl_pg_config=thl_web_rr,
-            thl_lm=thl_ledger_manager,
+        gr_business.prebuild_payouts(
             bpem=business_payout_event_manager,
         )
-        assert len(business.payouts) == 1
-        assert sum([p.amount for p in business.payouts]) == 123
+        assert len(gr_business.payouts) == 1
+        assert sum([p.amount for p in gr_business.payouts]) == 123
 
         # Add another!
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=p,
             amount=USDCent(123),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
-        )
-        business_payout_event_manager.set_account_lookup_table(
-            thl_lm=thl_ledger_manager
         )
-        business.prebuild_payouts(
-            thl_pg_config=thl_web_rr,
-            thl_lm=thl_ledger_manager,
+        gr_business.prebuild_payouts(
             bpem=business_payout_event_manager,
         )
-        assert len(business.payouts) == 1
-        assert len(business.payouts[0].bp_payouts) == 2
-        assert sum([p.amount for p in business.payouts]) == 246
+        assert isinstance(gr_business.payouts, list)
+        assert len(gr_business.payouts) == 2
+        assert len(gr_business.payouts[0].bp_payouts) == 1
+        assert sum([p.amount for p in gr_business.payouts]) == 246
 
     def test_payouts_totals(
         self,
-        business,
-        product_factory,
-        bp_payout_factory,
-        thl_lm,
-        thl_web_rr,
-        business_payout_event_manager,
-        create_main_accounts,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        brokerage_product_payout_event_factory: Callable[
+            ..., BrokerageProductPayoutEvent
+        ],
+        thl_ledger_manager: ThlLedgerManager,
+        thl_web_rr: PostgresConfig,
+        business_payout_event_manager: BusinessPayoutEventManager,
+        create_main_accounts: Callable[..., None],
     ):
-        from generalresearch.models.thl.product import Product
 
         create_main_accounts()
 
-        p1: Product = product_factory(business=business)
-        thl_lm.get_account_or_create_bp_wallet(product=p1)
-        business_payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+        p1: Product = product_factory(business=gr_business)
+        thl_ledger_manager.get_account_or_create_bp_wallet(product=p1)
 
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=p1,
             amount=USDCent(1),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
 
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=p1,
             amount=USDCent(25),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
 
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=p1,
             amount=USDCent(50),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
 
-        business.prebuild_payouts(
-            thl_pg_config=thl_web_rr,
-            thl_lm=thl_lm,
+        gr_business.prebuild_payouts(
             bpem=business_payout_event_manager,
         )
 
-        assert len(business.payouts) == 1
-        assert len(business.payouts[0].bp_payouts) == 3
-        assert business.payouts_total == USDCent(76)
-        assert business.payouts_total_str == "$0.76"
+        assert isinstance(gr_business.payouts, list)
+        assert len(gr_business.payouts) == 3
+        assert len(gr_business.payouts[0].bp_payouts) == 1
+        assert len(gr_business.payouts[1].bp_payouts) == 1
+        assert len(gr_business.payouts[2].bp_payouts) == 1
+        assert gr_business.payouts_total == USDCent(76)
+        assert gr_business.payouts_total_str == "$0.76"
 
     def test_pop_financial(
         self,
-        business,
-        thl_web_rr,
-        thl_ledger_manager,
-        mnt_filepath,
-        client_no_amm,
-        pop_ledger_merge,
+        gr_business: Business,
+        product_manager: ProductManager,
+        thl_ledger_manager: ThlLedgerManager,
+        mnt_filepath: GRLDatasets,
+        client_no_amm: DaskClient,
+        pop_ledger_merge: PopLedgerMerge,
     ):
-        assert business.pop_financial is None
-        business.prebuild_pop_financial(
-            thl_pg_config=thl_web_rr,
-            thl_lm=thl_lm,
+        assert gr_business.pop_financial is None
+        gr_business.prebuild_pop_financial(
+            product_manager=product_manager,
+            thl_lm=thl_ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
         )
-        assert business.pop_financial == []
+        assert gr_business.pop_financial == []
 
-    def test_bp_accounts(self, business, lm, thl_web_rr, product_factory, thl_lm):
-        assert business.bp_accounts is None
-        business.prefetch_bp_accounts(thl_lm=thl_lm, thl_pg_config=thl_web_rr)
-        assert business.bp_accounts == []
-
-        from generalresearch.models.thl.product import Product
+    def test_bp_accounts(
+        self,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        thl_ledger_manager: ThlLedgerManager,
+        product_manager: ProductManager,
+    ):
+        assert gr_business.bp_accounts is None
+        gr_business.prefetch_bp_accounts(
+            thl_lm=thl_ledger_manager, product_manager=product_manager
+        )
+        assert gr_business.bp_accounts == []
 
-        p1: Product = product_factory(business=business)
-        thl_lm.get_account_or_create_bp_wallet(product=p1)
+        p1: Product = product_factory(business=gr_business)
+        thl_ledger_manager.get_account_or_create_bp_wallet(product=p1)
 
-        business.prefetch_bp_accounts(thl_lm=thl_lm, thl_pg_config=thl_web_rr)
-        assert len(business.bp_accounts) == 1
+        gr_business.prefetch_bp_accounts(
+            thl_lm=thl_ledger_manager, product_manager=product_manager
+        )
+        assert len(gr_business.bp_accounts) == 1
 
 
 class TestBusinessBalance:
-
     @pytest.fixture
-    def start(self) -> "datetime":
-        return datetime(year=2018, month=3, day=14, hour=0, tzinfo=timezone.utc)
+    def start(self) -> datetime:
+        return datetime(year=2018, month=3, day=14, hour=0, tzinfo=UTC)
 
     @pytest.fixture
     def offset(self) -> str:
-        return "30d"
+        return "30D"
 
     @pytest.fixture
-    def duration(self) -> Optional["timedelta"]:
+    def duration(self) -> timedelta | None:
         return None
 
     @pytest.mark.skip
@@ -432,34 +461,27 @@ class TestBusinessBalance:
 
     def test_single_product(
         self,
-        business,
-        product_factory,
-        user_factory,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        user_factory: Callable[..., User],
         mnt_filepath,
-        bp_payout_factory,
-        thl_lm,
-        lm,
-        duration,
-        offset,
-        start,
-        thl_web_rr,
-        payout_event_manager,
-        session_with_tx_factory,
-        delete_ledger_db,
-        create_main_accounts,
-        client_no_amm,
+        ledger_manager: LedgerManager,
+        start: datetime,
+        thl_web_rr: PostgresConfig,
+        session_with_tx_factory: Callable[..., Session],
+        delete_ledger_db: Callable[..., None],
+        create_main_accounts: Callable[..., None],
+        client_no_amm: DaskClient,
         ledger_collection,
-        pop_ledger_merge,
-        delete_df_collection,
+        product_manager: ProductManager,
+        pop_ledger_merge: PopLedgerMerge,
+        delete_df_collection: Callable[..., None],
     ):
         delete_ledger_db()
         create_main_accounts()
         delete_df_collection(coll=ledger_collection)
 
-        from generalresearch.models.thl.product import Product
-        from generalresearch.models.thl.user import User
-
-        p1: Product = product_factory(business=business)
+        p1: Product = product_factory(business=gr_business)
         u1: User = user_factory(product=p1)
         u2: User = user_factory(product=p1)
 
@@ -478,57 +500,50 @@ class TestBusinessBalance:
         ledger_collection.initial_load(client=None, sync=True)
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
         )
-        assert isinstance(business.balance, BusinessBalances)
-        assert business.balance.payout == 190
-        assert business.balance.adjustment == 0
-        assert business.balance.net == 190
-        assert business.balance.retainer == 47
-        assert business.balance.available_balance == 143
+        assert isinstance(gr_business.balance, BusinessBalances)
+        assert gr_business.balance.payout == 190
+        assert gr_business.balance.adjustment == 0
+        assert gr_business.balance.net == 190
+        assert gr_business.balance.retainer == 47
+        assert gr_business.balance.available_balance == 143
 
-        assert len(business.balance.product_balances) == 1
-        pb = business.balance.product_balances[0]
+        assert len(gr_business.balance.product_balances) == 1
+        pb = gr_business.balance.product_balances[0]
         assert isinstance(pb, ProductBalances)
-        assert pb.balance == business.balance.balance
-        assert pb.available_balance == business.balance.available_balance
+        assert pb.balance == gr_business.balance.balance
+        assert pb.available_balance == gr_business.balance.available_balance
         assert pb.adjustment_percent == 0.0
 
     def test_multi_product(
         self,
-        business,
-        product_factory,
-        user_factory,
-        mnt_filepath,
-        bp_payout_factory,
-        thl_lm,
-        ledger_manager,
-        duration,
-        offset,
-        start,
-        thl_web_rr,
-        payout_event_manager,
-        session_with_tx_factory,
-        delete_ledger_db,
-        create_main_accounts,
-        client_no_amm,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        user_factory: Callable[..., User],
+        mnt_filepath: GRLDatasets,
+        ledger_manager: LedgerManager,
+        product_manager: ProductManager,
+        start: datetime,
+        session_with_tx_factory: Callable[..., Session],
+        delete_ledger_db: Callable[..., None],
+        create_main_accounts: Callable[..., None],
+        client_no_amm: DaskClient,
         ledger_collection,
-        pop_ledger_merge,
-        delete_df_collection,
+        pop_ledger_merge: PopLedgerMerge,
+        delete_df_collection: Callable[..., None],
     ):
         delete_ledger_db()
         create_main_accounts()
         delete_df_collection(coll=ledger_collection)
 
-        from generalresearch.models.thl.user import User
-
-        u1: User = user_factory(product=product_factory(business=business))
-        u2: User = user_factory(product=product_factory(business=business))
+        u1: User = user_factory(product=product_factory(business=gr_business))
+        u2: User = user_factory(product=product_factory(business=gr_business))
 
         session_with_tx_factory(
             user=u1,
@@ -545,33 +560,33 @@ class TestBusinessBalance:
         ledger_collection.initial_load(client=None, sync=True)
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
         )
-        assert isinstance(business.balance, BusinessBalances)
-        assert business.balance.payout == 190
-        assert business.balance.balance == 190
-        assert business.balance.adjustment == 0
-        assert business.balance.net == 190
-        assert business.balance.retainer == 46
-        assert business.balance.available_balance == 144
+        assert isinstance(gr_business.balance, BusinessBalances)
+        assert gr_business.balance.payout == 190
+        assert gr_business.balance.balance == 190
+        assert gr_business.balance.adjustment == 0
+        assert gr_business.balance.net == 190
+        assert gr_business.balance.retainer == 46
+        assert gr_business.balance.available_balance == 144
 
-        assert len(business.balance.product_balances) == 2
+        assert len(gr_business.balance.product_balances) == 2
 
-        pb1 = business.balance.product_balances[0]
-        pb2 = business.balance.product_balances[1]
+        pb1 = gr_business.balance.product_balances[0]
+        pb2 = gr_business.balance.product_balances[1]
         assert isinstance(pb1, ProductBalances)
         assert pb1.product_id == u1.product_id
         assert isinstance(pb2, ProductBalances)
         assert pb2.product_id == u2.product_id
 
         for pb in [pb1, pb2]:
-            assert pb.balance != business.balance.balance
-            assert pb.available_balance != business.balance.available_balance
+            assert pb.balance != gr_business.balance.balance
+            assert pb.available_balance != gr_business.balance.available_balance
             assert pb.adjustment_percent == 0.0
 
         assert pb1.product_id in [u1.product_id, u2.product_id]
@@ -592,34 +607,33 @@ class TestBusinessBalance:
 
     def test_multi_product_multi_payout(
         self,
-        business,
-        product_factory,
-        user_factory,
-        mnt_filepath,
-        bp_payout_factory,
-        thl_lm,
-        lm,
-        duration,
-        offset,
-        start,
-        thl_web_rr,
-        payout_event_manager,
-        session_with_tx_factory,
-        delete_ledger_db,
-        create_main_accounts,
-        client_no_amm,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        user_factory: Callable[..., User],
+        product_manager: ProductManager,
+        mnt_filepath: GRLDatasets,
+        brokerage_product_payout_event_factory: Callable[
+            ..., BrokerageProductPayoutEvent
+        ],
+        thl_ledger_manager: ThlLedgerManager,
+        ledger_manager: LedgerManager,
+        start: datetime,
+        thl_web_rr: PostgresConfig,
+        payout_event_manager: PayoutEventManager,
+        session_with_tx_factory: Callable[..., None],
+        delete_ledger_db: Callable[..., None],
+        create_main_accounts: Callable[..., None],
+        client_no_amm: DaskClient,
         ledger_collection,
-        pop_ledger_merge,
-        delete_df_collection,
+        pop_ledger_merge: PopLedgerMerge,
+        delete_df_collection: Callable[..., None],
     ):
         delete_ledger_db()
         create_main_accounts()
         delete_df_collection(coll=ledger_collection)
 
-        from generalresearch.models.thl.user import User
-
-        u1: User = user_factory(product=product_factory(business=business))
-        u2: User = user_factory(product=product_factory(business=business))
+        u1: User = user_factory(product=product_factory(business=gr_business))
+        u2: User = user_factory(product=product_factory(business=gr_business))
 
         session_with_tx_factory(
             user=u1,
@@ -633,62 +647,58 @@ class TestBusinessBalance:
             started=start + timedelta(days=2),
         )
 
-        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
-
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=u1.product,
             amount=USDCent(5),
             created=start + timedelta(days=4),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
 
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=u2.product,
             amount=USDCent(50),
             created=start + timedelta(days=4),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
 
         ledger_collection.initial_load(client=None, sync=True)
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
         )
 
-        assert business.balance.payout == 190
-        assert business.balance.net == 190
+        assert isinstance(gr_business.balance, BusinessBalances)
+        assert gr_business.balance.payout == 190
+        assert gr_business.balance.net == 190
 
-        assert business.balance.balance == 135
+        assert gr_business.balance.balance == 135
 
     def test_multi_product_multi_payout_adjustment(
         self,
-        business,
-        product_factory,
-        user_factory,
-        mnt_filepath,
-        bp_payout_factory,
-        duration,
-        offset,
-        start,
-        thl_web_rr,
-        payout_event_manager,
-        session_with_tx_factory,
-        delete_ledger_db,
-        create_main_accounts,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        user_factory: Callable[..., User],
+        mnt_filepath: GRLDatasets,
+        brokerage_product_payout_event_factory: Callable[
+            ..., BrokerageProductPayoutEvent
+        ],
+        ledger_manager: LedgerManager,
+        thl_ledger_manager: ThlLedgerManager,
+        start: datetime,
+        thl_web_rr: PostgresConfig,
+        payout_event_manager: PayoutEventManager,
+        session_with_tx_factory: Callable[..., Session],
+        delete_ledger_db: Callable[..., None],
+        product_manager: ProductManager,
+        create_main_accounts: Callable[..., None],
         ledger_collection,
         task_adj_collection,
-        pop_ledger_merge,
-        wall_manager,
-        session_manager,
-        adj_to_fail_with_tx_factory,
-        delete_df_collection,
+        pop_ledger_merge: PopLedgerMerge,
+        adj_to_fail_with_tx_factory: Callable[..., None],
+        delete_df_collection: Callable[..., None],
     ):
         """
         - Product 1 $2.50 Complete
@@ -712,11 +722,9 @@ class TestBusinessBalance:
         delete_df_collection(coll=ledger_collection)
         delete_df_collection(coll=task_adj_collection)
 
-        from generalresearch.models.thl.user import User
-
-        u1: User = user_factory(product=product_factory(business=business))
-        u2: User = user_factory(product=product_factory(business=business))
-        u3: User = user_factory(product=product_factory(business=business))
+        u1: User = user_factory(product=product_factory(business=gr_business))
+        u2: User = user_factory(product=product_factory(business=gr_business))
+        u3: User = user_factory(product=product_factory(business=gr_business))
 
         s1 = session_with_tx_factory(
             user=u1,
@@ -729,22 +737,17 @@ class TestBusinessBalance:
             wall_req_cpi=Decimal("2.50"),
             started=start + timedelta(days=2),
         )
-        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
 
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=u1.product,
             amount=USDCent(250),
             created=start + timedelta(days=3),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
 
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=u2.product,
             amount=USDCent(50),
             created=start + timedelta(days=4),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
 
         adj_to_fail_with_tx_factory(session=s1, created=start + timedelta(days=5))
@@ -769,57 +772,60 @@ class TestBusinessBalance:
         df = client_no_amm.compute(pop_ledger_merge.ddf(), sync=True)
         assert df.shape == (20, 28)
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
         )
 
-        assert business.balance.payout == 714
-        assert business.balance.adjustment == -238
+        assert isinstance(gr_business.balance, BusinessBalances)
+        assert gr_business.balance.payout == 714
+        assert gr_business.balance.adjustment == -238
 
-        assert business.balance.product_balances[0].adjustment == -238
-        assert business.balance.product_balances[1].adjustment == 0
-        assert business.balance.product_balances[2].adjustment == 0
+        assert gr_business.balance.product_balances[0].adjustment == -238
+        assert gr_business.balance.product_balances[1].adjustment == 0
+        assert gr_business.balance.product_balances[2].adjustment == 0
 
-        assert business.balance.expense == 0
-        assert business.balance.net == 714 - 238
-        assert business.balance.balance == business.balance.payout - (250 + 50 + 238)
+        assert gr_business.balance.expense == 0
+        assert gr_business.balance.net == 714 - 238
+        assert gr_business.balance.balance == gr_business.balance.payout - (
+            250 + 50 + 238
+        )
 
         predicted_retainer = sum(
             [
                 pb.balance * 0.25
-                for pb in business.balance.product_balances
+                for pb in gr_business.balance.product_balances
                 if pb.balance > 0
             ]
         )
-        assert business.balance.retainer == approx(predicted_retainer, rel=0.01)
+        assert gr_business.balance.retainer == approx(predicted_retainer, rel=0.01)
 
     def test_neg_balance_cache(
         self,
-        product,
-        mnt_filepath,
-        thl_lm,
-        client_no_amm,
-        thl_redis_config,
-        brokerage_product_payout_event_manager,
-        delete_ledger_db,
-        create_main_accounts,
-        delete_df_collection,
+        mnt_filepath: GRLDatasets,
+        thl_ledger_manager: ThlLedgerManager,
+        client_no_amm: DaskClient,
+        delete_ledger_db: Callable[..., None],
+        create_main_accounts: Callable[..., None],
+        delete_df_collection: Callable[..., None],
         ledger_collection,
-        business,
-        user_factory,
-        product_factory,
-        session_with_tx_factory,
-        pop_ledger_merge,
-        start,
-        bp_payout_factory,
+        gr_business: Business,
+        user_factory: Callable[..., User],
+        product_factory: Callable[..., Product],
+        session_with_tx_factory: Callable[..., Session],
+        pop_ledger_merge: PopLedgerMerge,
+        start: datetime,
+        brokerage_product_payout_event_factory: Callable[
+            ..., BrokerageProductPayoutEvent
+        ],
         payout_event_manager,
-        adj_to_fail_with_tx_factory,
-        thl_web_rr,
-        lm,
+        product_manager: ProductManager,
+        adj_to_fail_with_tx_factory: Callable[..., None],
+        thl_web_rr: PostgresConfig,
+        ledger_manager: LedgerManager,
     ):
         """Test having a Business with two products.. one that lost money
         and one that gained money. Ensure that the Business balance
@@ -830,15 +836,12 @@ class TestBusinessBalance:
         create_main_accounts()
         delete_df_collection(coll=ledger_collection)
 
-        from generalresearch.models.thl.product import Product
-        from generalresearch.models.thl.user import User
-
-        p1: Product = product_factory(business=business)
-        p2: Product = product_factory(business=business)
+        p1: Product = product_factory(business=gr_business)
+        p2: Product = product_factory(business=gr_business)
         u1: User = user_factory(product=p1)
         u2: User = user_factory(product=p2)
-        thl_lm.get_account_or_create_bp_wallet(product=p1)
-        thl_lm.get_account_or_create_bp_wallet(product=p2)
+        thl_ledger_manager.get_account_or_create_bp_wallet(product=p1)
+        thl_ledger_manager.get_account_or_create_bp_wallet(product=p2)
 
         # Product 1: Complete, Payout, Recon..
         s1 = session_with_tx_factory(
@@ -846,14 +849,11 @@ class TestBusinessBalance:
             wall_req_cpi=Decimal(".75"),
             started=start + timedelta(days=1),
         )
-        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=u1.product,
             amount=USDCent(71),
             ext_ref_id=uuid4().hex,
             created=start + timedelta(days=1, minutes=1),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
         adj_to_fail_with_tx_factory(
             session=s1,
@@ -861,12 +861,12 @@ class TestBusinessBalance:
         )
 
         # Product 2: Complete, Complete.
-        s2 = session_with_tx_factory(
+        session_with_tx_factory(
             user=u2,
             wall_req_cpi=Decimal(".75"),
             started=start + timedelta(days=1, minutes=3),
         )
-        s3 = session_with_tx_factory(
+        session_with_tx_factory(
             user=u2,
             wall_req_cpi=Decimal(".75"),
             started=start + timedelta(days=1, minutes=4),
@@ -876,16 +876,17 @@ class TestBusinessBalance:
         ledger_collection.initial_load(client=None, sync=True)
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
         )
 
         # Check Product 1
-        pb1 = business.balance.product_balances[0]
+        assert isinstance(gr_business.balance, BusinessBalances)
+        pb1 = gr_business.balance.product_balances[0]
         assert pb1.product_id == p1.uuid
         assert pb1.payout == 71
         assert pb1.adjustment == -71
@@ -895,7 +896,7 @@ class TestBusinessBalance:
         assert pb1.available_balance == 0
 
         # Check Product 2
-        pb2 = business.balance.product_balances[1]
+        pb2 = gr_business.balance.product_balances[1]
         assert pb2.product_id == p2.uuid
         assert pb2.payout == 71 * 2
         assert pb2.adjustment == 0
@@ -905,7 +906,8 @@ class TestBusinessBalance:
         assert pb2.available_balance == 107
 
         # Check Business
-        bb1 = business.balance
+        bb1 = gr_business.balance
+        assert isinstance(bb1, BusinessBalances)
         assert bb1.payout == (71 * 3)  # Raw total of completes
         assert bb1.adjustment == -71  # 1 Complete >> Failure
         assert bb1.expense == 0
@@ -923,29 +925,27 @@ class TestBusinessBalance:
 
     def test_multi_product_multi_payout_adjustment_at_timestamp(
         self,
-        business,
-        product_factory,
-        user_factory,
-        mnt_filepath,
-        bp_payout_factory,
-        thl_lm,
-        lm,
-        duration,
-        offset,
-        start,
-        thl_web_rr,
+        gr_business: Business,
+        product_factory: Callable[..., Product],
+        user_factory: Callable[..., User],
+        mnt_filepath: GRLDatasets,
+        brokerage_product_payout_event_factory: Callable[
+            ..., BrokerageProductPayoutEvent
+        ],
+        thl_ledger_manager: ThlLedgerManager,
+        ledger_manager: LedgerManager,
+        product_manager: ProductManager,
+        start: datetime,
         payout_event_manager,
-        session_with_tx_factory,
-        delete_ledger_db,
-        create_main_accounts,
-        client_no_amm,
+        session_with_tx_factory: Callable[..., None],
+        delete_ledger_db: Callable[..., None],
+        create_main_accounts: Callable[..., None],
+        client_no_amm: DaskClient,
         ledger_collection,
         task_adj_collection,
-        pop_ledger_merge,
-        wall_manager,
-        session_manager,
-        adj_to_fail_with_tx_factory,
-        delete_df_collection,
+        pop_ledger_merge: PopLedgerMerge,
+        adj_to_fail_with_tx_factory: Callable[..., None],
+        delete_df_collection: Callable[..., None],
     ):
         """
             This test measures a complex Business situation, but then makes
@@ -985,11 +985,9 @@ class TestBusinessBalance:
         delete_df_collection(coll=ledger_collection)
         delete_df_collection(coll=task_adj_collection)
 
-        from generalresearch.models.thl.user import User
-
-        u1: User = user_factory(product=product_factory(business=business))
-        u2: User = user_factory(product=product_factory(business=business))
-        u3: User = user_factory(product=product_factory(business=business))
+        u1: User = user_factory(product=product_factory(business=gr_business))
+        u2: User = user_factory(product=product_factory(business=gr_business))
+        u3: User = user_factory(product=product_factory(business=gr_business))
 
         s1 = session_with_tx_factory(
             user=u1,
@@ -1002,22 +1000,17 @@ class TestBusinessBalance:
             wall_req_cpi=Decimal("2.50"),
             started=start + timedelta(days=2),
         )
-        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
 
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=u1.product,
             amount=USDCent(250),
             created=start + timedelta(days=3),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
 
-        bp_payout_factory(
+        brokerage_product_payout_event_factory(
             product=u2.product,
             amount=USDCent(50),
             created=start + timedelta(days=4),
-            skip_wallet_balance_check=True,
-            skip_one_per_day_check=True,
         )
 
         session_with_tx_factory(
@@ -1042,73 +1035,80 @@ class TestBusinessBalance:
         df = client_no_amm.compute(pop_ledger_merge.ddf(), sync=True)
         assert df.shape == (20, 28)
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
         )
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
             at_timestamp=start + timedelta(days=1, hours=1),
         )
-        day1_bal = business.balance
+        day1_bal = gr_business.balance
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
             at_timestamp=start + timedelta(days=2, hours=1),
         )
-        day2_bal = business.balance
+        day2_bal = gr_business.balance
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
             at_timestamp=start + timedelta(days=3, hours=1),
         )
-        day3_bal = business.balance
+        day3_bal = gr_business.balance
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
             at_timestamp=start + timedelta(days=4, hours=1),
         )
-        day4_bal = business.balance
+        day4_bal = gr_business.balance
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
             at_timestamp=start + timedelta(days=5, hours=1),
         )
-        day5_bal = business.balance
+        day5_bal = gr_business.balance
 
-        business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
-            lm=lm,
+        gr_business.prebuild_balance(
+            product_manager=product_manager,
+            lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             pop_ledger=pop_ledger_merge,
             at_timestamp=start + timedelta(days=6, hours=1),
         )
-        day6_bal = business.balance
+        day6_bal = gr_business.balance
+
+        assert isinstance(day1_bal, BusinessBalances)
+        assert isinstance(day2_bal, BusinessBalances)
+        assert isinstance(day3_bal, BusinessBalances)
+        assert isinstance(day4_bal, BusinessBalances)
+        assert isinstance(day5_bal, BusinessBalances)
+        assert isinstance(day6_bal, BusinessBalances)
 
         assert day1_bal.payout == 238
         assert day1_bal.retainer == 59
@@ -1136,9 +1136,8 @@ class TestBusinessBalance:
 
 
 class TestBusinessMethods:
-
     @pytest.fixture(scope="function")
-    def start(self, utc_90days_ago) -> "datetime":
+    def start(self, utc_90days_ago: datetime) -> datetime:
         s = utc_90days_ago.replace(microsecond=0)
         return s
 
@@ -1149,72 +1148,74 @@ class TestBusinessMethods:
     @pytest.fixture(scope="function")
     def duration(
         self,
-    ) -> Optional["timedelta"]:
+    ) -> timedelta | None:
         return None
 
-    def test_cache_key(self, business, gr_redis):
-        assert isinstance(business.cache_key, str)
-        assert ":" in business.cache_key
-        assert str(business.uuid) in business.cache_key
+    def test_cache_key(self, gr_business: Business):
+        assert isinstance(gr_business.cache_key, str)
+        assert ":" in gr_business.cache_key
+        assert str(gr_business.uuid) in gr_business.cache_key
 
     def test_set_cache(
         self,
-        business,
-        gr_redis,
-        gr_db,
-        thl_web_rr,
-        client_no_amm,
-        mnt_filepath,
-        lm,
-        thl_lm,
+        gr_business: Business,
+        thl_web_rr: PostgresConfig,
+        client_no_amm: DaskClient,
+        mnt_filepath: GRLDatasets,
+        ledger_manager: LedgerManager,
+        thl_ledger_manager: ThlLedgerManager,
         business_payout_event_manager,
-        product_factory,
-        membership_factory,
-        team,
-        session_with_tx_factory,
-        user_factory,
+        gr_business_bank_account_manager: BusinessBankAccountManager,
+        product_manager: ProductManager,
+        product_factory: Callable[..., Product],
+        gr_team: Team,
+        session_with_tx_factory: Callable[..., Session],
+        user_factory: Callable[..., User],
         ledger_collection,
-        pop_ledger_merge,
-        utc_60days_ago,
-        delete_ledger_db,
-        create_main_accounts,
-        gr_redis_config,
-        mnt_gr_api_dir,
+        pop_ledger_merge: PopLedgerMerge,
+        utc_60days_ago: datetime,
+        delete_ledger_db: Callable[..., None],
+        create_main_accounts: Callable[..., None],
+        gr_redis_config: RedisConfig,
+        mnt_gr_api_dir: Path,
     ):
-        assert gr_redis.get(name=business.cache_key) is None
+        client = gr_redis_config.create_redis_client()
+        assert client.get(name=gr_business.cache_key) is None
 
-        p1 = product_factory(team=team, business=business)
+        p1 = product_factory(team=gr_team, business=gr_business)
         u1 = user_factory(product=p1)
 
         # Business needs tx & incite to build balance
         delete_ledger_db()
         create_main_accounts()
-        thl_lm.get_account_or_create_bp_wallet(product=p1)
+        thl_ledger_manager.get_account_or_create_bp_wallet(product=p1)
         session_with_tx_factory(user=u1, started=utc_60days_ago)
         ledger_collection.initial_load(client=None, sync=True)
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
-        business.set_cache(
-            pg_config=gr_db,
+        gr_business.set_cache(
+            product_manager=product_manager,
+            business_bank_account_manager=gr_business_bank_account_manager,
+            pg_config=thl_web_rr,
             thl_web_rr=thl_web_rr,
             redis_config=gr_redis_config,
             client=client_no_amm,
             ds=mnt_filepath,
-            lm=lm,
-            thl_lm=thl_lm,
+            lm=ledger_manager,
+            thl_lm=thl_ledger_manager,
             bpem=business_payout_event_manager,
             pop_ledger=pop_ledger_merge,
             mnt_gr_api=mnt_gr_api_dir,
         )
 
-        assert gr_redis.hgetall(name=business.cache_key) is not None
+        assert client.hgetall(name=gr_business.cache_key) is not None
         from generalresearch.models.gr.business import Business
 
         # We're going to pull only a specific year, but make sure that
         # it's being assigned to the field regardless
-        year = datetime.now(tz=timezone.utc).year
+        year = datetime.now(tz=UTC).year
         res = Business.from_redis(
-            uuid=business.uuid,
+            uuid=gr_business.uuid,
             fields=[f"pop_financial:{year}"],
             gr_redis_config=gr_redis_config,
         )
@@ -1222,53 +1223,53 @@ class TestBusinessMethods:
 
     def test_set_cache_business(
         self,
-        gr_user,
-        business,
-        gr_user_token,
-        gr_redis,
-        gr_db,
-        thl_web_rr,
-        product_factory,
-        team,
-        membership_factory,
-        client_no_amm,
-        mnt_filepath,
-        lm,
-        thl_lm,
+        gr_business: Business,
+        gr_db: PostgresConfig,
+        thl_web_rr: PostgresConfig,
+        product_factory: Callable[..., Product],
+        gr_team: Team,
+        client_no_amm: DaskClient,
+        mnt_filepath: GRLDatasets,
+        ledger_manager: LedgerManager,
+        thl_ledger_manager: ThlLedgerManager,
         business_payout_event_manager,
-        user_factory,
-        delete_ledger_db,
-        create_main_accounts,
-        session_with_tx_factory,
+        product_manager: ProductManager,
+        gr_business_bank_account_manager: BusinessBankAccountManager,
+        user_factory: Callable[..., User],
+        delete_ledger_db: Callable[..., None],
+        create_main_accounts: Callable[..., None],
+        session_with_tx_factory: Callable[..., Session],
         ledger_collection,
-        team_manager,
-        pop_ledger_merge,
-        gr_redis_config,
-        utc_60days_ago,
-        mnt_gr_api_dir,
+        gr_team_manager: TeamManager,
+        pop_ledger_merge: PopLedgerMerge,
+        gr_redis_config: RedisConfig,
+        utc_60days_ago: datetime,
+        mnt_gr_api_dir: Path,
     ):
         from generalresearch.models.gr.business import Business
 
-        p1 = product_factory(team=team, business=business)
+        p1 = product_factory(team=gr_team, business=gr_business)
         u1 = user_factory(product=p1)
-        team_manager.add_business(team=team, business=business)
+        gr_team_manager.add_business(team=gr_team, business=gr_business)
 
         # Business needs tx & incite to build balance
         delete_ledger_db()
         create_main_accounts()
-        thl_lm.get_account_or_create_bp_wallet(product=p1)
+        thl_ledger_manager.get_account_or_create_bp_wallet(product=p1)
         session_with_tx_factory(user=u1, started=utc_60days_ago)
         ledger_collection.initial_load(client=None, sync=True)
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
-        business.set_cache(
+        gr_business.set_cache(
+            product_manager=product_manager,
+            business_bank_account_manager=gr_business_bank_account_manager,
             pg_config=gr_db,
             thl_web_rr=thl_web_rr,
             redis_config=gr_redis_config,
             client=client_no_amm,
             ds=mnt_filepath,
-            lm=lm,
-            thl_lm=thl_lm,
+            lm=ledger_manager,
+            thl_lm=thl_ledger_manager,
             bpem=business_payout_event_manager,
             pop_ledger=pop_ledger_merge,
             mnt_gr_api=mnt_gr_api_dir,
@@ -1276,7 +1277,7 @@ class TestBusinessMethods:
 
         # keys: List = Business.required_fields() + ["products", "bp_accounts"]
         business2 = Business.from_redis(
-            uuid=business.uuid,
+            uuid=gr_business.uuid,
             fields=[
                 "id",
                 "tax_number",
@@ -1295,11 +1296,16 @@ class TestBusinessMethods:
             gr_redis_config=gr_redis_config,
         )
 
-        assert business.model_dump_json() == business2.model_dump_json()
+        assert isinstance(business2, Business)
+        assert gr_business.model_dump_json() == business2.model_dump_json()
+        # assert isinstance(business2.balance, BusinessBalances)
+        assert isinstance(business2.products, list)
+        assert isinstance(business2.teams, list)
         assert p1.uuid in [p.uuid for p in business2.products]
         assert len(business2.teams) == 1
-        assert team.uuid in [t.uuid for t in business2.teams]
+        assert gr_team.uuid in [t.uuid for t in business2.teams]
 
+        assert isinstance(business2.balance, BusinessBalances)
         assert business2.balance.payout == 48
         assert business2.balance.balance == 48
         assert business2.balance.net == 48
@@ -1312,39 +1318,39 @@ class TestBusinessMethods:
         assert len(business2.bp_accounts) == 1
         assert len(business2.bp_accounts) == len(business2.product_uuids)
 
+        assert isinstance(business2.pop_financial, list)
         assert len(business2.pop_financial) == 1
         assert business2.pop_financial[0].payout == business2.balance.payout
         assert business2.pop_financial[0].net == business2.balance.net
 
     def test_prebuild_enriched_session_parquet(
         self,
-        event_report_request,
         enriched_session_merge,
-        client_no_amm,
-        wall_collection,
-        session_collection,
-        thl_web_rr,
-        session_report_request,
-        user_factory,
-        start,
-        session_factory,
-        product_factory,
-        delete_df_collection,
-        business,
-        mnt_filepath,
-        mnt_gr_api_dir,
+        client_no_amm: DaskClient,
+        wall_collection: WallDFCollection,
+        product_manager: ProductManager,
+        session_collection: SessionDFCollection,
+        thl_web_rr: PostgresConfig,
+        user_factory: Callable[..., User],
+        start: datetime,
+        session_factory: Callable[..., Session],
+        product_factory: Callable[..., Product],
+        delete_df_collection: Callable[..., None],
+        gr_business: Business,
+        mnt_filepath: GRLDatasets,
+        mnt_gr_api_dir: Path,
     ):
 
         delete_df_collection(coll=wall_collection)
         delete_df_collection(coll=session_collection)
 
-        p1 = product_factory(business=business)
-        p2 = product_factory(business=business)
+        p1 = product_factory(business=gr_business)
+        p2 = product_factory(business=gr_business)
 
         for p in [p1, p2]:
             u = user_factory(product=p)
             for i in range(50):
-                s = session_factory(
+                session_factory(
                     user=u,
                     wall_count=1,
                     wall_req_cpi=Decimal("1.00"),
@@ -1360,8 +1366,8 @@ class TestBusinessMethods:
             pg_config=thl_web_rr,
         )
 
-        business.prebuild_enriched_session_parquet(
-            thl_pg_config=thl_web_rr,
+        gr_business.prebuild_enriched_session_parquet(
+            product_manager=product_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             mnt_gr_api=mnt_gr_api_dir,
@@ -1370,40 +1376,40 @@ class TestBusinessMethods:
 
         # Now try to read from path
         df = pd.read_parquet(
-            os.path.join(mnt_gr_api_dir, "pop_session", f"{business.file_key}.parquet")
+            os.path.join(
+                mnt_gr_api_dir, "pop_session", f"{gr_business.file_key}.parquet"
+            )
         )
         assert isinstance(df, pd.DataFrame)
 
     def test_prebuild_enriched_wall_parquet(
         self,
-        event_report_request,
-        enriched_session_merge,
         enriched_wall_merge,
-        client_no_amm,
-        wall_collection,
-        session_collection,
-        thl_web_rr,
-        session_report_request,
-        user_factory,
-        start,
-        session_factory,
-        product_factory,
-        delete_df_collection,
-        business,
-        mnt_filepath,
-        mnt_gr_api_dir,
+        client_no_amm: DaskClient,
+        wall_collection: WallDFCollection,
+        product_manager: ProductManager,
+        session_collection: SessionDFCollection,
+        thl_web_rr: PostgresConfig,
+        user_factory: Callable[..., User],
+        start: datetime,
+        session_factory: Callable[..., Session],
+        product_factory: Callable[..., Product],
+        delete_df_collection: Callable[..., None],
+        gr_business: Business,
+        mnt_filepath: GRLDatasets,
+        mnt_gr_api_dir: Path,
     ):
 
         delete_df_collection(coll=wall_collection)
         delete_df_collection(coll=session_collection)
 
-        p1 = product_factory(business=business)
-        p2 = product_factory(business=business)
+        p1 = product_factory(business=gr_business)
+        p2 = product_factory(business=gr_business)
 
         for p in [p1, p2]:
             u = user_factory(product=p)
             for i in range(50):
-                s = session_factory(
+                session_factory(
                     user=u,
                     wall_count=1,
                     wall_req_cpi=Decimal("1.00"),
@@ -1419,8 +1425,8 @@ class TestBusinessMethods:
             pg_config=thl_web_rr,
         )
 
-        business.prebuild_enriched_wall_parquet(
-            thl_pg_config=thl_web_rr,
+        gr_business.prebuild_enriched_wall_parquet(
+            product_manager=product_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             mnt_gr_api=mnt_gr_api_dir,
@@ -1429,6 +1435,6 @@ class TestBusinessMethods:
 
         # Now try to read from path
         df = pd.read_parquet(
-            os.path.join(mnt_gr_api_dir, "pop_event", f"{business.file_key}.parquet")
+            os.path.join(mnt_gr_api_dir, "pop_event", f"{gr_business.file_key}.parquet")
         )
         assert isinstance(df, pd.DataFrame)
diff --git a/tests/models/gr/test_team.py b/tests/models/gr/test_team.py
index d728bbe..e853817 100644
--- a/tests/models/gr/test_team.py
+++ b/tests/models/gr/test_team.py
@@ -1,127 +1,180 @@
+from __future__ import annotations
+
 import os
-from datetime import timedelta
+from collections.abc import Callable
+from datetime import datetime, timedelta
 from decimal import Decimal
+from pathlib import Path
+from typing import TYPE_CHECKING
 
 import pandas as pd
+from dask.distributed import Client as DaskClient
+from distributed.utils_test import (
+    client_no_amm,
+)
+
+from generalresearch.models.gr.business import Business
+from generalresearch.models.gr.team import Team
+from generalresearch.models.thl.product import Product
+
+if TYPE_CHECKING:
+    from generalresearch.incite.base import GRLDatasets
+    from generalresearch.incite.collections.thl_web import (
+        SessionDFCollection,
+        WallDFCollection,
+    )
+    from generalresearch.incite.mergers.foundations.enriched_session import (
+        EnrichedSessionMerge,
+    )
+    from generalresearch.incite.mergers.foundations.enriched_wall import (
+        EnrichedWallMerge,
+    )
+    from generalresearch.managers.gr.authentication import GRUserManager
+    from generalresearch.managers.gr.business import BusinessManager
+    from generalresearch.managers.gr.team import MembershipManager, TeamManager
+    from generalresearch.managers.thl.product import ProductManager
+    from generalresearch.models.gr.authentication import GRUser
+    from generalresearch.models.gr.team import Membership
+    from generalresearch.models.thl.session import Session
+    from generalresearch.models.thl.user import User
+    from generalresearch.pg_helper import PostgresConfig
+    from generalresearch.redis_helper import RedisConfig
 
 
 class TestTeam:
+    def test_init(self, gr_team: Team):
 
-    def test_init(self, team):
-        from generalresearch.models.gr.team import Team
-
-        assert isinstance(team, Team)
-        assert isinstance(team.id, int)
-        assert isinstance(team.uuid, str)
+        assert isinstance(gr_team, Team)
+        assert isinstance(gr_team.id, int)
+        assert isinstance(gr_team.uuid, str)
 
-    def test_memberships_none(self, team, gr_user_factory, gr_db):
-        assert team.memberships is None
+    def test_memberships_none(
+        self, gr_team: Team, gr_membership_manager: MembershipManager
+    ):
+        assert gr_team.memberships is None
 
-        team.prefetch_memberships(pg_config=gr_db)
-        assert isinstance(team.memberships, list)
-        assert len(team.memberships) == 0
+        gr_team.prefetch_memberships(gr_membership_manager=gr_membership_manager)
+        assert isinstance(gr_team.memberships, list)
+        assert len(gr_team.memberships) == 0
 
     def test_memberships(
         self,
-        team,
-        membership,
-        gr_user,
-        gr_user_factory,
-        membership_factory,
-        membership_manager,
-        gr_db,
+        gr_team: Team,
+        gr_user: GRUser,
+        gr_membership,
+        gr_user_factory: Callable[..., GRUser],
+        gr_membership_manager: MembershipManager,
     ):
-        assert team.memberships is None
+        assert gr_team.memberships is None
 
-        team.prefetch_memberships(pg_config=gr_db)
-        assert isinstance(team.memberships, list)
-        assert len(team.memberships) == 1
-        assert team.memberships[0].user_id == gr_user.id
+        gr_team.prefetch_memberships(gr_membership_manager=gr_membership_manager)
+        assert isinstance(gr_team.memberships, list)
+        assert len(gr_team.memberships) == 1
+        assert gr_team.memberships[0].user_id == gr_user.id
 
         # Create another new Membership
-        membership_manager.create(team=team, gr_user=gr_user_factory())
-        assert len(team.memberships) == 1
-        team.prefetch_memberships(pg_config=gr_db)
-        assert len(team.memberships) == 2
+        gr_membership_manager.create(team=gr_team, gr_user=gr_user_factory())
+        assert len(gr_team.memberships) == 1
+        gr_team.prefetch_memberships(gr_membership_manager=gr_membership_manager)
+        assert len(gr_team.memberships) == 2
 
     def test_gr_users(
-        self, team, gr_user_factory, membership_manager, gr_db, gr_redis_config
+        self,
+        gr_team: Team,
+        gr_user_factory: Callable[..., GRUser],
+        gr_membership_manager: MembershipManager,
+        gr_user_manager: GRUserManager,
     ):
-        assert team.gr_users is None
+        assert gr_team.gr_users is None
 
-        team.prefetch_gr_users(pg_config=gr_db, redis_config=gr_redis_config)
-        assert isinstance(team.gr_users, list)
-        assert len(team.gr_users) == 0
+        gr_team.prefetch_gr_users(gr_user_manager=gr_user_manager)
+        assert isinstance(gr_team.gr_users, list)
+        assert len(gr_team.gr_users) == 0
 
         # Create a new Membership
-        membership_manager.create(team=team, gr_user=gr_user_factory())
-        assert len(team.gr_users) == 0
-        team.prefetch_gr_users(pg_config=gr_db, redis_config=gr_redis_config)
-        assert len(team.gr_users) == 1
+        gr_membership_manager.create(team=gr_team, gr_user=gr_user_factory())
+        assert len(gr_team.gr_users) == 0
+        gr_team.prefetch_gr_users(gr_user_manager=gr_user_manager)
+        assert len(gr_team.gr_users) == 1
 
         # Create another Membership
-        membership_manager.create(team=team, gr_user=gr_user_factory())
-        assert len(team.gr_users) == 1
-        team.prefetch_gr_users(pg_config=gr_db, redis_config=gr_redis_config)
-        assert len(team.gr_users) == 2
+        gr_membership_manager.create(team=gr_team, gr_user=gr_user_factory())
+        assert len(gr_team.gr_users) == 1
+        gr_team.prefetch_gr_users(gr_user_manager=gr_user_manager)
+        assert len(gr_team.gr_users) == 2
 
-    def test_businesses(self, team, business, team_manager, gr_db, gr_redis_config):
-        from generalresearch.models.gr.business import Business
+    def test_businesses(
+        self,
+        gr_team: Team,
+        gr_business: Business,
+        team_manager: TeamManager,
+        gr_business_manager: BusinessManager,
+    ):
 
-        assert team.businesses is None
+        assert gr_team.businesses is None
 
-        team.prefetch_businesses(pg_config=gr_db, redis_config=gr_redis_config)
-        assert isinstance(team.businesses, list)
-        assert len(team.businesses) == 0
+        gr_team.prefetch_businesses(gr_business_manager=gr_business_manager)
+        assert isinstance(gr_team.businesses, list)
+        assert len(gr_team.businesses) == 0
 
-        team_manager.add_business(team=team, business=business)
-        assert len(team.businesses) == 0
-        team.prefetch_businesses(pg_config=gr_db, redis_config=gr_redis_config)
-        assert len(team.businesses) == 1
-        assert isinstance(team.businesses[0], Business)
-        assert team.businesses[0].uuid == business.uuid
+        team_manager.add_business(team=gr_team, business=gr_business)
+        assert len(gr_team.businesses) == 0
+        gr_team.prefetch_businesses(gr_business_manager=gr_business_manager)
+        assert len(gr_team.businesses) == 1
+        assert isinstance(gr_team.businesses[0], Business)
+        assert gr_team.businesses[0].uuid == gr_business.uuid
 
-    def test_products(self, team, product_factory, thl_web_rr):
-        from generalresearch.models.thl.product import Product
+    def test_products(
+        self,
+        gr_team: Team,
+        product_factory: Callable[..., Product],
+        thl_web_rr: PostgresConfig,
+        product_manager: ProductManager,
+    ):
 
-        assert team.products is None
+        assert gr_team.products is None
 
-        team.prefetch_products(thl_pg_config=thl_web_rr)
-        assert isinstance(team.products, list)
-        assert len(team.products) == 0
+        gr_team.prefetch_products(product_manager=product_manager)
+        assert isinstance(gr_team.products, list)
+        assert len(gr_team.products) == 0
 
-        product_factory(team=team)
-        assert len(team.products) == 0
-        team.prefetch_products(thl_pg_config=thl_web_rr)
-        assert len(team.products) == 1
-        assert isinstance(team.products[0], Product)
+        product_factory(team=gr_team)
+        assert len(gr_team.products) == 0
+        gr_team.prefetch_products(product_manager=product_manager)
+        assert len(gr_team.products) == 1
+        assert isinstance(gr_team.products[0], Product)
 
 
 class TestTeamMethods:
-
-    def test_cache_key(self, team, gr_redis):
-        assert isinstance(team.cache_key, str)
-        assert ":" in team.cache_key
-        assert str(team.uuid) in team.cache_key
+    def test_cache_key(self, gr_team: Team):
+        assert isinstance(gr_team.cache_key, str)
+        assert ":" in gr_team.cache_key
+        assert str(gr_team.uuid) in gr_team.cache_key
 
     def test_set_cache(
         self,
-        team,
-        gr_redis,
-        gr_db,
-        thl_web_rr,
-        gr_redis_config,
-        client_no_amm,
-        mnt_filepath,
-        mnt_gr_api_dir,
-        enriched_wall_merge,
-        enriched_session_merge,
+        gr_team: Team,
+        gr_db: PostgresConfig,
+        thl_web_rr: PostgresConfig,
+        gr_redis_config: RedisConfig,
+        client_no_amm: DaskClient,
+        mnt_filepath: GRLDatasets,
+        mnt_gr_api_dir: Path,
+        enriched_wall_merge: EnrichedWallMerge,
+        enriched_session_merge: EnrichedSessionMerge,
+        product_manager: ProductManager,
+        gr_user_manager: GRUserManager,
+        gr_business_manager: BusinessManager,
+        gr_membership_manager: MembershipManager,
     ):
-        assert gr_redis.get(name=team.cache_key) is None
-
-        team.set_cache(
-            pg_config=gr_db,
-            thl_web_rr=thl_web_rr,
+        client = gr_redis_config.create_redis_client()
+        assert client.get(name=gr_team.cache_key) is None
+
+        gr_team.set_cache(
+            product_manager=product_manager,
+            gr_user_manager=gr_user_manager,
+            gr_business_manager=gr_business_manager,
+            gr_membership_manager=gr_membership_manager,
             redis_config=gr_redis_config,
             client=client_no_amm,
             ds=mnt_filepath,
@@ -130,33 +183,36 @@ class TestTeamMethods:
             enriched_session=enriched_session_merge,
         )
 
-        assert gr_redis.hgetall(name=team.cache_key) is not None
+        assert client.hgetall(name=gr_team.cache_key) is not None
 
     def test_set_cache_team(
         self,
-        gr_user,
-        gr_user_token,
-        gr_redis,
-        gr_db,
-        thl_web_rr,
-        product_factory,
-        team,
-        membership_factory,
-        gr_redis_config,
-        client_no_amm,
-        mnt_filepath,
-        mnt_gr_api_dir,
-        enriched_wall_merge,
-        enriched_session_merge,
+        gr_user: GRUser,
+        gr_db: PostgresConfig,
+        thl_web_rr: PostgresConfig,
+        product_factory: Callable[..., Product],
+        gr_team: Team,
+        gr_membership_factory: Callable[..., Membership],
+        gr_redis_config: RedisConfig,
+        mnt_filepath: GRLDatasets,
+        mnt_gr_api_dir: Path,
+        enriched_wall_merge: EnrichedWallMerge,
+        enriched_session_merge: EnrichedSessionMerge,
+        product_manager: ProductManager,
+        gr_user_manager: GRUserManager,
+        gr_business_manager: BusinessManager,
+        gr_membership_manager: MembershipManager,
     ):
         from generalresearch.models.gr.team import Team
 
-        p1 = product_factory(team=team)
-        membership_factory(team=team, gr_user=gr_user)
+        p1 = product_factory(team=gr_team)
+        gr_membership_factory(gr_team=gr_team, gr_user=gr_user)
 
-        team.set_cache(
-            pg_config=gr_db,
-            thl_web_rr=thl_web_rr,
+        gr_team.set_cache(
+            product_manager=product_manager,
+            gr_user_manager=gr_user_manager,
+            gr_business_manager=gr_business_manager,
+            gr_membership_manager=gr_membership_manager,
             redis_config=gr_redis_config,
             client=client_no_amm,
             ds=mnt_filepath,
@@ -166,46 +222,47 @@ class TestTeamMethods:
         )
 
         team2 = Team.from_redis(
-            uuid=team.uuid,
+            uuid=gr_team.uuid,
             fields=["id", "memberships", "gr_users", "businesses", "products"],
             gr_redis_config=gr_redis_config,
         )
 
-        assert team.model_dump_json() == team2.model_dump_json()
+        assert isinstance(team2, Team)
+        assert isinstance(team2.products, list)
+        assert isinstance(team2.gr_users, list)
+        assert gr_team.model_dump_json() == team2.model_dump_json()
         assert p1.uuid in [p.uuid for p in team2.products]
         assert len(team2.gr_users) == 1
         assert gr_user.id in [gru.id for gru in team2.gr_users]
 
     def test_prebuild_enriched_session_parquet(
         self,
-        event_report_request,
-        enriched_session_merge,
-        client_no_amm,
-        wall_collection,
-        session_collection,
-        thl_web_rr,
-        session_report_request,
-        user_factory,
-        start,
-        session_factory,
-        product_factory,
-        delete_df_collection,
-        business,
-        mnt_filepath,
-        mnt_gr_api_dir,
-        team,
+        enriched_session_merge: EnrichedSessionMerge,
+        client_no_amm: DaskClient,
+        wall_collection: WallDFCollection,
+        session_collection: SessionDFCollection,
+        thl_web_rr: PostgresConfig,
+        user_factory: Callable[..., User],
+        start: datetime,
+        session_factory: Callable[..., Session],
+        product_factory: Callable[..., Product],
+        delete_df_collection: Callable[..., None],
+        mnt_filepath: GRLDatasets,
+        mnt_gr_api_dir: Path,
+        gr_team: Team,
+        product_manager: ProductManager,
     ):
 
         delete_df_collection(coll=wall_collection)
         delete_df_collection(coll=session_collection)
 
-        p1 = product_factory(team=team)
-        p2 = product_factory(team=team)
+        p1 = product_factory(team=gr_team)
+        p2 = product_factory(team=gr_team)
 
         for p in [p1, p2]:
             u = user_factory(product=p)
             for i in range(50):
-                s = session_factory(
+                session_factory(
                     user=u,
                     wall_count=1,
                     wall_req_cpi=Decimal("1.00"),
@@ -221,8 +278,8 @@ class TestTeamMethods:
             pg_config=thl_web_rr,
         )
 
-        team.prebuild_enriched_session_parquet(
-            thl_pg_config=thl_web_rr,
+        gr_team.prebuild_enriched_session_parquet(
+            product_manager=product_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             mnt_gr_api=mnt_gr_api_dir,
@@ -231,41 +288,38 @@ class TestTeamMethods:
 
         # Now try to read from path
         df = pd.read_parquet(
-            os.path.join(mnt_gr_api_dir, "pop_session", f"{team.file_key}.parquet")
+            os.path.join(mnt_gr_api_dir, "pop_session", f"{gr_team.file_key}.parquet")
         )
         assert isinstance(df, pd.DataFrame)
 
     def test_prebuild_enriched_wall_parquet(
         self,
-        event_report_request,
-        enriched_session_merge,
-        enriched_wall_merge,
-        client_no_amm,
-        wall_collection,
-        session_collection,
-        thl_web_rr,
-        session_report_request,
-        user_factory,
-        start,
-        session_factory,
-        product_factory,
-        delete_df_collection,
-        business,
-        mnt_filepath,
-        mnt_gr_api_dir,
-        team,
+        enriched_wall_merge: EnrichedWallMerge,
+        client_no_amm: DaskClient,
+        wall_collection: WallDFCollection,
+        session_collection: EnrichedSessionMerge,
+        thl_web_rr: PostgresConfig,
+        user_factory: Callable[..., User],
+        start: datetime,
+        session_factory: Callable[..., Session],
+        product_factory: Callable[..., Product],
+        delete_df_collection: Callable[..., None],
+        mnt_filepath: GRLDatasets,
+        mnt_gr_api_dir: Path,
+        gr_team: Team,
+        product_manager: ProductManager,
     ):
 
         delete_df_collection(coll=wall_collection)
         delete_df_collection(coll=session_collection)
 
-        p1 = product_factory(team=team)
-        p2 = product_factory(team=team)
+        p1 = product_factory(team=gr_team)
+        p2 = product_factory(team=gr_team)
 
         for p in [p1, p2]:
             u = user_factory(product=p)
             for i in range(50):
-                s = session_factory(
+                session_factory(
                     user=u,
                     wall_count=1,
                     wall_req_cpi=Decimal("1.00"),
@@ -281,8 +335,8 @@ class TestTeamMethods:
             pg_config=thl_web_rr,
         )
 
-        team.prebuild_enriched_wall_parquet(
-            thl_pg_config=thl_web_rr,
+        gr_team.prebuild_enriched_wall_parquet(
+            product_manager=product_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             mnt_gr_api=mnt_gr_api_dir,
@@ -291,6 +345,6 @@ class TestTeamMethods:
 
         # Now try to read from path
         df = pd.read_parquet(
-            os.path.join(mnt_gr_api_dir, "pop_event", f"{team.file_key}.parquet")
+            os.path.join(mnt_gr_api_dir, "pop_event", f"{gr_team.file_key}.parquet")
         )
         assert isinstance(df, pd.DataFrame)