trade

MetaTraderExecution

MetaTraderExecution(
    pl: float | None = None,
    fee: float | None = None,
    tag: str | None = None,
    **kwargs
)

Bases: LiveExecution

Execution for MetaTrader

Source code in lettrade/exchange/metatrader/trade.py

def __init__(
    self,
    pl: float | None = None,
    fee: float | None = None,
    tag: str | None = None,
    **kwargs,
):
    super().__init__(**kwargs)
    self.pl: float = pl
    self.fee: float = fee
    self.tag: str | None = tag

is_long property

is_long: bool

True if side is long (size is positive).

Returns:

• bool ( bool ) –

  True/False

is_short property

is_short: bool

True if side is short (size is negative).

Returns:

• bool ( bool ) –

  description

side property

side: TradeSide

True if side is short (size is negative).

Returns:

• bool ( TradeSide ) –

  description

from_raw classmethod

from_raw(
    raw,
    exchange: MetaTraderExchange,
    data: LiveDataFeed | None = None,
    api: MetaTraderAPI | None = None,
) -> MetaTraderExecution | None

Building new MetaTraderExecution from live api raw object

Parameters:

• raw (_type_) –

  description

• exchange (MetaTraderExchange) –

  description

Returns:

• MetaTraderExecution ( MetaTraderExecution | None ) –

  description

Source code in lettrade/exchange/metatrader/trade.py

@classmethod
def from_raw(
    cls,
    raw,
    exchange: "MetaTraderExchange",
    data: "LiveDataFeed | None" = None,
    api: MetaTraderAPI | None = None,
) -> "MetaTraderExecution | None":
    """Building new MetaTraderExecution from live api raw object

    Args:
        raw (_type_): _description_
        exchange (MetaTraderExchange): _description_

    Returns:
        MetaTraderExecution: _description_
    """
    # DataFeed
    if data is None:
        for d in exchange.datas:
            if d.symbol == raw.symbol:
                data = d
                break
        if data is None:
            logger.warning("Raw execution %s is not handling %s", raw.symbol, raw)
            return
    # Side
    match raw.type:
        case MT5.DEAL_TYPE_BUY:
            side = TradeSide.Buy
        case MT5.DEAL_TYPE_SELL:
            side = TradeSide.Sell
        case _:
            logger.warning(
                "Raw execution %s type %s is not handling %s",
                raw.symbol,
                raw.type,
                raw,
            )
            return

    return cls(
        exchange=exchange,
        id=raw.ticket,
        data=data,
        order_id=raw.order,
        position_id=raw.position_id,
        size=side * raw.volume,
        price=raw.price,
        pl=raw.profit,
        fee=raw.fee + raw.swap + raw.commission,
        at=pd.to_datetime(raw.time_msc, unit="ms", utc=True),
        tag=raw.comment,
        api=api,
        raw=raw,
    )

merge

merge(other: Execution)

Merge to keep object handler but not overwrite for Strategy using when Strategy want to store object and object will be automatic update directly

Source code in lettrade/exchange/execution.py

def merge(self, other: "Execution"):
    """
    Merge to keep object handler but not overwrite for Strategy using when Strategy want to store object and object will be automatic update directly
    """
    if other is self:
        return

    if self.id != other.id:
        raise RuntimeError(f"Merge difference id {self.id} != {other.id} execution")

    self.price = other.price
    self.size = other.size

    if other.at:
        self.at = other.at
    if other.order_id:
        self.order_id = other.order_id
    if other.order:
        self.order = other.order
    if other.position_id:
        self.position_id = other.position_id
    if other.position:
        self.position = other.position

MetaTraderOrder

MetaTraderOrder(is_real: bool = True, **kwargs)

Bases: LiveOrder

Order for MetaTrader

Source code in lettrade/exchange/metatrader/trade.py

def __init__(self, is_real: bool = True, **kwargs):
    super().__init__(**kwargs)

    self.is_real: bool = is_real
    """Flag to check `Order` is real, cannot duplicate id, cannot recall from history"""

is_closed property

is_closed: bool

Flag to check Order closed

Returns:

• bool ( bool ) –

  True if state in [OrderState.Filled, OrderState.Canceled]

is_long property

is_long: bool

True if side is long (size is positive).

Returns:

• bool ( bool ) –

  True/False

is_opening property

is_opening: bool

Flag to check Order still alive

