opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/lib/strategy/opentrades.py

@@ -0,0 +1,281 @@
+from ...types.na import NA, na_float
+from ...types import PyneFloat, PyneInt, PyneStr
+from ... import lib
+from .. import syminfo
+
+from ...core.module_property import module_property
+
+
+#
+# Functions
+#
+
+# noinspection PyProtectedMember
+def commission(trade_num: int) -> PyneFloat:
+    """
+    Returns the sum of entry and exit fees paid in the open trade, expressed in strategy.account_currency
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The sum of entry and exit fees paid in the open trade, expressed in strategy.account_currency
+    """
+    if trade_num < 0:
+        return na_float
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].commission
+    except (IndexError, AssertionError):
+        return 0.0
+
+
+# noinspection PyProtectedMember
+def entry_bar_index(trade_num: int) -> PyneInt:
+    """
+    Returns the bar_index of the open trade's entry
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The bar_index of the open trade's entry
+    """
+    if trade_num < 0:
+        return NA(int)
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].entry_bar_index
+    except (IndexError, AssertionError):
+        return NA(int)
+
+
+# noinspection PyProtectedMember
+def entry_comment(trade_num: int) -> PyneStr:
+    """
+    Returns the comment message of the open trade's entry
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The comment message of the open trade's entry
+    """
+    if trade_num < 0:
+        return NA(str)
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        comment = lib._script.position.open_trades[trade_num].entry_comment
+        return comment if comment is not None else NA(str)
+    except (IndexError, AssertionError):
+        return NA(str)
+
+
+# noinspection PyProtectedMember
+def entry_id(trade_num: int) -> PyneStr:
+    """
+    Returns the id of the open trade's entry
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The id of the open trade's entry
+    """
+    if trade_num < 0:
+        return NA(str)
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        entry_id_ = lib._script.position.open_trades[trade_num].entry_id
+        return entry_id_ if entry_id_ is not None else NA(str)
+    except (IndexError, AssertionError):
+        return NA(str)
+
+
+# noinspection PyProtectedMember
+def entry_price(trade_num: int) -> PyneFloat:
+    """
+    Returns the price of the open trade's entry
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The price of the open trade's entry
+    """
+    if trade_num < 0:
+        return na_float
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].entry_price
+    except (IndexError, AssertionError):
+        return na_float
+
+
+# noinspection PyProtectedMember
+def entry_time(trade_num: int) -> PyneInt:
+    """
+    Returns the time of the open trade's entry (UNIX)
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The time of the open trade's entry (UNIX)
+    """
+    if trade_num < 0:
+        return NA(int)
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].entry_time
+    except (IndexError, AssertionError):
+        return NA(int)
+
+
+# noinspection PyProtectedMember
+def max_drawdown(trade_num: int) -> PyneFloat:
+    """
+    Returns the maximum drawdown of the open trade
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The maximum drawdown of the open trade
+    """
+    if trade_num < 0:
+        return na_float
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].max_drawdown
+    except (IndexError, AssertionError):
+        return 0.0
+
+
+# noinspection PyProtectedMember
+def max_drawdown_percent(trade_num: int) -> PyneFloat:
+    """
+    Returns the maximum drawdown percentage of the open trade
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The maximum drawdown percentage of the open trade
+    """
+    if trade_num < 0:
+        return na_float
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].max_drawdown_percent
+    except (IndexError, AssertionError):
+        return 0.0
+
+
+# noinspection PyProtectedMember
+def max_runup(trade_num: int) -> PyneFloat:
+    """
+    Returns the maximum runup of the open trade
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The maximum runup of the open trade
+    """
+    if trade_num < 0:
+        return na_float
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].max_runup
+    except (IndexError, AssertionError):
+        return 0.0
+
+
+# noinspection PyProtectedMember
+def max_runup_percent(trade_num: int) -> PyneFloat:
+    """
+    Returns the maximum runup percentage of the open trade
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The maximum runup percentage of the open trade
+    """
+    if trade_num < 0:
+        return na_float
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].max_runup_percent
+    except (IndexError, AssertionError):
+        return 0.0
+
+
+# noinspection PyProtectedMember
+def profit(trade_num: int) -> PyneFloat:
+    """
+    Returns the profit of the open trade expressed in strategy.account_currency
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The profit of the open trade expressed in strategy.account_currency
+    """
+    if trade_num < 0:
+        return na_float
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].profit
+    except IndexError:
+        return 0.0
+
+
+# noinspection PyProtectedMember
+def profit_percent(trade_num: int) -> PyneFloat:
+    """
+    Returns the profit percentage of the open trade
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The profit percentage of the open trade
+    """
+    if trade_num < 0:
+        return na_float
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].profit_percent
+    except (IndexError, AssertionError):
+        return 0.0
+
+
+# noinspection PyProtectedMember
+def size(trade_num: int) -> PyneFloat:
+    """
+    Returns the size and direction (<0 short >0 long) of the open trade
+
+    :param trade_num: The trade number of the open trade. The number of the first trade is zero
+    :return: The size and direction (<0 short >0 long) of the open trade
+    """
+    if trade_num < 0:
+        return 0.0
+    try:
+        assert lib._script is not None
+        assert lib._script.position is not None
+        return lib._script.position.open_trades[trade_num].size
+    except (IndexError, AssertionError):
+        return 0.0
+
+
+#
+# Module properties
+#
+
+# noinspection PyProtectedMember
+@module_property
+def capital_held() -> PyneFloat:
+    """
+    Returns the amount of capital held in open positions, expressed in
+    strategy.account_currency.
+
+    :return: The capital tied up by the currently open trades
+    """
+    if lib._script is None or lib._script.position is None:
+        return 0.0
+    position = lib._script.position
+    # pointvalue converts contracts -> account currency (1 for spot/stocks,
+    # but e.g. 100000 for VN30 futures); omitting it understates the held
+    # capital by that factor on non-unit-pointvalue instruments.
+    return sum(abs(trade.size) * trade.entry_price * syminfo.pointvalue
+               for trade in position.open_trades)
+
+
+# noinspection PyProtectedMember
+@module_property
+def opentrades() -> int:
+    """
+    Number of market position entries, which were not closed and remain opened.
+
+    :return: The number of open trades
+    """
+    if lib._script is None or lib._script.position is None:
+        return 0
+    position = lib._script.position
+    return len(position.open_trades)

