wayfinder-paths 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

wayfinder_paths/core/clients/ClientManager.py

@@ -28,7 +28,7 @@ from wayfinder_paths.core.clients.WalletClient import WalletClient
 
 class ClientManager:
     """
-    Manages all API client instances for a vault job.
+    Manages all API client instances for a strategy job.
 
     Args:
         clients: Optional dict of pre-instantiated clients to inject directly.
@@ -66,6 +66,33 @@ class ClientManager:
         self._brap_client: BRAPClientProtocol | None = None
         self._simulation_client: SimulationClientProtocol | None = None
 
+    def _get_or_create_client(
+        self,
+        client_attr: str,
+        injected_key: str,
+        client_class: type[Any],
+    ) -> Any:
+        """
+        Helper method to get or create a client instance.
+
+        Args:
+            client_attr: Name of the private attribute storing the client (e.g., "_token_client").
+            injected_key: Key to look up in _injected_clients dict.
+            client_class: Client class to instantiate if not injected.
+
+        Returns:
+            Client instance.
+        """
+        client = getattr(self, client_attr)
+        if not client:
+            client = self._injected_clients.get(injected_key) or client_class(
+                api_key=self._api_key
+            )
+            setattr(self, client_attr, client)
+            if self._access_token and hasattr(client, "set_bearer_token"):
+                client.set_bearer_token(self._access_token)
+        return client
+
     @property
     def auth(self) -> AuthClient | None:
         """Get or create auth client. Returns None if skip_auth=True."""
@@ -80,96 +107,48 @@ class ClientManager:
     @property
     def token(self) -> TokenClientProtocol:
         """Get or create token client"""
-        if not self._token_client:
-            self._token_client = self._injected_clients.get("token") or TokenClient(
-                api_key=self._api_key
-            )
-            if self._access_token and hasattr(self._token_client, "set_bearer_token"):
-                self._token_client.set_bearer_token(self._access_token)
-        return self._token_client
+        return self._get_or_create_client("_token_client", "token", TokenClient)
 
     @property
     def transaction(self) -> TransactionClientProtocol:
         """Get or create transaction client"""
-        if not self._transaction_client:
-            self._transaction_client = self._injected_clients.get(
-                "transaction"
-            ) or TransactionClient(api_key=self._api_key)
-            if self._access_token and hasattr(
-                self._transaction_client, "set_bearer_token"
-            ):
-                self._transaction_client.set_bearer_token(self._access_token)
-        return self._transaction_client
+        return self._get_or_create_client(
+            "_transaction_client", "transaction", TransactionClient
+        )
 
     @property
     def ledger(self) -> LedgerClientProtocol:
         """Get or create ledger client"""
-        if not self._ledger_client:
-            self._ledger_client = self._injected_clients.get("ledger") or LedgerClient(
-                api_key=self._api_key
-            )
-            if self._access_token and hasattr(self._ledger_client, "set_bearer_token"):
-                self._ledger_client.set_bearer_token(self._access_token)
-        return self._ledger_client
+        return self._get_or_create_client("_ledger_client", "ledger", LedgerClient)
 
     @property
     def pool(self) -> PoolClientProtocol:
         """Get or create pool client"""
-        if not self._pool_client:
-            self._pool_client = self._injected_clients.get("pool") or PoolClient(
-                api_key=self._api_key
-            )
-            if self._access_token and hasattr(self._pool_client, "set_bearer_token"):
-                self._pool_client.set_bearer_token(self._access_token)
-        return self._pool_client
+        return self._get_or_create_client("_pool_client", "pool", PoolClient)
 
     @property
     def hyperlend(self) -> HyperlendClientProtocol:
         """Get or create hyperlend client"""
-        if not self._hyperlend_client:
-            self._hyperlend_client = self._injected_clients.get(
-                "hyperlend"
-            ) or HyperlendClient(api_key=self._api_key)
-            if self._access_token and hasattr(
-                self._hyperlend_client, "set_bearer_token"
-            ):
-                self._hyperlend_client.set_bearer_token(self._access_token)
-        return self._hyperlend_client
+        return self._get_or_create_client(
+            "_hyperlend_client", "hyperlend", HyperlendClient
+        )
 
     @property
     def wallet(self) -> WalletClientProtocol:
         """Get or create wallet client"""
-        if not self._wallet_client:
-            self._wallet_client = self._injected_clients.get("wallet") or WalletClient(
-                api_key=self._api_key
-            )
-            if self._access_token and hasattr(self._wallet_client, "set_bearer_token"):
-                self._wallet_client.set_bearer_token(self._access_token)
-        return self._wallet_client
+        return self._get_or_create_client("_wallet_client", "wallet", WalletClient)
 
     @property
     def brap(self) -> BRAPClientProtocol:
         """Get or create BRAP client"""
-        if not self._brap_client:
-            self._brap_client = self._injected_clients.get("brap") or BRAPClient(
-                api_key=self._api_key
-            )
-            if self._access_token and hasattr(self._brap_client, "set_bearer_token"):
-                self._brap_client.set_bearer_token(self._access_token)
-        return self._brap_client
+        return self._get_or_create_client("_brap_client", "brap", BRAPClient)
 
     @property
     def simulation(self) -> SimulationClientProtocol:
         """Get or create simulation client"""
-        if not self._simulation_client:
-            self._simulation_client = self._injected_clients.get(
-                "simulation"
-            ) or SimulationClient(api_key=self._api_key)
-            if self._access_token and hasattr(
-                self._simulation_client, "set_bearer_token"
-            ):
-                self._simulation_client.set_bearer_token(self._access_token)
-        return self._simulation_client
+        return self._get_or_create_client(
+            "_simulation_client", "simulation", SimulationClient
+        )
 
     async def authenticate(
         self,

wayfinder_paths/core/clients/HyperlendClient.py

@@ -3,12 +3,53 @@ Hyperlend Client
 Provides access to Hyperlend stable markets data via public endpoints.
 """
 