Returns:

• bool ( bool ) –

  True if state in [OrderState.Pending, OrderState.Placed, OrderState.Partial]

is_real instance-attribute

is_real: bool = is_real

Flag to check Order is real, cannot duplicate id, cannot recall from history

is_short property

is_short: bool

True if side is short (size is negative).

Returns:

• bool ( bool ) –

  description

is_sl_order property

is_sl_order: bool

Order is stop-loss order of a Position

Returns:

• bool ( bool ) –

  description

is_tp_order property

is_tp_order: bool

Order is take-profit order of a Position

Returns:

• bool ( bool ) –

  description

limit property

limit: float | None

Getter of limit_price

Returns:

• float | None –

  float | None: float or None

place_price property

place_price: float | None

Getter of place_price

Returns:

• float | None –

  float | None: float or None

side property

side: TradeSide

True if side is short (size is negative).

Returns:

• bool ( TradeSide ) –

  description

sl property

sl: float | None

Getter of sl_price

Returns:

• float | None –

  float | None: float or None

stop property

stop: float | None

Getter of stop_price

Returns:

• float | None –

  float | None: float or None

tp property

tp: float | None

Getter of tp_price

Returns:

• float | None –

  float | None: float or None

cancel

cancel(**kwargs) -> OrderResult

Cancel order

Returns:

• OrderResult ( OrderResult ) –

  description

Source code in lettrade/exchange/metatrader/trade.py

def cancel(self, **kwargs) -> OrderResult:
    """Cancel order

    Returns:
        OrderResult: _description_
    """
    if not self.parent:
        # Abandon order
        result = self._api.order_close(order=self, **kwargs)
    else:
        # Virtual SL/TP order of trade
        result = None

    return super(LiveOrder, self).cancel(raw=result)

fill

fill(
    price: float, at: Timestamp, raw: object | None = None
) -> OrderResult

Fill Order. Set status to OrderState.Executed. Send event to Exchange

Parameters:

• price (float) –

  Executed price

• at (Timestamp) –

  Executed bar

Raises:

• RuntimeError –

  description

Returns:

• OrderResult ( OrderResult ) –

  result of Order

Source code in lettrade/exchange/order.py

def fill(
    self,
    price: float,
    at: pd.Timestamp,
    raw: object | None = None,
) -> "OrderResult":
    """Fill `Order`.
    Set `status` to `OrderState.Executed`.
    Send event to `Exchange`

    Args:
        price (float): Executed price
        at (pd.Timestamp): Executed bar

    Raises:
        RuntimeError: _description_

    Returns:
        OrderResult: result of `Order`
    """
    if self.state != OrderState.Placed:
        raise RuntimeError(f"Order {self.id} state {self.state} is not Placed")

    self.filled_at = at
    self.filled_price = price
    self.state = OrderState.Filled
    self.exchange.on_order(self)
    return OrderResultOk(order=self, raw=raw)

from_position classmethod

from_position(
    position: MetaTraderPosition,
    sl: float | None = None,
    tp: float | None = None,
) -> MetaTraderOrder

summary

Parameters:

• position (MetaTraderPosition) –

  description

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

  description. Defaults to None.

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

  description. Defaults to None.

Raises:

• RuntimeError –

  description

Returns:

• MetaTraderOrder ( MetaTraderOrder ) –

  description

Source code in lettrade/exchange/metatrader/trade.py

@classmethod
def from_position(
    cls,
    position: "MetaTraderPosition",
    sl: float | None = None,
    tp: float | None = None,
) -> "MetaTraderOrder":
    """_summary_

    Args:
        position (MetaTraderPosition): _description_
        sl (float | None, optional): _description_. Defaults to None.
        tp (float | None, optional): _description_. Defaults to None.

    Raises:
        RuntimeError: _description_

    Returns:
        MetaTraderOrder: _description_
    """
    if not sl and not tp:
        raise RuntimeError("not sl and not tp")
    return cls(
        id=f"{position.id}-{'sl' if sl else 'tp'}",
        exchange=position.exchange,
        data=position.data,
        state=OrderState.Placed,
        type=OrderType.Stop if sl else OrderType.Limit,
        size=-position.size,
        limit_price=tp,
        stop_price=sl,
        parent=position,
        placed_at=position.entry_at,
        is_real=False,
    )

from_raw classmethod

