Trade

def __init__(
    self,
    direction: TradeDirection,
    quantity: int,
    open_value: float,
    open_datetime: arrow.Arrow,
    epic: "Epic",
    current_close_value: Optional[float] = None,
    status: Optional[TransactionStatus] = TransactionStatus.CREATED,
    strategy: Optional["BaseStrategy"] = None,
    stop_absolute: Optional[float] = None,
    limit_absolute: Optional[float] = None,
    stop_relative: Optional[float] = None,
    limit_relative: Optional[float] = None,
    ref: Optional[str] = None,
    meta: Optional[Dict[str, Any]] = None,
) -> None:
    """
    Create a new trade instance.

    Arguments:
        direction: trade direction (buy or sell)
        quantity: quantity of the trade.
        open_value: market value to open the Trade with
        open_datetime: datetime of the trade open
        status: operation status
        epic: [`Epic`][estrade.epic.Epic] instance having at least one tick.
        strategy: [`Strategy`][estrade.strategy.BaseStrategy] instance
        stop_absolute (Optional[float]): stop value for this trade
        stop_relative (Optional[float]): stop value relative to open for this trade
        limit_absolute (Optional[float]): limit value for this trade
        limit_relative (Optional[float]): limit value relative to open for
            this trade
        ref: trade reference
        meta: trade metadata
    """
    self.epic = epic
    self.strategy = strategy  # TODO: test Strategy type
    self.direction = direction  # TODO: check invalid direction
    self.open_quantity = quantity  # TODO: check positive
    self.closes: List[TradeClose] = []

    self.open_value = open_value
    self.current_close_value = current_close_value or open_value

    self.max_result: float = self.result
    self.min_result: float = self.result

    StopLimitMixin.__init__(
        self,
        stop_absolute=stop_absolute,
        stop_relative=stop_relative,
        limit_absolute=limit_absolute,
        limit_relative=limit_relative,
    )

    RefMixin.__init__(self, ref)
    TimedMixin.__init__(self, open_datetime)
    MetaMixin.__init__(self, meta)
    TransactionMixin.__init__(self, status)

    # self.epic.trade_provider.open_trade(self)
    logger.info(
        "New %s trade created: %s @ %s", self.direction, self.ref, self.open_value
    )

def close(
    self,
    close_value: float,
    datetime: Optional[Union[pydatetime, arrow.Arrow]] = None,
    quantity: Optional[int] = None,
    **kwargs,
) -> "TradeClose":
    """
    Close (totally or partially) a trade.

    This method create a new instance of [`TradeClose`][estrade.trade.TradeClose]
    and adds it to this instance `closes`.

    Arguments:
        close_value: the market value at which the close is performed.
        datetime: datetime of the closing.
        quantity: quantity to close, default to the remaining open quantities if
            not provided.

    Returns:
        The [`TradeClose`][estrade.trade.TradeClose] instance created.

    """
    quantity = quantity or self.opened_quantities
    datetime = datetime or self.epic.last_tick.datetime

    if quantity > self.opened_quantities:
        logger.error(
            f"Impossible to close {quantity} when only "
            f"{self.opened_quantities} are opened."
        )
        quantity = self.opened_quantities

    logger.info(
        "Close %s quantities of trade %s @ %s", quantity, self.ref, close_value
    )
    new_close = TradeClose(
        trade=self,
        close_value=close_value,
        quantity=quantity,
        datetime=datetime,
        **kwargs,
    )
    self.closes.append(new_close)
    return new_close

def close_from_epic(self, **kwargs) -> "TradeClose":
    """
    Close Trade with its Epic last tick.

    Arguments:
        kwargs: see [`TradeClose`][estrade.trade.TradeClose] arguments

    Returns:
        The [`TradeClose`][estrade.trade.TradeClose] instance created.
    """
    trade_close = self.close_from_tick(self.epic.last_tick, **kwargs)

    return trade_close

def close_from_tick(self, tick: "Tick", **kwargs) -> "TradeClose":
    """
    Close current Trade from a Tick instance.

    Arguments:
        tick: Tick instance to use to close the current trade.

    Returns:
        The [`TradeClose`][estrade.trade.TradeClose] instance created.
    """
    # update current trade with tick to set self.current_close_value
    self.update_from_tick(tick)

    trade_close = self.close(
        datetime=tick.datetime,
        close_value=self.current_close_value,
        **kwargs,
    )
    return trade_close

