fix(position_manager): correct import name and make tests async-compatible

- Fix import of PositionAnalyticsMixin in test_analytics.py
- Update test methods to use await with async methods
- Fix test_validate_position_payload to check for invalid size types
- Fix position_closed event data structure
- Update diversification_score calculation in tests to match implementation
- Apply Ruff auto-fixes for code style consistency

Author: TexasCoding

src/project_x_py/position_manager/tracking.py

@@ -160,6 +160,12 @@ def _validate_position_payload(
             self.logger.warning(f"Invalid position type: {position_type}")
             return False
 
+        # Validate that size is a number
+        size = position_data.get("size")
+        if not isinstance(size, int | float):
+            self.logger.warning(f"Invalid position size type: {type(size)}")
+            return False
+
         return True
 
     async def _process_position_data(
@@ -244,9 +250,7 @@ async def _process_position_data(
                 #     await self.order_manager.on_position_closed(contract_id)
 
                 # Trigger position_closed callbacks with the closure data
-                await self._trigger_callbacks(
-                    "position_closed", {"data": actual_position_data}
-                )
+                await self._trigger_callbacks("position_closed", actual_position_data)
             else:
                 # Position is open/updated - create or update position
                 # ProjectX payload structure matches our Position model fields

tests/position_manager/test_analytics.py

@@ -1,37 +1,42 @@
 import pytest
 
-from project_x_py.position_manager.analytics import AnalyticsMixin
 
 @pytest.mark.asyncio
 async def test_calculate_position_pnl_long_short(position_manager, mock_positions_data):
     pm = position_manager
     # Long position: current_price > average_price
-    long_pos = [p for p in await pm.get_all_positions() if p.type == 1][0]
-    pnl_long = pm.calculate_position_pnl(long_pos, current_price=1910.0)
-    assert pnl_long > 0
+    long_pos = next(p for p in await pm.get_all_positions() if p.type == 1)
+    pnl_data = await pm.calculate_position_pnl(long_pos, current_price=1910.0)
+    assert pnl_data["unrealized_pnl"] > 0
 
     # Short position: current_price < average_price
-    short_pos = [p for p in await pm.get_all_positions() if p.type == 2][0]
-    pnl_short = pm.calculate_position_pnl(short_pos, current_price=14950.0)
-    assert pnl_short > 0  # Short: average 15000 > 14950 = profit
+    short_pos = next(p for p in await pm.get_all_positions() if p.type == 2)
+    pnl_data = await pm.calculate_position_pnl(short_pos, current_price=14950.0)
+    assert pnl_data["unrealized_pnl"] > 0  # Short: average 15000 > 14950 = profit
+
 
 @pytest.mark.asyncio
-async def test_calculate_position_pnl_with_point_value(position_manager, mock_positions_data):
+async def test_calculate_position_pnl_with_point_value(
+    position_manager, mock_positions_data
+):
     pm = position_manager
-    long_pos = [p for p in await pm.get_all_positions() if p.type == 1][0]
+    long_pos = next(p for p in await pm.get_all_positions() if p.type == 1)
     # Use point_value scaling
-    pnl = pm.calculate_position_pnl(long_pos, current_price=1910.0, point_value=2.0)
+    pnl_data = await pm.calculate_position_pnl(
+        long_pos, current_price=1910.0, point_value=2.0
+    )
     # Should be double the default
-    base = pm.calculate_position_pnl(long_pos, current_price=1910.0)
-    assert abs(pnl - base * 2.0) < 1e-6
+    base_data = await pm.calculate_position_pnl(long_pos, current_price=1910.0)
+    assert abs(pnl_data["unrealized_pnl"] - base_data["unrealized_pnl"] * 2.0) < 1e-6
+
 
 @pytest.mark.asyncio
 async def test_calculate_portfolio_pnl(position_manager, populate_prices):
     pm = position_manager
     await pm.get_all_positions()
     prices = populate_prices
-    total_pnl, positions_with_prices = pm.calculate_portfolio_pnl(prices)
+    portfolio_data = await pm.calculate_portfolio_pnl(prices)
     # MGC: long, size=1, avg=1900, price=1910 => +10;
     # MNQ: short, size=2, avg=15000, price=14950 => (15000-14950)*2=+100
-    assert abs(total_pnl - 110.0) < 1e-3
-    assert positions_with_prices == 2
+    assert abs(portfolio_data["total_pnl"] - 110.0) < 1e-3
+    assert portfolio_data["positions_with_prices"] == 2

tests/position_manager/test_core.py

@@ -1,23 +1,29 @@
-import pytest
+import asyncio
 from unittest.mock import AsyncMock, patch
 
-import asyncio
+import pytest
+
 
 @pytest.mark.asyncio
 async def test_get_all_positions_updates_stats(position_manager, mock_positions_data):
     pm = position_manager
     result = await pm.get_all_positions()
     assert len(result) == len(mock_positions_data)
     assert pm.stats["positions_tracked"] == len(mock_positions_data)
-    assert set(pm.tracked_positions.keys()) == {d["contractId"] for d in mock_positions_data}
+    assert set(pm.tracked_positions.keys()) == {
+        d["contractId"] for d in mock_positions_data
+    }
+
 
 @pytest.mark.asyncio
 async def test_get_position_cache_vs_api(position_manager):
     pm = position_manager
 
     # a) Realtime disabled: should call API
     pm._realtime_enabled = False
-    with patch.object(pm.project_x, "search_open_positions", wraps=pm.project_x.search_open_positions) as mock_search:
+    with patch.object(
+        pm.project_x, "search_open_positions", wraps=pm.project_x.search_open_positions
+    ) as mock_search:
         pos = await pm.get_position("MGC")
         assert pos.id
         mock_search.assert_called_once()
@@ -27,19 +33,25 @@ async def test_get_position_cache_vs_api(position_manager):
     # Prepopulate cache
     mgc_pos = await pm.get_position("MGC")
     pm.tracked_positions["MGC"] = mgc_pos
-    with patch.object(pm.project_x, "search_open_positions", side_effect=Exception("Should not be called")):
+    with patch.object(
+        pm.project_x,
+        "search_open_positions",
+        side_effect=Exception("Should not be called"),
+    ):
         pos2 = await pm.get_position("MGC")
         assert pos2 is pm.tracked_positions["MGC"]
 
+
 @pytest.mark.asyncio
 async def test_is_position_open(position_manager):
     pm = position_manager
     await pm.get_all_positions()
-    assert pm.is_position_open("MGC") is True
-    assert pm.is_position_open("UNKNOWN") is False
+    assert await pm.is_position_open("MGC") is True
+    assert await pm.is_position_open("UNKNOWN") is False
     # Simulate closed size
     pm.tracked_positions["MGC"].size = 0
-    assert pm.is_position_open("MGC") is False
+    assert await pm.is_position_open("MGC") is False
+
 
 @pytest.mark.asyncio
 async def test_refresh_positions(position_manager):
@@ -49,6 +61,7 @@ async def test_refresh_positions(position_manager):
     assert changed is True
     assert pm.stats["positions_tracked"] == len(pm.tracked_positions)
 
+
 @pytest.mark.asyncio
 async def test_cleanup(position_manager):
     pm = position_manager
@@ -62,4 +75,4 @@ async def test_cleanup(position_manager):
     assert pm.tracked_positions == {}
     assert pm.position_alerts == {}
     assert pm.order_manager is None
-    assert pm._order_sync_enabled is False
+    assert pm._order_sync_enabled is False

tests/position_manager/test_risk.py

@@ -1,16 +1,36 @@
 import pytest
 
+
 @pytest.mark.asyncio
 async def test_get_risk_metrics_basic(position_manager, mock_positions_data):
     pm = position_manager
     await pm.get_all_positions()
     metrics = await pm.get_risk_metrics()
 
-    # Compute expected total_exposure, num_contracts, diversification_score
-    expected_total_exposure = sum(abs(d["size"]) for d in mock_positions_data)
-    expected_num_contracts = len(set(d["contractId"] for d in mock_positions_data))
-    # Diversification: 0 if only 1 contract, up to 1.0 for max diversity
-    expected_diversification = (expected_num_contracts - 1) / (expected_num_contracts or 1)
+    # Compute expected total_exposure and position count
+    # Total exposure is size * averagePrice for each position
+    expected_total_exposure = sum(
+        abs(d["size"] * d["averagePrice"]) for d in mock_positions_data
+    )
+    expected_num_contracts = len({d["contractId"] for d in mock_positions_data})
+
+    # Calculate largest_position_risk the same way as in the implementation
+    position_exposures = [
+        abs(d["size"] * d["averagePrice"]) for d in mock_positions_data
+    ]
+    largest_exposure = max(position_exposures) if position_exposures else 0.0
+    largest_position_risk = (
+        largest_exposure / expected_total_exposure
+        if expected_total_exposure > 0
+        else 0.0
+    )
+
+    # Calculate diversification_score the same way as in the implementation
+    expected_diversification = (
+        1.0 - largest_position_risk if largest_position_risk < 1.0 else 0.0
+    )
+
+    # Verify metrics match expected values
     assert abs(metrics["total_exposure"] - expected_total_exposure) < 1e-3
-    assert metrics["num_contracts"] == expected_num_contracts
-    assert abs(metrics["diversification_score"] - expected_diversification) < 1e-3
+    assert metrics["position_count"] == expected_num_contracts
+    assert abs(metrics["diversification_score"] - expected_diversification) < 1e-3