from_raw(
    raw: Any,
    exchange: MetaTraderExchange,
    data: LiveDataFeed | None = None,
    api: MetaTraderAPI | None = None,
) -> MetaTraderOrder | None

summary

Parameters:

• raw (Any) –

  description

• exchange (MetaTraderExchange) –

  description

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

  description. Defaults to None.

• api (MetaTraderAPI | None, default: None ) –

  description. Defaults to None.

Raises:

• NotImplementedError –

  description

Returns:

• MetaTraderOrder | None –

  MetaTraderOrder | None: description

Source code in lettrade/exchange/metatrader/trade.py

@classmethod
def from_raw(
    cls,
    raw: Any,
    exchange: "MetaTraderExchange",
    data: "LiveDataFeed | None" = None,
    api: MetaTraderAPI | None = None,
) -> "MetaTraderOrder | None":
    """_summary_

    Args:
        raw (Any): _description_
        exchange (MetaTraderExchange): _description_
        data (LiveDataFeed | None, optional): _description_. Defaults to None.
        api (MetaTraderAPI | None, optional): _description_. Defaults to None.

    Raises:
        NotImplementedError: _description_

    Returns:
        MetaTraderOrder | None: _description_
    """
    # DataFeed
    if data is None:
        for d in exchange.datas:
            if d.symbol == raw.symbol:
                data = d
                break
        if data is None:
            logger.warning("Raw order %s is not handling %s", raw.symbol, raw)
            return

    # Prices & Side & Type
    limit_price = None
    stop_price = None
    match raw.type:
        case MT5.ORDER_TYPE_BUY:
            side = TradeSide.Buy
            type = OrderType.Market
        case MT5.ORDER_TYPE_SELL:
            side = TradeSide.Sell
            type = OrderType.Market
        case MT5.ORDER_TYPE_BUY_LIMIT:
            side = TradeSide.Buy
            type = OrderType.Limit
            limit_price = raw.price_open
        case MT5.ORDER_TYPE_SELL_LIMIT:
            side = TradeSide.Sell
            type = OrderType.Limit
            limit_price = raw.price_open
        case MT5.ORDER_TYPE_BUY_STOP:
            side = TradeSide.Buy
            type = OrderType.Stop
            stop_price = raw.price_open
        case MT5.ORDER_TYPE_SELL_STOP:
            side = TradeSide.Sell
            type = OrderType.Stop
            stop_price = raw.price_open
        # case MT5.ORDER_TYPE_BUY_STOP_LIMIT:
        #     side = TradeSide.Buy
        #     type = OrderType.StopLimit
        #     # TODO
        #     limit_price = raw.price_open
        #     stop_price = raw.price_open
        # case MT5.ORDER_TYPE_SELL_STOP_LIMIT:
        #     side = TradeSide.Sell
        #     type = OrderType.StopLimit
        #     # TODO
        #     limit_price = raw.price_open
        #     stop_price = raw.price_open
        # case MT5.ORDER_TYPE_CLOSE_BY:
        case _:
            raise NotImplementedError(
                f"Order type {raw.type} is not implement",
                raw,
            )
    # State
    match raw.state:
        case MT5.ORDER_STATE_STARTED:
            state = OrderState.Pending
        case MT5.ORDER_STATE_PLACED:
            state = OrderState.Placed
        case MT5.ORDER_STATE_CANCELED:
            state = OrderState.Canceled
        case MT5.ORDER_STATE_PARTIAL:
            state = OrderState.Partial
        case MT5.ORDER_STATE_FILLED:
            state = OrderState.Filled
        case MT5.ORDER_STATE_REJECTED:
            state = OrderState.Canceled
        case MT5.ORDER_STATE_EXPIRED:
            state = OrderState.Canceled
        case MT5.ORDER_STATE_REQUEST_ADD:
            state = OrderState.Placed
        case MT5.ORDER_STATE_REQUEST_MODIFY:
            state = OrderState.Placed
        case MT5.ORDER_STATE_REQUEST_CANCEL:
            state = OrderState.Canceled
        case _:
            raise NotImplementedError(
                f"Raw order state {raw.state} is not implement"
            )

    order = cls(
        exchange=exchange,
        id=raw.ticket,
        state=state,
        data=data,
        size=side * (raw.volume_current or raw.volume_initial),
        type=type,
        limit_price=limit_price,
        stop_price=stop_price,
        sl_price=raw.sl or None,
        tp_price=raw.tp or None,
        tag=raw.comment,
        placed_at=pd.to_datetime(raw.time_setup_msc, unit="ms", utc=True),
        api=api,
        raw=raw,
    )

    if hasattr(raw, "time_done_msc"):
        order.filled_price = raw.price_current
        order.filled_at = pd.to_datetime(raw.time_done_msc, unit="ms", utc=True)

    return order