pynecore/lib/strategy/opentrades.pyi

@@ -0,0 +1,49 @@
+from ...types import PyneFloat, PyneInt, PyneStr
+
+
+# IDE-facing view of the function-and-namespace module: bare ``strategy.opentrades``
+# is an int value, ``strategy.opentrades.commission(...)`` a namespaced function;
+# the AST transformer resolves both at runtime. The ``int`` base keeps arithmetic
+# on the bare name type-checking.
+class OpenTradesModule(int):
+    def __call__(self) -> int: ...
+
+    #
+    # Functions
+    #
+
+    def commission(self, trade_num: int) -> PyneFloat: ...
+
+    def entry_bar_index(self, trade_num: int) -> PyneInt: ...
+
+    def entry_comment(self, trade_num: int) -> PyneStr: ...
+
+    def entry_id(self, trade_num: int) -> PyneStr: ...
+
+    def entry_price(self, trade_num: int) -> PyneFloat: ...
+
+    def entry_time(self, trade_num: int) -> PyneInt: ...
+
+    def max_drawdown(self, trade_num: int) -> PyneFloat: ...
+
+    def max_drawdown_percent(self, trade_num: int) -> PyneFloat: ...
+
+    def max_runup(self, trade_num: int) -> PyneFloat: ...
+
+    def max_runup_percent(self, trade_num: int) -> PyneFloat: ...
+
+    def profit(self, trade_num: int) -> PyneFloat: ...
+
+    def profit_percent(self, trade_num: int) -> PyneFloat: ...
+
+    def size(self, trade_num: int) -> PyneFloat: ...
+
+    #
+    # Properties
+    #
+
+    @property
+    def capital_held(self) -> PyneFloat: ...
+
+
+opentrades: OpenTradesModule

