ctrader-api-client 0.2.1__tar.gz → 0.2.3__tar.gz

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/.pre-commit-config.yaml

@@ -1,4 +1,12 @@
 repos:
+  - repo: local
+    hooks:
+      - id: local-ci
+        name: Local CI Checks
+        entry: just ci
+        language: system
+        pass_filenames: false
+
   # Ruff for linting & formatting
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.12.9

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/Justfile

@@ -15,6 +15,7 @@ ci directory='':
     @just lint {{directory}}
     @just fmt {{directory}}
     @just type-check {{directory}}
+    @just test {{directory}}
 
 # Lint the codebase using ruff, optionally specifying a directory to lint.
 lint directory='':

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctrader-api-client
-Version: 0.2.1
+Version: 0.2.3
 Summary: API Client to interact with the cTrader Open API spec
 Author-email: Elio <elioachukri@pm.me>
 License-File: LICENSE

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ctrader-api-client"
-version = "0.2.1"
+version = "0.2.3"
 description = "API Client to interact with the cTrader Open API spec"
 readme = "README.md"
 authors = [

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/src/ctrader_api_client/api/market_data.py

@@ -372,7 +372,7 @@ class MarketDataAPI:
                 description=f"Expected ProtoOAGetTrendbarsRes, got {type(response).__name__}",
             )
 