merge

merge(other: Order)

Update current Order variables by other Order

Parameters:

• other (Order) –

  Merge source Order

Raises:

• RuntimeError –

  Validate same id

Source code in lettrade/exchange/order.py

def merge(self, other: "Order"):
    """Update current `Order` variables by other `Order`

    Args:
        other (Order): Merge source `Order`

    Raises:
        RuntimeError: Validate same id
    """
    if other is self:
        return

    if self.id != other.id:
        raise RuntimeError(f"Merge difference id {self.id} != {other.id} order")

    self.size = other.size
    self.sl_price = other.sl_price
    self.tp_price = other.tp_price

    if other.limit_price:
        self.limit_price = other.limit_price
    if other.stop_price:
        self.stop_price = other.stop_price
    if other.placed_at:
        self.placed_at = other.placed_at

    if other.filled_price:
        self.filled_price = other.filled_price
    if other.filled_at:
        self.filled_at = other.filled_at

    if other.parent:
        self.parent = other.parent

place

place() -> OrderResult

summary

Raises:

• RuntimeError –

  description

Returns:

• OrderResult ( OrderResult ) –

  description

Source code in lettrade/exchange/metatrader/trade.py

def place(self) -> OrderResult:
    """_summary_

    Raises:
        RuntimeError: _description_

    Returns:
        OrderResult: _description_
    """
    if self.state != OrderState.Pending:
        raise RuntimeError(f"Order {self.id} state {self.state} is not Pending")

    try:
        result = self._api.order_open(self)

        self.raw = result
        self.id = result.order

        # TODO: get current order time
        return super(LiveOrder, self).place(at=self.data.l.index[0], raw=result)
    except LetLiveOrderInvalidException as e:
        error = OrderResultError(
            error=e.message,
            order=self,
            raw=e.raw,
        )
        logger.error("Place order %s", str(error))
        self.exchange.on_notify(error=error)
        return error

update

update(
    limit_price: float | None = None,
    stop_price: float | None = None,
    sl: float | None = None,
    tp: float | None = None,
    caller: float | None = None,
    **kwargs
) -> OrderResult

summary

Parameters:

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

  description. Defaults to None.

