ctrader-api-client 0.7.3__tar.gz → 0.8.1__tar.gz

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ctrader-api-client
-Version: 0.7.3
+Version: 0.8.1
 Summary: API Client to interact with the cTrader Open API spec
 Author-email: Elio <elioachukri@pm.me>
 License-File: LICENSE
@@ -15,6 +15,7 @@ Requires-Dist: anyio>=4.13.0
 Requires-Dist: betterproto[compiler]>=1.2.5
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: tenacity>=9.1.4
+Requires-Dist: tzdata>=2025.2
 Description-Content-Type: text/markdown
 
 # cTrader API Client
@@ -301,6 +302,17 @@ results = await client.symbols.search(account_id, "EUR")
 
 # Get specific symbol
 symbol = await client.symbols.get_by_id(account_id, symbol_id)
+
+# Trading hours arrive with the symbol, so this costs no extra request
+hours = symbol.trading_hours
+if hours.is_open():
+    print(f"Open, closes at {hours.next_close()}")
+else:
+    print(f"Closed, opens at {hours.next_open()}")
+
+# Sessions for a given day, with broker holidays already applied
+for session in hours.sessions_on(date(2026, 6, 19)):
+    print(session.start, "->", session.end)
 ```
 
 ### Account Information
@@ -354,10 +366,14 @@ config = ClientConfig(
     heartbeat_timeout=30.0, # Or 0 to disable server heartbeat checks
     request_timeout=30.0,
 
-    # Reconnection
-    reconnect_attempts=5,
+    # Reconnection: None retries for as long as the client is open (the
+    # default), an integer caps the attempts, 0 disables reconnection. A
+    # finite budget that runs out raises CTraderReconnectAbandonedError out
+    # of the `async with client:` block.
+    reconnect_attempts=None,
     reconnect_min_wait=1.0,
     reconnect_max_wait=60.0,
+    connect_timeout=30.0,
 
     # Token refresh: when to refresh access tokens and how hard to retry
     refresh_policy=RefreshPolicy(

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/README.md

@@ -282,6 +282,17 @@ results = await client.symbols.search(account_id, "EUR")
 
 # Get specific symbol
 symbol = await client.symbols.get_by_id(account_id, symbol_id)
+
+# Trading hours arrive with the symbol, so this costs no extra request
+hours = symbol.trading_hours
+if hours.is_open():
+    print(f"Open, closes at {hours.next_close()}")
+else:
+    print(f"Closed, opens at {hours.next_open()}")
+
+# Sessions for a given day, with broker holidays already applied
+for session in hours.sessions_on(date(2026, 6, 19)):
+    print(session.start, "->", session.end)
 ```
 
 ### Account Information