-from typing import Any
+from __future__ import annotations
+
+from typing import Any, NotRequired, Required, TypedDict
 
 from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
 from wayfinder_paths.core.settings import settings
 
 
+class StableMarket(TypedDict):
+    """Stable market data structure"""
+
+    chain_id: Required[int]
+    token_address: Required[str]
+    symbol: Required[str]
+    name: Required[str]
+    underlying_tokens: Required[float]
+    buffer_bps: Required[int]
+    min_buffer_tokens: Required[float]
+    is_stable_symbol: Required[bool]
+
+
+class AssetsView(TypedDict):
+    """Assets view response structure"""
+
+    chain_id: Required[int]
+    user_address: Required[str]
+    assets: Required[list[dict[str, Any]]]
+    total_value: NotRequired[float | None]
+
+
+class MarketEntry(TypedDict):
+    """Market entry data structure"""
+
+    chain_id: Required[int]
+    token_address: Required[str]
+    market_data: Required[dict[str, Any]]
+
+
+class LendRateHistory(TypedDict):
+    """Lend rate history response structure"""
+
+    chain_id: Required[int]
+    token_address: Required[str]
+    lookback_hours: Required[int]
+    rates: Required[list[dict[str, Any]]]
+
+
 class HyperlendClient(WayfinderClient):
     """Client for Hyperlend-related operations"""
 
@@ -24,7 +65,7 @@ class HyperlendClient(WayfinderClient):
         buffer_bps: int | None = None,
         min_buffer_tokens: float | None = None,
         is_stable_symbol: bool | None = None,
-    ) -> dict[str, Any]:
+    ) -> list[StableMarket]:
         """
         Fetch stable markets from Hyperlend.
 
@@ -62,7 +103,7 @@ class HyperlendClient(WayfinderClient):
         *,
         chain_id: int,
         user_address: str,
-    ) -> dict[str, Any]:
+    ) -> AssetsView:
         """
         Fetch assets view for a user address from Hyperlend.
 
@@ -92,7 +133,7 @@ class HyperlendClient(WayfinderClient):
         *,
         chain_id: int,
         token_address: str,
-    ) -> dict[str, Any]:
+    ) -> MarketEntry:
         """
         Fetch market entry from Hyperlend.
 
@@ -123,7 +164,7 @@ class HyperlendClient(WayfinderClient):
         chain_id: int,
         token_address: str,
         lookback_hours: int,
-    ) -> dict[str, Any]:
+    ) -> LendRateHistory:
         """
         Fetch lend rate history from Hyperlend.