exchange

BackTestExchange

BackTestExchange(**kwargs)

Bases: Exchange

Source code in lettrade/exchange/backtest/exchange.py

def __init__(self, **kwargs):
    super().__init__(**kwargs)

    if self._config.setdefault("use_execution", False):
        self.executions = None

data instance-attribute

data: DataFeed

main DataFeed

datas instance-attribute

datas: list[DataFeed]

List of all available DataFeed

history_orders instance-attribute

history_orders: dict[str, Order] = dict()

History Order dict by Order.id key

history_positions instance-attribute

history_positions: dict[str, Position] = dict()

History Position dict by Position.id key

orders instance-attribute

orders: dict[str, Order] = dict()

Available Order dict by Order.id key

positions instance-attribute

positions: dict[str, Position] = dict()

Available Position dict by Position.id key

init

init(
    brain: Brain,
    feeder: DataFeeder,
    account: Account,
    commander: Commander,
) -> None

Init Exchange dependencies. Set data/datas from feeder. Set state to ExchangeState.Start.

Parameters:

• brain (Brain) –

  description

• feeder (DataFeeder) –

  description

• account (Account) –

  description

• commander (Commander) –

  description

Source code in lettrade/exchange/exchange.py

def init(
    self,
    brain: "Brain",
    feeder: DataFeeder,
    account: Account,
    commander: Commander,
) -> None:
    """Init Exchange dependencies.
    Set data/datas from feeder.
    Set state to `ExchangeState.Start`.

    Args:
        brain (Brain): _description_
        feeder (DataFeeder): _description_
        account (Account): _description_
        commander (Commander): _description_
    """
    self._brain = brain
    self._feeder = feeder
    self._account = account
    self._commander = commander

    self.data = self._feeder.data
    self.datas = self._feeder.datas

    self._account.init(exchange=self)

    self._state = ExchangeState.Start

new_order

new_order(
    size: float,
    type: OrderType = OrderType.Market,
    limit: float | None = None,
    stop: float | None = None,
    sl: float | None = None,
    tp: float | None = None,
    tag: object | None = None,
    data: DataFeed | None = None,
    expiration: datetime | None = None,
    **kwargs
) -> OrderResult

Place new order. Then send order events to Brain

Parameters:

• size (float) –

  description

• type (OrderType | None, default: Market ) –

  description. Defaults to OrderType.Market.

• limit (float | None, default: None ) –

  description. Defaults to None.

• stop (float | None, default: None ) –

  description. Defaults to None.

• sl (float | None, default: None ) –

  description. Defaults to None.

• tp (float | None, default: None ) –

  description. Defaults to None.

• tag (object | None, default: None ) –

  description. Defaults to None.

• data (DataFeed | None, default: None ) –

  description. Defaults to None.

• **kwargs (dict | None, default: {} ) –

  Extra-parameters

Returns:

• OrderResult ( OrderResult ) –

  Result when place new Order

Source code in lettrade/exchange/backtest/exchange.py

def new_order(
    self,
    size: float,
    type: OrderType = OrderType.Market,
    limit: float | None = None,
    stop: float | None = None,
    sl: float | None = None,
    tp: float | None = None,
    tag: object | None = None,
    data: DataFeed | None = None,
    expiration: datetime | None = None,
    **kwargs,
) -> OrderResult:
    """Place new order.
    Then send order events to `Brain`

    Args:
        size (float): _description_
        type (OrderType | None, optional): _description_. Defaults to OrderType.Market.
        limit (float | None, optional): _description_. Defaults to None.
        stop (float | None, optional): _description_. Defaults to None.
        sl (float | None, optional): _description_. Defaults to None.
        tp (float | None, optional): _description_. Defaults to None.
        tag (object | None, optional): _description_. Defaults to None.
        data (DataFeed | None, optional): _description_. Defaults to None.
        **kwargs (dict | None, optional): Extra-parameters

    Returns:
        OrderResult: Result when place new `Order`
    """
    if data is None:
        data = self.data

    order = BackTestOrder(
        id=self._id(),
        exchange=self,
        data=data,
        size=size,
        type=type,
        limit_price=limit,
        stop_price=stop,
        sl_price=sl,
        tp_price=tp,
        expiration=expiration,
        tag=tag,
    )
    ok = order.place(at=self.data.bar())

    if type == OrderType.Market:
        # Simulate market order will send event before return order result
        self._simulate_orders()

    return ok

next

next()

Execution when new data feeded

Source code in lettrade/exchange/backtest/exchange.py

def next(self):
    """Execution when new data feeded"""
    self._simulate_orders()
    super().next()

next_next

next_next()

Call after strategy.next()

Source code in lettrade/exchange/exchange.py

def next_next(self):
    """Call after strategy.next()"""
    self._account.next_next()

on_executions

on_executions(
    executions: list[Execution],
    broadcast: bool | None = True,
    **kwargs
) -> None

Receive Execution event from exchange then store and notify Brain

Source code in lettrade/exchange/exchange.py

def on_executions(
    self,
    executions: list[Execution],
    broadcast: bool | None = True,
    **kwargs,
) -> None:
    """
    Receive Execution event from exchange then store and notify Brain
    """
    for execution in executions:
        if not isinstance(execution, Execution):
            raise RuntimeError(f"{execution} is not instance of type Execution")

        if execution.id in self.executions:
            # Merge to keep Execution handler for strategy using
            # when strategy want to store Execution object
            # and object will be automatic update directly
            self.executions[execution.id].merge(execution)
            execution = self.executions[execution.id]
        else:
            self.executions[execution.id] = execution

    if self._state != ExchangeState.Run:
        return

    if broadcast:
        self._brain.on_executions(executions)