@@ -335,10 +346,14 @@ config = ClientConfig(
     heartbeat_timeout=30.0, # Or 0 to disable server heartbeat checks
     request_timeout=30.0,
 
-    # Reconnection
-    reconnect_attempts=5,
+    # Reconnection: None retries for as long as the client is open (the
+    # default), an integer caps the attempts, 0 disables reconnection. A
+    # finite budget that runs out raises CTraderReconnectAbandonedError out
+    # of the `async with client:` block.
+    reconnect_attempts=None,
     reconnect_min_wait=1.0,
     reconnect_max_wait=60.0,
+    connect_timeout=30.0,
 
     # Token refresh: when to refresh access tokens and how hard to retry
     refresh_policy=RefreshPolicy(

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/docs/api/exceptions.md

@@ -153,6 +153,32 @@ other handlers for that event.
     options:
       show_source: false
 
+::: ctrader_api_client.CTraderReconnectAbandonedError
+    options:
+      show_source: false
+
+This is the one connection exception that reaches you without your having called
+anything: it is raised out of the `async with client:` block itself. Reconnection
+is unbounded by default, so seeing it means either that `reconnect_attempts` was
+set to a finite number and every one was spent, or that something failed which
+the reconnection logic did not anticipate.
+
+```python
+while True:
+    try:
+        async with client:
+            await asyncio.Event().wait()
+    except CTraderReconnectAbandonedError:
+        logger.exception("Client abandoned its connection; starting a new one")
+        await asyncio.sleep(30)
+```
+
+Catching it is only worthwhile if you intend to build a fresh client, since the
+one that raised it is finished. Letting it propagate and having a process
+supervisor restart you is an equally good answer, and the reason it is raised
+rather than logged: a client that has stopped reconnecting has no reader and no
+heartbeat left to notice anything, so nothing short of a restart brings it back.
+
 ### Authentication
 
 ::: ctrader_api_client.AuthenticationError

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/docs/api/models.md

@@ -130,6 +130,26 @@ partial_close = ClosePositionRequest(
       show_source: false
 
 
+::: ctrader_api_client.models.TradingHours
+    options:
+      show_source: false
+
+
+::: ctrader_api_client.models.TradingSession
+    options:
+      show_source: false
+
+
+::: ctrader_api_client.models.ScheduleInterval
+    options:
+      show_source: false
+
+
+::: ctrader_api_client.models.Holiday
+    options:
+      show_source: false
+
+
 ::: ctrader_api_client.models.Account
     options:
       show_source: false

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/docs/api/symbols.md

@@ -58,6 +58,64 @@ for sym in eur_pairs:
     print(sym.name)
 ```
 
+## Trading Hours
+
+Every `Symbol` arrives with its trading calendar attached, so asking when a symbol is open
+costs no extra request:
+
+```python
+from datetime import date
+
+symbol = await client.symbols.get_by_id(account_id, 270)
+hours = symbol.trading_hours
+
+if hours.is_open():
+    print("open now, closes at", hours.next_close())
+else:
+    print("closed, opens at", hours.next_open())
+
+for session in hours.sessions_on(date(2026, 6, 19)):
+    print(session.start, "->", session.end, f"({session.duration})")
+```
+
+Sessions are reported in the symbol's own `schedule_timezone` and are never merged, so a
+schedule with a nightly maintenance break reports one session either side of it.
+
+### Holidays
+
+Holidays are closed windows that cut into the weekly schedule rather than replacing a whole
+day. A broker publishing an "early close" sends a window covering the rest of the day, which
+brings the close forward:
+
+```python
+# Regular Friday: 01:05 - 23:50. With a 20:00 early close holiday:
+hours.sessions_on(date(2026, 6, 19))  # -> one session, 01:05 - 20:00
+
+hours.holidays_on(date(2026, 6, 19))  # -> the holiday responsible
+```
+
+A holiday carries **its own** timezone, which is not always the symbol's. A closure defined in
+a timezone an hour behind the symbol's straddles two of the symbol's calendar days, and both
+are shortened accordingly.
+
+A holiday whose window is empty (`start_second >= end_second`, which brokers send as `0`/`0`)
+closes the entire day.
+
+### Trading mode is separate
+
+`is_open()` answers the calendar question only. A symbol can be closed to trading by its
+`trading_mode` while the schedule says it is open, so check both:
+
+```python
+tradable = hours.is_open() and symbol.trading_mode == TradingMode.ENABLED
+```
+
+### Staleness
+
+Schedules arrive only with a symbol fetch, so a long-lived `Symbol` can drift. Subscribe to
+`SymbolChangedEvent` and re-fetch when the server reports a change. The API exposes no
+historical schedules — what you receive is the current configuration.
+
 ## Volume Conversion
 
 The cTrader API uses volume in "cents" (smallest volume units). The relationship between lots and volume depends on the symbol's `lot_size`:

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/docs/getting-started.md

@@ -312,13 +312,22 @@ config = ClientConfig(
     heartbeat_timeout=0,  # 0 to disable server heartbeat checks (default)
     request_timeout=30.0,
 
-    # Reconnection
-    reconnect_attempts=5,
+    # Reconnection: None retries for as long as the client is open (the
+    # default), an integer caps the attempts, 0 disables reconnection.
+    reconnect_attempts=None,
     reconnect_min_wait=1.0,
     reconnect_max_wait=60.0,
+    connect_timeout=30.0,
 )
 ```
 
+Reconnection is unbounded by default because a finite budget that runs out
+leaves a client that can never recover: there is no reader and no heartbeat left
+to notice anything, so it stays offline until the process restarts. If you do
+set a finite `reconnect_attempts`, spending it raises
+`CTraderReconnectAbandonedError` out of the `async with client:` block rather
+than leaving the client alive and permanently disconnected.
+
 ## Next Steps
 
 - [API Reference - Client](api/client.md) - Full client documentation

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ctrader-api-client"
-version = "0.7.3"
+version = "0.8.1"
 description = "API Client to interact with the cTrader Open API spec"
 readme = "README.md"
 authors = [
@@ -20,6 +20,9 @@ dependencies = [
     "betterproto[compiler]>=1.2.5",
     "pydantic>=2.12.5",
     "tenacity>=9.1.4",
+    # Windows ships no system IANA database, which ZoneInfo needs to resolve the
+    # broker-supplied timezones that trading schedules are expressed in.
+    "tzdata>=2025.2",
 ]
 
 [build-system]

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/src/ctrader_api_client/__init__.py

@@ -92,12 +92,14 @@ from .exceptions import (
     CTraderConnectionFailedError,
     CTraderConnectionTimeoutError,
     CTraderError,
+    CTraderReconnectAbandonedError,
     DeserializationError,
     FramingError,
     ProtocolError,
     TokenExpiredError,
     TokenRefreshError,
     UnknownPayloadTypeError,
+    UnknownTimezoneError,
 )
 from .models import (
     Account,
@@ -107,13 +109,17 @@ from .models import (
     CloseDetail,
     ClosePositionRequest,
     Deal,
+    Holiday,
     NewOrderRequest,
     Order,
     Position,
     PositionUnrealizedPnL,
+    ScheduleInterval,
     Symbol,
     SymbolInfo,
     TickData,
+    TradingHours,
+    TradingSession,
     Trendbar,
 )
 
@@ -139,6 +145,7 @@ __all__ = [
     "CTraderConnectionFailedError",
     "CTraderConnectionTimeoutError",
     "CTraderError",
+    "CTraderReconnectAbandonedError",
     "ClientConfig",
     "ClientDisconnectEvent",
     "CloseDetail",
@@ -152,6 +159,7 @@ __all__ = [
     "ExecutionEvent",
     "ExecutionType",
     "FramingError",
+    "Holiday",
     "MarginCallTriggerEvent",
     "MarginChangeEvent",
     "NewOrderRequest",
@@ -168,6 +176,7 @@ __all__ = [
     "ReauthPolicy",
     "ReconnectedEvent",
     "RefreshPolicy",
+    "ScheduleInterval",
     "SpotEvent",
     "StopTriggerMethod",
     "SubscriptionRestoreFailedEvent",
@@ -182,9 +191,12 @@ __all__ = [
     "TokenRefreshFailedEvent",
     "TokenStore",
     "TraderUpdateEvent",
+    "TradingHours",
     "TradingMode",
+    "TradingSession",
     "TrailingStopChangedEvent",
     "Trendbar",
     "TrendbarPeriod",
     "UnknownPayloadTypeError",
+    "UnknownTimezoneError",
 ]

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/src/ctrader_api_client/composition.py

@@ -78,6 +78,7 @@ def build_graph(
         host=config.host,
         port=config.port,
         use_ssl=config.use_ssl,
+        connect_timeout=config.connect_timeout,
     )
     protocol = Protocol(
         transport=transport,

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/src/ctrader_api_client/config.py

@@ -17,7 +17,12 @@ class ClientConfig(BaseModel):
         heartbeat_interval: Seconds between heartbeat sends.
         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).
+        connect_timeout: Seconds allowed for the TCP connection and TLS
+            handshake together, after which the attempt is failed and retried.
+        reconnect_attempts: Max reconnection attempts. None (the default)
+            retries for as long as the client is open. 0 disables reconnection.
+            A finite budget that runs out abandons the connection and raises
+            CTraderReconnectAbandonedError out of the `async with` block.
         reconnect_min_wait: Initial wait between reconnection attempts.
         reconnect_max_wait: Maximum wait between reconnection attempts.
         refresh_policy: When to refresh access tokens and how hard to try.
@@ -51,9 +56,10 @@ class ClientConfig(BaseModel):
 
     # Request settings
     request_timeout: float = Field(default=30.0, gt=0)
+    connect_timeout: float = Field(default=30.0, gt=0)
 
     # Reconnection settings
-    reconnect_attempts: int = Field(default=5, ge=0)
+    reconnect_attempts: int | None = Field(default=None, ge=0)
     reconnect_min_wait: float = Field(default=1.0, gt=0)
     reconnect_max_wait: float = Field(default=60.0, gt=0)
 

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/src/ctrader_api_client/connection/protocol.py

@@ -12,6 +12,7 @@ from tenacity import (
     AsyncRetrying,
     retry_if_exception_type,
     stop_after_attempt,
+    stop_never,
     wait_exponential,
 )
 
@@ -29,6 +30,7 @@ from ..exceptions import (
     CTraderConnectionClosedError,
     CTraderConnectionFailedError,
     CTraderConnectionTimeoutError,
+    CTraderReconnectAbandonedError,
     FramingError,
 )
 from .listener import ConnectionListener
@@ -73,7 +75,7 @@ class Protocol:
     def __init__(
         self,
         transport: Transport,
-        reconnect_attempts: int = 5,
+        reconnect_attempts: int | None = None,
         reconnect_min_wait: float = 1.0,
         reconnect_max_wait: float = 60.0,
     ) -> None:
@@ -81,7 +83,10 @@ class Protocol:
 
         Args:
             transport: The underlying transport for sending/receiving data.
-            reconnect_attempts: Maximum reconnection attempts (0 to disable).
+            reconnect_attempts: Maximum reconnection attempts. None retries for
+                as long as the client is open, which is the default: an outage
+                that outlasts a finite budget otherwise leaves a client that
+                can never recover. 0 disables reconnection entirely.
             reconnect_min_wait: Initial wait between attempts (seconds).
             reconnect_max_wait: Maximum wait between attempts (seconds).
         """
@@ -500,6 +505,11 @@ class Protocol:
         working — reported through `handle_disconnect` as `_redo_requested`, the
         only route left once the reader has exited — is reconnected too instead
         of being stranded.
+
+        Raises:
+            CTraderReconnectAbandonedError: If reconnection is given up on. This
+                is deliberately allowed to escape into the protocol task group
+                and tear the client down: see :meth:`_abandon`.
         """
         try:
             while True:
@@ -535,18 +545,46 @@ class Protocol:
                 await self._notify_connection_lost()
         except (CTraderConnectionFailedError, CTraderConnectionClosedError) as e:
             logger.error("Reconnection failed, giving up: %s", e)
-            self._running = False
-            # Wake all pending requests so callers fail fast instead of hanging.
-            self._fail_pending("Connection lost and reconnection failed")
-        except Exception:
-            # Defensive: never let the reconnection task crash the task group.
+            self._abandon("connection lost and reconnection failed", e)
+        except Exception as e:
+            # Nothing here is expected to fail this way — the retry loop below
+            # absorbs every failure connecting — so treat it as a defect rather
+            # than a state to sit quietly in.
             logger.exception("Unexpected error while reconnecting")
-            self._running = False
-            self._fail_pending("Reconnection error")
+            self._abandon("unexpected error while reconnecting", e)
         finally:
             self._reconnecting = False
             self._redo_requested = False
 
+    def _abandon(self, reason: str, cause: BaseException) -> None:
+        """Stop the protocol and make giving up impossible to miss.
+
+        A client that has stopped reconnecting cannot recover on its own: the
+        reader has exited, the heartbeat loop returns as soon as its next write
+        fails, and `handle_disconnect` refuses everything once `_running` is
+        False. Nothing is left that could try again. Staying alive in that state
+        only means a consumer polling `is_connected` sees a link that is down
+        and assumes, reasonably and wrongly, that something is working on it.
+
+        So the failure is raised instead of recorded. It escapes into the
+        protocol task group, through the supervisor's, and out of the
+        `async with client:` block, where a process supervisor will see it.
+
+        Raises:
+            CTraderReconnectAbandonedError: Always, unless reconnection was
+                disabled by configuration, which is a choice rather than a
+                failure and keeps the previous behaviour of a client that
+                rejects further requests.
+        """
+        self._running = False
+        # Wake all pending requests so callers fail fast instead of hanging.
+        self._fail_pending(reason)
+
+        if self._reconnect_attempts == 0:
+            return
+
+        raise CTraderReconnectAbandonedError(reason, cause) from cause
+
     def _fail_pending(self, reason: str) -> None:
         """Resolve every in-flight request with a connection error."""
         for pending in self._pending.values():
@@ -556,27 +594,35 @@ class Protocol:
     async def _reconnect(self) -> None:
         """Attempt reconnection with exponential backoff.
 
+        Retries on *any* failure rather than on an enumerated set of exception
+        types. The budget exists to outlast a server that cannot be reached,
+        and an unrecognised exception is no evidence that it can be: a
+        whitelist here meant an exception nobody had thought of skipped the
+        retries entirely and went straight to being fatal.
+
         Raises:
-            CTraderConnectionClosedError: If reconnection is disabled or all attempts fail.
-            CTraderConnectionFailedError: If connection cannot be established.
+            CTraderConnectionClosedError: If reconnection is disabled.
+            CTraderConnectionFailedError: If every attempt in the budget failed.
         """
         if self._reconnect_attempts == 0:
             raise CTraderConnectionClosedError("Connection lost and reconnection disabled")
 
+        budget = "unlimited" if self._reconnect_attempts is None else self._reconnect_attempts
+
         async for attempt in AsyncRetrying(
-            stop=stop_after_attempt(self._reconnect_attempts),
+            stop=stop_never if self._reconnect_attempts is None else stop_after_attempt(self._reconnect_attempts),
             wait=wait_exponential(
                 min=self._reconnect_min_wait,
                 max=self._reconnect_max_wait,
             ),
-            retry=retry_if_exception_type(CTraderConnectionFailedError),
+            retry=retry_if_exception_type(Exception),
             reraise=True,
         ):
             with attempt:
                 logger.debug(
-                    "Reconnection attempt %d/%d",
+                    "Reconnection attempt %d/%s",
                     attempt.retry_state.attempt_number,
-                    self._reconnect_attempts,
+                    budget,
                 )
                 await self._transport.connect()
 

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/src/ctrader_api_client/connection/transport.py

@@ -18,17 +18,21 @@ class Transport:
     Handles raw socket connections without knowledge of protobuf or message semantics.
     """
 
-    def __init__(self, host: str, port: int, use_ssl: bool = True) -> None:
+    def __init__(self, host: str, port: int, use_ssl: bool = True, connect_timeout: float = 30.0) -> None:
         """Initialize transport configuration.
 
         Args:
             host: The server hostname to connect to.
             port: The server port to connect to.
             use_ssl: Whether to use SSL/TLS encryption. Defaults to True.
+            connect_timeout: Seconds to allow for the TCP connection and the
+                TLS handshake together. Bounds the one failure mode a caller
+                cannot retry: a handshake that neither completes nor fails.
         """
         self._host = host
         self._port = port
         self._ssl = use_ssl
+        self._connect_timeout = connect_timeout
         self._stream: ByteStream | None = None
 
     @property
@@ -62,6 +66,12 @@ class Transport:
 
         If already connected, this method returns immediately.
 
+        Either returns with a usable stream or raises
+        `CTraderConnectionFailedError`. There is deliberately no third outcome:
+        anything that goes wrong on the way to a connection *is* a failure to
+        connect, whatever its type, so callers can retry on one exception
+        rather than on a list of them that has to be kept complete.
+
         Raises:
             CTraderConnectionFailedError: If connection cannot be established.
         """
@@ -69,17 +79,25 @@ class Transport:
             return  # Already connected
 
         try:
-            if self._ssl:
-                ssl_context = ssl.create_default_context()
-                self._stream = await anyio.connect_tcp(
-                    self._host,
-                    self._port,
-                    ssl_context=ssl_context,
-                    tls_standard_compatible=True,
-                )
-            else:
-                self._stream = await anyio.connect_tcp(self._host, self._port)
-        except OSError as e:
+            # Every failure is translated, not an enumerated set of them. A TLS
+            # handshake cut short by the peer surfaces as anyio's
+            # BrokenResourceError, which is not an OSError and so used to
+            # escape untranslated — past the retry loop that only knew
+            # CTraderConnectionFailedError, and into the handler that reads an
+            # unrecognised exception as fatal. Cancellation still passes
+            # through: anyio raises it from BaseException, not Exception.
+            with anyio.fail_after(self._connect_timeout):
+                if self._ssl:
+                    ssl_context = ssl.create_default_context()
+                    self._stream = await anyio.connect_tcp(
+                        self._host,
+                        self._port,
+                        ssl_context=ssl_context,
+                        tls_standard_compatible=True,
+                    )
+                else:
+                    self._stream = await anyio.connect_tcp(self._host, self._port)
+        except Exception as e:
             raise CTraderConnectionFailedError(self._host, self._port, e) from e
 
         if self._ssl:

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/src/ctrader_api_client/exceptions.py

@@ -68,6 +68,39 @@ class CTraderConnectionTimeoutError(CTraderConnectionError):
         super().__init__(f"{operation} timed out after {timeout_seconds}s")
 
 
+class CTraderReconnectAbandonedError(CTraderConnectionError):
+    """The client tried to restore a dropped link and gave up.
+
+    Raised out of the `async with client:` block, tearing the client down
+    rather than leaving it alive but permanently offline. A client that has
+    stopped reconnecting can never recover on its own — there is no reader and
+    no heartbeat left to notice anything — so the only useful thing it can do
+    is say so where a supervisor will see it.
+
+    Reaching this is not expected. Reconnection is unbounded by default, so a
+    server that stays unreachable produces retries rather than this error. It
+    means either that `reconnect_attempts` was set to a finite number and every
+    one was used, or that something went wrong that the reconnection logic did
+    not anticipate.
+
+    Not raised when reconnection is disabled outright with
+    `reconnect_attempts=0`: not reconnecting is the documented outcome there,
+    not a failure.
+
+    Attributes:
+        reason: What was being attempted when it was abandoned.
+        cause: The final underlying failure, also set as `__cause__`.
+    """
+
+    def __init__(self, reason: str, cause: BaseException | None = None) -> None:
+        self.reason = reason
+        self.cause = cause
+        message = f"Reconnection abandoned: {reason}"
+        if cause:
+            message += f" ({cause})"
+        super().__init__(message)
+
+
 # =============================================================================
 # Authentication Errors
 # =============================================================================
@@ -222,6 +255,28 @@ class APIError(CTraderError):
         )
 
 
+# =============================================================================
+# Data Errors
+# =============================================================================
+
+
+class UnknownTimezoneError(CTraderError):
+    """A timezone named by the server is not in the IANA database.
+
+    Trading schedules are broker-supplied wall clock time, so a timezone that
+    cannot be resolved leaves every session boundary meaningless. This should
+    never happen: if it does, the broker has published a symbol whose schedule
+    timezone is misconfigured, and the schedule cannot be interpreted at all.
+    """
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        super().__init__(
+            f"Unknown schedule timezone {name!r}. This should never happen; it means the broker "
+            f"published a symbol whose schedule timezone is not a valid IANA name."
+        )
+
+
 # =============================================================================
 # Protocol Errors
 # =============================================================================

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.1}/src/ctrader_api_client/models/__init__.py

@@ -30,6 +30,7 @@ from .order import Order
 from .position import Position, PositionUnrealizedPnL
 from .requests import AmendOrderRequest, AmendPositionRequest, ClosePositionRequest, NewOrderRequest
 from .symbol import Symbol, SymbolInfo
+from .trading_hours import Holiday, ScheduleInterval, TradingHours, TradingSession
 
 
 __all__ = [
@@ -40,12 +41,16 @@ __all__ = [
     "CloseDetail",
     "ClosePositionRequest",
     "Deal",
+    "Holiday",
     "NewOrderRequest",
     "Order",
     "Position",
     "PositionUnrealizedPnL",
+    "ScheduleInterval",
     "Symbol",
     "SymbolInfo",
     "TickData",
+    "TradingHours",
+    "TradingSession",
     "Trendbar",
 ]