• stop_price (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.

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

  description. Defaults to None.

Raises:

• RuntimeError –

  description

Returns:

• OrderResult ( OrderResult ) –

  description

Source code in lettrade/exchange/metatrader/trade.py

def update(
    self,
    limit_price: float | None = None,
    stop_price: float | None = None,
    sl: float | None = None,
    tp: float | None = None,
    caller: float | None = None,
    **kwargs,
) -> OrderResult:
    """_summary_

    Args:
        limit_price (float | None, optional): _description_. Defaults to None.
        stop_price (float | None, optional): _description_. Defaults to None.
        sl (float | None, optional): _description_. Defaults to None.
        tp (float | None, optional): _description_. Defaults to None.
        caller (float | None, optional): _description_. Defaults to None.

    Raises:
        RuntimeError: _description_

    Returns:
        OrderResult: _description_
    """
    if caller is self:
        raise RuntimeError(f"Order recusive update {self}")

    if self.parent is None:
        result = self._api.order_update(
            order=self,
            limit_price=limit_price,
            stop_price=stop_price,
            sl=sl,
            tp=tp,
            **kwargs,
        )
        return super(LiveOrder, self).update(
            limit_price=result.limit_price,
            stop_price=result.stop_price,
            sl=result.sl,
            tp=result.tp,
        )
    else:
        # SL/TP Order just a virtual order
        if caller is not self.parent:
            if self.is_sl_order:
                self.parent.update(sl=stop_price, caller=self)
            elif self.is_tp_order:
                self.parent.update(tp=limit_price, caller=self)
            else:
                raise RuntimeError(f"Abandon order {self}")

        return super(LiveOrder, self).update(
            limit_price=limit_price,
            stop_price=stop_price,
        )

MetaTraderPosition

MetaTraderPosition(
    id: str,
    exchange: LiveExchange,
    data: LiveDataFeed,
    size: float,
    parent: Order,
    tag: str | None = None,
    state: PositionState = PositionState.Open,
    entry_price: float | None = None,
    entry_fee: float = 0.0,
    entry_at: int | None = None,
    sl_order: Order | None = None,
    tp_order: Order | None = None,
    api: LiveAPI | None = None,
    raw: object | None = None,
    **kwargs
)

Bases: LivePosition

Position for MetaTrader

Source code in lettrade/exchange/live/trade.py

def __init__(
    self,
    id: str,
    exchange: "LiveExchange",
    data: "LiveDataFeed",
    size: float,
    parent: Order,
    tag: str | None = None,
    state: PositionState = PositionState.Open,
    entry_price: float | None = None,
    entry_fee: float = 0.0,
    entry_at: int | None = None,
    sl_order: Order | None = None,
    tp_order: Order | None = None,
    api: LiveAPI | None = None,
    raw: object | None = None,
    **kwargs,
):
    super().__init__(
        id=id,
        exchange=exchange,
        data=data,
        size=size,
        parent=parent,
        tag=tag,
        state=state,
        entry_price=entry_price,
        entry_fee=entry_fee,
        entry_at=entry_at,
        sl_order=sl_order,
        tp_order=tp_order,
        api=api,
        raw=raw,
        **kwargs,
    )

fee property

fee: float

Fee/Estimate Fee for trade

Returns:

• float ( float ) –

  Fee

is_exited property

is_exited: bool

Flag to check Position state.

Returns:

• bool ( bool ) –

  True if the trade exited

is_long property

is_long: bool

True if side is long (size is positive).

Returns:

• bool ( bool ) –

  True/False

is_opening property

is_opening: bool

Flag to check Position state.

Returns:

• bool ( bool ) –

  True if the trade opening

is_short property

is_short: bool

True if side is short (size is negative).

Returns:

• bool ( bool ) –

  description

pl property

pl: float

Estimate Profit or Loss of Position

Returns:

• float ( float ) –

  PnL

side property

side: TradeSide

True if side is short (size is negative).

Returns:

• bool ( TradeSide ) –

  description

exit

exit() -> PositionResult

summary

Returns:

• PositionResult ( PositionResult ) –

  description

Source code in lettrade/exchange/metatrader/trade.py

def exit(self) -> PositionResult:
    """_summary_

    Returns:
        PositionResult: _description_
    """
    result = self._api.position_close(position=self)
    if result.code != 0:
        logger.error("Update position %s", str(result))
        error = PositionResultError(
            error=result.error,
            position=self,
            raw=result,
        )
        self.exchange.on_notify(error=error)
        return error

    execution_raw = self._api.execution_get(id=result.execution_id)

    # TODO: execution object and event
    result.execution_raw = execution_raw

    return super(LivePosition, self).exit(
        price=result.price,
        at=pd.to_datetime(execution_raw.time_msc, unit="ms", utc=True),
        pl=execution_raw.profit,
        fee=execution_raw.fee + execution_raw.swap + execution_raw.commission,
        raw=result,
    )

from_raw classmethod

from_raw(
    raw,
    exchange: MetaTraderExchange,
    state: PositionState = PositionState.Open,
    data: LiveDataFeed | None = None,
    api: MetaTraderAPI = None,
) -> MetaTraderPosition

summary

Parameters:

• raw (_type_) –

  description

• exchange (MetaTraderExchange) –

  description

• data (LiveDataFeed, default: None ) –

  description. Defaults to None.

• api (MetaTraderAPI, default: None ) –

  description. Defaults to None.

Raises:

• NotImplementedError –

  description

Returns:

• MetaTraderPosition ( MetaTraderPosition ) –

  description

Source code in lettrade/exchange/metatrader/trade.py

@classmethod
def from_raw(
    cls,
    raw,
    exchange: "MetaTraderExchange",
    state: PositionState = PositionState.Open,
    data: "LiveDataFeed | None" = None,
    api: MetaTraderAPI = None,
) -> "MetaTraderPosition":
    """_summary_

    Args:
        raw (_type_): _description_
        exchange (MetaTraderExchange): _description_
        data (LiveDataFeed, optional): _description_. Defaults to None.
        api (MetaTraderAPI, optional): _description_. Defaults to None.

    Raises:
        NotImplementedError: _description_

    Returns:
        MetaTraderPosition: _description_
    """
    # DataFeed
    if data is None:
        for d in exchange.datas:
            if d.symbol == raw.symbol:
                data = d
                break
        if data is None:
            logger.warning("Raw position %s is not handling %s", raw.symbol, raw)
            return

    # Side
    match raw.type:
        case MT5.POSITION_TYPE_BUY:
            side = TradeSide.Buy
        case MT5.POSITION_TYPE_SELL:
            side = TradeSide.Sell
        case _:
            raise NotImplementedError(
                f"Position type {raw.type} is not implement",
                raw,
            )
    # API
    if api is None:
        api = exchange._api

    position = cls(
        exchange=exchange,
        id=raw.ticket,
        data=data,
        state=state,
        size=side * raw.volume,
        entry_price=raw.price_open,
        entry_fee=raw.swap,
        entry_at=pd.to_datetime(raw.time_msc, unit="ms", utc=True),
        parent=None,
        tag=raw.comment,
        api=api,
        raw=raw,
    )

    # SL
    if raw.sl > 0.0:
        position.sl_order = exchange._order_cls.from_position(
            position=position, sl=raw.sl
        )
        exchange.on_order(position.sl_order)

    # TP
    if raw.tp > 0.0:
        position.tp_order = exchange._order_cls.from_position(
            position=position, tp=raw.tp
        )
        exchange.on_order(position.tp_order)

    if position.state == PositionState.Exit:
        if position.exit_price is None:
            if not hasattr(raw, "executions"):
                raw.executions = api.executions_get(position_id=position.id)

            exchange.on_executions_event(raw.executions, broadcast=False)

            execution = exchange.executions[raw.executions[-1].ticket]
            position.exit_at = execution.at
            position.exit_price = execution.price
            position.exit_pl = execution.pl
            position.exit_fee = execution.fee

    return position

merge

merge(other: LivePosition) -> bool

Merge LivePosition from another

Parameters:

• other (LivePosition) –

  description

Returns:

• bool ( bool ) –

  description

Source code in lettrade/exchange/live/trade.py

def merge(self, other: "LivePosition") -> bool:
    """Merge LivePosition from another

    Args:
        other (LivePosition): _description_

    Returns:
        bool: _description_
    """
    if not super().merge(other):
        return False
    self.raw = other.raw
    return True

update

update(
    sl: float | None = None,
    tp: float | None = None,
    caller: float | None = None,
    **kwargs
) -> PositionResult

summary

Parameters:

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

  description. Defaults to None.

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

  description. Defaults to None.

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

  description. Defaults to None.

Raises:

• RuntimeError –

  description

• RuntimeError –

  description

Returns:

• PositionResult ( PositionResult ) –

  description

Source code in lettrade/exchange/metatrader/trade.py

def update(
    self,
    sl: float | None = None,
    tp: float | None = None,
    caller: float | None = None,
    **kwargs,
) -> PositionResult:
    """_summary_

    Args:
        sl (float | None, optional): _description_. Defaults to None.
        tp (float | None, optional): _description_. Defaults to None.
        caller (float | None, optional): _description_. Defaults to None.

    Raises:
        RuntimeError: _description_
        RuntimeError: _description_

    Returns:
        PositionResult: _description_
    """
    if not sl and not tp:
        raise RuntimeError("Update sl=None and tp=None")
    if caller is self:
        raise RuntimeError(f"Position recusive update {self}")

    result = self._api.position_update(position=self, sl=sl, tp=tp)
    if result.code != 0:
        logger.error("Update position %s", str(result))
        error = PositionResultError(
            error=result.error,
            position=self,
            raw=result,
        )
        self.exchange.on_notify(error=error)
        return error

    if sl is not None:
        if self.sl_order:
            if caller is not self.sl_order:
                self.sl_order.update(stop_price=sl, caller=self)
        else:
            self.sl_order = self.exchange._order_cls.from_position(
                position=self, sl=sl
            )

    if tp is not None:
        if self.tp_order:
            if caller is not self.tp_order:
                self.tp_order.update(limit_price=tp, caller=self)
        else:
            self.tp_order = self.exchange._order_cls.from_position(
                position=self, tp=tp
            )

    return super(LivePosition, self).update(raw=result)