on_order

on_order(
    order: Order, broadcast: bool | None = True, **kwargs
) -> None

Receive order event from exchange then store and notify Brain

Parameters:

• order (Order) –

  description

• broadcast (bool | None, default: True ) –

  description. Defaults to True.

Source code in lettrade/exchange/exchange.py

def on_order(
    self,
    order: Order,
    broadcast: bool | None = True,
    **kwargs,
) -> None:
    """Receive order event from exchange then store and notify Brain

    Args:
        order (Order): _description_
        broadcast (bool | None, optional): _description_. Defaults to True.
    """
    self.on_orders(orders=[order], broadcast=broadcast, **kwargs)

on_orders

on_orders(
    orders: list[Order],
    broadcast: bool | None = True,
    **kwargs
) -> None

Receive orders event from exchange then store and notify Brain

Parameters:

• orders (list[Order]) –

  description

• broadcast (bool | None, default: True ) –

  description. Defaults to True.

Raises:

• RuntimeError –

  description

Source code in lettrade/exchange/exchange.py

def on_orders(
    self,
    orders: list[Order],
    broadcast: bool | None = True,
    **kwargs,
) -> None:
    """Receive orders event from exchange then store and notify Brain

    Args:
        orders (list[Order]): _description_
        broadcast (bool | None, optional): _description_. Defaults to True.

    Raises:
        RuntimeError: _description_
    """
    for order in orders:
        if not isinstance(order, Order):
            raise RuntimeError(f"{order} is not instance of type Order")

        if order.is_closed:
            if order.id in self.history_orders:
                logger.warning("Order closed recall: %s", order)

            self.history_orders[order.id] = order
            if order.id in self.orders:
                del self.orders[order.id]

            if __debug__:
                logger.info("Order closed: %s", order)
        else:
            if order.id in self.history_orders:
                raise RuntimeError(f"Order {order.id} closed")

            if order.id in self.orders:
                # Merge to keep Order handler for strategy using
                # when strategy want to store Order object
                # and object will be automatic update directly
                self.orders[order.id].merge(order)
                order = self.orders[order.id]

                if __debug__:
                    logger.info("Order updated: %s", order)
            else:
                self.orders[order.id] = order

                if __debug__:
                    logger.info("Order placed: %s", order)

    if self._state != ExchangeState.Run:
        return

    if broadcast:
        self._brain.on_orders(orders)

on_position

on_position(
    position: Position,
    broadcast: bool | None = True,
    **kwargs
) -> None

Receive Position event from exchange then store and notify Brain

Parameters:

• position (Position) –

  new comming Position

• broadcast (bool | None, default: True ) –

  Flag notify to Brain. Defaults to True.

Raises:

• RuntimeError –

  validate Position instance

Source code in lettrade/exchange/exchange.py

def on_position(
    self,
    position: Position,
    broadcast: bool | None = True,
    **kwargs,
) -> None:
    """Receive Position event from exchange then store and notify Brain

    Args:
        position (Position): new comming `Position`
        broadcast (bool | None, optional): Flag notify to Brain. Defaults to True.

    Raises:
        RuntimeError: validate `Position` instance
    """
    self.on_positions(positions=[position], broadcast=broadcast, **kwargs)

on_positions

on_positions(
    positions: list[Position],
    broadcast: bool | None = True,
    **kwargs
) -> None

Receive Positions event from exchange then store and notify Brain

Parameters:

• positions (list[Position]) –

  list of new comming Position

• broadcast (bool | None, default: True ) –

  Flag notify to Brain. Defaults to True.

Raises:

• RuntimeError –

  validate Position instance

Source code in lettrade/exchange/exchange.py

def on_positions(
    self,
    positions: list[Position],
    broadcast: bool | None = True,
    **kwargs,
) -> None:
    """Receive Positions event from exchange then store and notify Brain

    Args:
        positions (list[Position]): list of new comming `Position`
        broadcast (bool | None, optional): Flag notify to Brain. Defaults to True.

    Raises:
        RuntimeError: validate `Position` instance
    """
    for position in positions:
        if not isinstance(position, Position):
            raise RuntimeError(f"{position} is not instance of type Position")

        if position.is_exited:
            if position.id in self.history_positions:
                logger.warning("Position exited recall: %s", position)

            self.history_positions[position.id] = position
            if position.id in self.positions:
                del self.positions[position.id]

            # self._account._on_position_exit(position)
        else:
            if position.id in self.history_positions:
                raise RuntimeError(f"Position {position.id} closed: {position}")
            if position.id in self.positions:
                # Merge to keep Position handler for strategy using
                # when strategy want to store Position object
                # and object will be automatic update directly
                self.positions[position.id].merge(position)
                position = self.positions[position.id]
            else:
                self.positions[position.id] = position
                # self._account._on_position_entry(position)

    self._account.on_positions(positions)

    if self._state != ExchangeState.Run:
        return

    if broadcast:
        self._brain.on_positions(positions)

start

start() -> None

Start of Exchange by: - Start account. - Set state to ExchangeState.Run ready for next().

Source code in lettrade/exchange/exchange.py

def start(self) -> None:
    """Start of Exchange by:
    - Start account.
    - Set state to `ExchangeState.Run` ready for next().
    """
    self._account.start()
    self._state = ExchangeState.Run

stop

stop() -> None

Stop Exchange

Source code in lettrade/exchange/exchange.py

def stop(self) -> None:
    """Stop Exchange"""
    self._state = ExchangeState.Stop
    self._account.stop()