pynecore/lib/strategy/risk.py

@@ -0,0 +1,109 @@
+from ...types.na import NA
+from ...types import PyneStr
+from .. import strategy
+
+from ... import lib
+
+
+# noinspection PyShadowingBuiltins,PyProtectedMember
+def max_drawdown(
+        value: float | int,
+        type: strategy.QtyType = strategy.percent_of_equity,
+        alert_message: PyneStr = NA(str)
+) -> None:
+    """
+    The purpose of this rule is to determine maximum drawdown. The rule affects the whole strategy.
+    Once the maximum drawdown value is reached, all pending orders are cancelled, all open positions
+    are closed and no new orders can be placed.
+
+    :param value: The maximum drawdown value
+    :param type: The type of the value
+    :param alert_message: The alert message
+    """
+    if lib._script is None or lib._script.position is None:
+        return
+
+    lib._script.position.risk_max_drawdown_value = value
+    lib._script.position.risk_max_drawdown_type = type
+    lib._script.position.risk_max_drawdown_alert = None if isinstance(alert_message, NA) else str(alert_message)
+
+
+# noinspection PyProtectedMember
+def allow_entry_in(value: strategy.direction.Direction) -> None:
+    """
+    This function can be used to specify in which market direction the strategy.entry function is
+    allowed to open positions.
+
+    :param value: The allowed direction
+    """
+    if lib._script is None or lib._script.position is None:
+        return
+
+    lib._script.position.risk_allowed_direction = value
+
+
+# noinspection PyProtectedMember
+def max_cons_loss_days(count: int, alert_message: PyneStr = NA(str)) -> None:
+    """
+    The purpose of this rule is to determine the maximum number of consecutive losing days.
+    Once the maximum number of consecutive losing days is reached, all pending orders are cancelled,
+    all open positions are closed and no new orders can be placed
+
+    :param count: The maximum number of consecutive losing days
+    :param alert_message: The alert message
+    """
+    if lib._script is None or lib._script.position is None:
+        return
+
+    lib._script.position.risk_max_cons_loss_days = count
+    lib._script.position.risk_max_cons_loss_days_alert = None if isinstance(alert_message, NA) else str(alert_message)
+
+
+# noinspection PyProtectedMember
+def max_intraday_filled_orders(count: int, alert_message: PyneStr = NA(str)) -> None:
+    """
+    The purpose of this rule is to determine the maximum number of intraday filled orders
+
+    :param count: The maximum number of intraday filled orders
+    :param alert_message: The alert message
+    """
+    if lib._script is None or lib._script.position is None:
+        return
+
+    lib._script.position.risk_max_intraday_filled_orders = count
+    lib._script.position.risk_max_intraday_filled_orders_alert = (
+        None if isinstance(alert_message, NA) else str(alert_message)
+    )
+
+
+# noinspection PyShadowingBuiltins,PyProtectedMember
+def max_intraday_loss(value: float | int, type: strategy.QtyType = strategy.percent_of_equity,
+                      alert_message: PyneStr = NA(str)) -> None:
+    """
+    The purpose of this rule is to determine the maximum intraday loss. The rule affects the whole strategy.
+    Once the maximum intraday loss value is reached, all pending orders are cancelled, all open positions
+    are closed and no new orders can be placed
+
+    :param value: The maximum intraday loss value
+    :param type: The type of the value
+    :param alert_message: The alert message
+    """
+    if lib._script is None or lib._script.position is None:
+        return
+
+    lib._script.position.risk_max_intraday_loss_value = value
+    lib._script.position.risk_max_intraday_loss_type = type
+    lib._script.position.risk_max_intraday_loss_alert = None if isinstance(alert_message, NA) else str(alert_message)
+
+
+# noinspection PyProtectedMember
+def max_position_size(contracts: int | float):
+    """
+    The purpose of this rule is to determine maximum size of a market position
+
+    :param contracts: The maximum size of a market position
+    """
+    if lib._script is None or lib._script.position is None:
+        return
+
+    lib._script.position.risk_max_position_size = abs(contracts)