@staticmethod
def open_from_epic(epic: "Epic", **kwargs: Any) -> "Trade":
    """
    Open a trade from an Epic current last tick.

    Arguments:
        epic: Epic instance to open the Trade from
        kwargs: see [`Trade`][estrade.trade.Trade] `__init__` method arguments

    Returns:
        opened trade instance.
    """
    new_trade = Trade.open_from_tick(
        tick=epic.last_tick,
        epic=epic,
        **kwargs,
    )

    return new_trade

@staticmethod
def open_from_tick(tick: "Tick", epic: "Epic", **kwargs: Any) -> "Trade":
    """
    Open a [`Trade`][estrade.trade.Trade] from a [`Tick`][estrade.tick.Tick].

    Arguments:
        tick: [`Tick`][estrade.tick.Tick] instance.
        kwargs: Arguments with the same constraints as the
            [`Trade`][estrade.trade.Trade.__init__]
    """
    if kwargs["direction"] == TradeDirection.BUY:
        kwargs["open_value"] = tick.ask
        kwargs["current_close_value"] = tick.bid
    elif kwargs["direction"] == TradeDirection.SELL:
        kwargs["open_value"] = tick.bid
        kwargs["current_close_value"] = tick.ask
    else:
        raise TradeException("Invalid direction")

    kwargs["open_datetime"] = tick.datetime

    trade = Trade(
        epic=epic,
        **kwargs,
    )
    return trade

def update(self, current_close_value: float) -> None:
    """
    Update trade with the current market value.

    Arguments:
        current_close_value: the current market value to close this Trade.

    !!! example

        ```python
        --8<-- "tests/doc/reference/trade/test_update.py"
        ```
    """
    if self.closed:
        logger.error("Cannot update a closed trade.")
        return

    self.current_close_value = current_close_value

    if self._stop_limit_reached():
        self.close(
            close_value=self.current_close_value,
            meta={"close_reason": "stop_limit_reached"},
        )

    self._update_min_max()

def update_from_epic(self) -> None:
    """Update current trade from its Epic current value."""
    self.update_from_tick(self.epic.last_tick)

def update_from_tick(self, tick: "Tick") -> None:
    """
    Update current trade from the input Tick.

    Arguments:
        tick: Tick instance to use to update the trade result.
    """
    if self.direction == TradeDirection.BUY:
        current_close_value = tick.bid
    else:
        current_close_value = tick.ask

    self.update(current_close_value)

def update_limit_absolute(self, limit_absolute: float) -> None:
    """
    Add a limit by its absolute value on the current instance.

    Arguments:
        limit_absolute: limit absolute value
    """
    self.limit_absolute = limit_absolute
    self.epic.trade_provider.update_limit(trade=self)  # type: ignore

def update_limit_relative(self, limit_relative: float) -> None:
    """
    Add a limit by its relative value on the current instance.

    Arguments:
        limit_relative: limit absolute value

    !!! note

        limit is relative to the trade open value.
    """
    self.limit_relative = limit_relative
    self.epic.trade_provider.update_limit(trade=self)  # type: ignore

def update_stop_absolute(self, stop_absolute: float) -> None:
    """
    Add a stop by its absolute value on the current instance.

    Arguments:
        stop_absolute: stop absolute value
    """
    self.stop_absolute = stop_absolute
    self.epic.trade_provider.update_stop(trade=self)  # type: ignore

def update_stop_relative(self, stop_relative: float) -> None:
    """
    Add a stop by its relative value on the current instance.

    Arguments:
        stop_relative: stop absolute value

    !!! note

        stop is relative to the trade open value.
    """
    self.stop_relative = stop_relative
    self.epic.trade_provider.update_stop(trade=self)  # type: ignore

def __init__(
    self,
    trade: Trade,
    close_value: float,
    quantity: int,
    datetime: Union[pydatetime, arrow.Arrow],
    status: Optional[TransactionStatus] = TransactionStatus.CREATED,
    ref: Optional[str] = None,
    meta: Optional[Dict[Any, Any]] = None,
) -> None:
    """
    Create a new partial close of a trade.

    Arguments:
        trade: [`Trade`][estrade.trade.Trade] instance.
        close_value: current market value at close time.
        quantity: closed quantities
        datetime: close datetime
        ref: an optional name for this close
        meta: trade close metadata
    """
    self.trade = trade
    self.close_value = close_value
    self.quantity = quantity

    TransactionMixin.__init__(self, status)
    TimedMixin.__init__(self, datetime)
    MetaMixin.__init__(self, meta)
    RefMixin.__init__(self, ref)