-        return [Trendbar.from_proto(t) for t in response.trendbar]
+        return [Trendbar.from_proto(t, historical=True) for t in response.trendbar]
 
     async def get_tick_data(
         self,

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/src/ctrader_api_client/config.py

@@ -13,7 +13,7 @@ class ClientConfig(BaseModel):
         client_id: OAuth application client ID.
         client_secret: OAuth application client secret.
         heartbeat_interval: Seconds between heartbeat sends.
-        heartbeat_timeout: Seconds without server heartbeat before disconnect. Set to 0 to disable.
+        heartbeat_timeout: Seconds without server-initiated messages before disconnect. Set to 0 to disable.
         request_timeout: Default timeout for API requests in seconds.
         reconnect_attempts: Max reconnection attempts (0 to disable).
         reconnect_min_wait: Initial wait between reconnection attempts.
@@ -43,7 +43,7 @@ class ClientConfig(BaseModel):
 
     # Heartbeat settings
     heartbeat_interval: float = Field(default=10.0, gt=0)
-    heartbeat_timeout: float = Field(default=0, ge=0)
+    heartbeat_timeout: float = Field(default=60.0, ge=0)
 
     # Request settings
     request_timeout: float = Field(default=30.0, gt=0)

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/src/ctrader_api_client/connection/heartbeat.py

@@ -5,6 +5,7 @@ import time
 
 import anyio
 import anyio.abc
+import betterproto
 
 from .._internal.proto import ProtoHeartbeatEvent
 from .protocol import Protocol
@@ -43,10 +44,11 @@ class HeartbeatManager:
     async def start(self) -> None:
         """Start heartbeat monitoring.
 
-        Registers an event handler for incoming heartbeats and starts
-        the heartbeat send loop.
+        Registers event handlers and starts the heartbeat send loop.
         """
-        # Register handler for incoming heartbeats
+        # Track activity on any server message, not just heartbeats
+        self._protocol.on_event(betterproto.Message, self._record_activity)
+        # Keep heartbeat handler for debug logging
         self._protocol.on_event(ProtoHeartbeatEvent, self._on_heartbeat)
         self._last_received = time.monotonic()
 
@@ -58,7 +60,7 @@ class HeartbeatManager:
     async def stop(self) -> None:
         """Stop heartbeat monitoring.
 
-        Cancels the heartbeat loop and removes the event handler.
+        Cancels the heartbeat loop and removes event handlers.
         """
         if self._task_scope is not None:
             self._task_scope.cancel()
@@ -71,6 +73,7 @@ class HeartbeatManager:
                 pass
             self._task_group = None
 
+        self._protocol.remove_handler(betterproto.Message, self._record_activity)
         self._protocol.remove_handler(ProtoHeartbeatEvent, self._on_heartbeat)
 
     async def restart(self) -> None:
@@ -83,13 +86,12 @@ class HeartbeatManager:
         if self._task_group is not None:
             self._task_group.start_soon(self._heartbeat_loop)
 
-    async def _on_heartbeat(self, _event: ProtoHeartbeatEvent) -> None:
-        """Handler called when heartbeat received from server.
-
-        Args:
-            _event: The heartbeat event from the server (unused).
-        """
+    async def _record_activity(self, _message: betterproto.Message) -> None:
+        """Reset the inactivity timer on any received server message."""
         self._last_received = time.monotonic()
+
+    async def _on_heartbeat(self, _event: ProtoHeartbeatEvent) -> None:
+        """Handler called when an explicit heartbeat is received from the server."""
         logger.debug("Heartbeat received from server")
 
     async def _heartbeat_loop(self) -> None:

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/src/ctrader_api_client/connection/protocol.py

@@ -276,17 +276,20 @@ class Protocol:
 
         Handlers are spawned as concurrent tasks to prevent deadlocks if
         handlers perform some blocking I/O calls that require responses from the reader loop.
+        Walks the MRO so handlers registered for a base class (e.g. betterproto.Message)
+        are also called for all subclass messages.
 
         Args:
             message: The event message to dispatch.
         """
-        handlers = self._event_handlers.get(type(message), [])
-        for handler in handlers:
-            if self._task_group is not None:
-                self._task_group.start_soon(self._call_handler_safe, handler, message)
-            else:
-                # Fallback if task group not available (shouldn't happen in normal operation)
-                await self._call_handler_safe(handler, message)
+        for cls in type(message).__mro__:
+            handlers = self._event_handlers.get(cls, [])
+            for handler in handlers:
+                if self._task_group is not None:
+                    self._task_group.start_soon(self._call_handler_safe, handler, message)
+                else:
+                    # Fallback if task group not available (shouldn't happen in normal operation)
+                    await self._call_handler_safe(handler, message)
 
     @staticmethod
     async def _call_handler_safe(

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/src/ctrader_api_client/models/market_data.py

@@ -56,17 +56,15 @@ class Trendbar(FrozenModel):
     volume: int
 
     @classmethod
-    def from_proto(cls, proto: ProtoOATrendbar, bid_price: float | None = None) -> Trendbar:
-        """Create Trendbar from proto message.
+    def from_proto(cls, proto: ProtoOATrendbar, bid_price: float | None = None, historical: bool = False) -> Trendbar:
+        """Create a Trendbar from a proto message.
 
         Args:
-            proto: The proto message.
-            bid_price: Optional bid price to use for specifying the close price since the API never provides delta_close
-                 on live trendbar updates.
-
-        Returns:
-            A new Trendbar instance.
+            proto: Source proto message.
+            bid_price: Bid price used as close when the API omits delta_close on live updates.
+            historical: If False, raises on delta_close == 0 instead of silently returning low == close.
         """
+
         # Calculate timestamp from utc_timestamp_in_minutes
         ts = datetime.now(UTC)
         if proto.utc_timestamp_in_minutes:
@@ -80,12 +78,14 @@ class Trendbar(FrozenModel):
         if bid_price is not None:
             close = bid_price
         else:
-            if proto.delta_close == 0:
-                # If delta_close is 0, it means the API did not provide a close price (e.g. for live updates).
+            if not historical and proto.delta_close == 0:
+                # If delta_close is 0 on a live bar, it means the API did not provide a close price.
                 # In this case, we must raise instead of silently returning an incorrect close price.
+                # If historical is True, we allow delta_close to be 0 since historical bars can have a close price equal
+                # to the low price.
                 raise RuntimeError(
                     "delta_close missing from Trendbar proto and no bid_price was provided to use as fallback."
-                    "Returning error as this is safer than silently returning an incorrect close price of low + 0."
+                    " Returning error as this is safer than silently returning an incorrect close price of low + 0."
                 )
             close = low + proto.delta_close
 

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/tests/unit/connection/test_heartbeat.py

@@ -6,9 +6,10 @@ import time
 from unittest.mock import AsyncMock, MagicMock
 
 import anyio
+import betterproto
 import pytest
 
-from ctrader_api_client._internal.proto import ProtoHeartbeatEvent
+from ctrader_api_client._internal.proto import ProtoHeartbeatEvent, ProtoOAVersionRes
 from ctrader_api_client.connection.heartbeat import HeartbeatManager
 from ctrader_api_client.connection.protocol import Protocol
 
@@ -55,10 +56,10 @@ class TestHeartbeatStart:
         await heartbeat.start()
 
         try:
-            # Check that on_event was called with ProtoHeartbeatEvent
-            mock_protocol.on_event.assert_called_once()
-            call_args = mock_protocol.on_event.call_args
-            assert call_args[0][0] is ProtoHeartbeatEvent
+            assert mock_protocol.on_event.call_count == 2
+            registered_types = [call[0][0] for call in mock_protocol.on_event.call_args_list]
+            assert betterproto.Message in registered_types
+            assert ProtoHeartbeatEvent in registered_types
         finally:
             await heartbeat.stop()
 
@@ -86,9 +87,10 @@ class TestHeartbeatStop:
         await heartbeat.start()
         await heartbeat.stop()
 
-        mock_protocol.remove_handler.assert_called_once()
-        call_args = mock_protocol.remove_handler.call_args
-        assert call_args[0][0] is ProtoHeartbeatEvent
+        assert mock_protocol.remove_handler.call_count == 2
+        removed_types = [call[0][0] for call in mock_protocol.remove_handler.call_args_list]
+        assert betterproto.Message in removed_types
+        assert ProtoHeartbeatEvent in removed_types
 
     @pytest.mark.anyio
     async def test_stop_cancels_loop(self, mock_protocol: MagicMock) -> None:
@@ -105,16 +107,27 @@ class TestHeartbeatReceived:
     """Tests for heartbeat event handling."""
 
     @pytest.mark.anyio
-    async def test_heartbeat_updates_last_received(self, mock_protocol: MagicMock) -> None:
+    async def test_record_activity_updates_last_received(self, mock_protocol: MagicMock) -> None:
         heartbeat = HeartbeatManager(mock_protocol)
 
         initial_time = time.monotonic() - 100  # Set to past
         heartbeat._last_received = initial_time
 
-        await heartbeat._on_heartbeat(ProtoHeartbeatEvent())
+        await heartbeat._record_activity(ProtoHeartbeatEvent())
 
         assert heartbeat._last_received > initial_time
 
+    @pytest.mark.anyio
+    async def test_on_heartbeat_does_not_update_last_received(self, mock_protocol: MagicMock) -> None:
+        heartbeat = HeartbeatManager(mock_protocol)
+
+        initial_time = time.monotonic() - 100
+        heartbeat._last_received = initial_time
+
+        await heartbeat._on_heartbeat(ProtoHeartbeatEvent())
+
+        assert heartbeat._last_received == initial_time
+
 
 class TestHeartbeatSend:
     """Tests for heartbeat sending."""
@@ -163,15 +176,28 @@ class TestHeartbeatTimeout:
         await heartbeat.start()
 
         try:
-            # Simulate receiving heartbeats
             for _ in range(3):
                 await anyio.sleep(0.03)
-                await heartbeat._on_heartbeat(ProtoHeartbeatEvent())
+                await heartbeat._record_activity(ProtoHeartbeatEvent())
+        finally:
+            await heartbeat.stop()
+
+        mock_protocol.handle_disconnect.assert_not_called()
+
+    @pytest.mark.anyio
+    async def test_no_timeout_when_non_heartbeat_messages_received(self, mock_protocol: MagicMock) -> None:
+        heartbeat = HeartbeatManager(mock_protocol, interval=0.02, timeout=0.1)
+
+        await heartbeat.start()
+
+        try:
+            for _ in range(3):
+                await anyio.sleep(0.03)
+                await heartbeat._record_activity(ProtoOAVersionRes())
         finally:
             await heartbeat.stop()
 
-        # Disconnect should not have been triggered
-        mock_protocol._handle_disconnect.assert_not_called()
+        mock_protocol.handle_disconnect.assert_not_called()
 
 
 class TestHeartbeatSendFailure:

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/tests/unit/connection/test_protocol.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from unittest.mock import AsyncMock, MagicMock
 
 import anyio
+import betterproto
 import pytest
 
 from ctrader_api_client._internal.proto import (
@@ -348,6 +349,28 @@ class TestMessageDispatch:
 
         assert len(received) == 1
 
+    @pytest.mark.anyio
+    async def test_dispatch_triggers_base_class_handler(self, mock_transport: MagicMock) -> None:
+        protocol = Protocol(mock_transport)
+
+        received: list[betterproto.Message] = []
+
+        async def catch_all(message: betterproto.Message) -> None:
+            received.append(message)
+
+        protocol.on_event(betterproto.Message, catch_all)
+
+        proto_msg = ProtoMessage(
+            payload_type=ProtoPayloadType.HEARTBEAT_EVENT,
+            client_msg_id="",
+        )
+        inner = ProtoHeartbeatEvent()
+
+        await protocol._dispatch_message(proto_msg, inner)
+
+        assert len(received) == 1
+        assert isinstance(received[0], ProtoHeartbeatEvent)
+
 
 class TestReconnect:
     """Tests for reconnection logic."""

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/tests/unit/models/test_market_data.py

@@ -62,7 +62,7 @@ class TestTrendbarFromProto:
 
         for proto_value, expected_period in test_cases:
             proto.period = proto_value
-            bar = Trendbar.from_proto(proto)
+            bar = Trendbar.from_proto(proto, bid_price=10)
             assert bar.period == expected_period
 
     def test_from_proto_converts_timestamp(self) -> None:
@@ -77,7 +77,7 @@ class TestTrendbarFromProto:
         proto.delta_close = 0
         proto.volume = 1000
 
-        bar = Trendbar.from_proto(proto)
+        bar = Trendbar.from_proto(proto, bid_price=10)
 
         assert bar.timestamp == datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
 

{ctrader_api_client-0.2.1 → ctrader_api_client-0.2.3}/uv.lock

@@ -201,7 +201,7 @@ wheels = [
 
 [[package]]
 name = "ctrader-api-client"
-version = "0.2.1"
+version = "0.2.3"
 source = { editable = "." }
 dependencies = [
     { name = "anyio" },