powerquant-cli 0.2.6__py3-none-any.whl

quant_cli/examples/research/ipo_first_day.py

@@ -0,0 +1,348 @@
+"""上市首日 VWAP 理论买入、下一交易日卖出的可复用研究源码。"""
+
+from dataclasses import dataclass
+from datetime import date, datetime, time
+from decimal import Decimal
+from zoneinfo import ZoneInfo
+
+from quant_core.app.order_execution.constants import OrderSide
+from quant_core.app.order_execution.fee_model import StandardFeeModel
+
+CN = ZoneInfo("Asia/Shanghai")
+
+
+@dataclass(frozen=True)
+class IpoTrade:
+    instrument_id: str
+    listed_date: date
+    exit_date: date
+    quantity: int
+    buy_vwap: Decimal
+    sell_price: Decimal
+    gross_pnl: Decimal
+    buy_fee: Decimal
+    sell_fee: Decimal
+
+    @property
+    def net_pnl(self):
+        return self.gross_pnl - self.buy_fee - self.sell_fee
+
+
+class IpoVwapStudy:
+    """本研究专属的事后测算，不产生订单或成交。"""
+
+    def __init__(self, market):
+        self.market = market
+        self.fees = StandardFeeModel(
+            commission_rate=Decimal("0.0003"),
+            minimum_commission=Decimal("5"),
+            sell_stamp_tax_rate=Decimal("0.0005"),
+            transfer_fee_rate=Decimal("0"),
+        )
+
+    async def _days(self, start, end):
+        if start >= end:
+            raise ValueError("研究区间至少跨两个日期")
+        days = [
+            item.trade_date
+            for item in await self.market.list_trading_days("XSHG", start, end)
+            if item.is_open
+        ]
+        if len(days) < 2:
+            raise ValueError("区间内不足两个交易日")
+        return days
+
+    async def _ipos(self, day):
+        return sorted(
+            (
+                item
+                for item in await self.market.list_instruments_on(day)
+                if item.instrument_type == "stock" and item.listed_date == day
+            ),
+            key=lambda item: item.instrument_id,
+        )
+
+    async def _price(self, instrument_id, day, mode):
+        bars = await self.market.get_bars(
+            instrument_id,
+            "1d",
+            datetime.combine(day, time.min, CN),
+            datetime.combine(day, time.max, CN),
+            2,
+        )
+        if len(bars) != 1 or bars[0].suspended or bars[0].volume <= 0:
+            return None
+        if mode == "vwap" and bars[0].amount is None:
+            return None
+        price = bars[0].open if mode == "open" else bars[0].amount / Decimal(bars[0].volume)
+        tolerance = Decimal("0.01")
+        if (
+            not price.is_finite()
+            or price <= 0
+            or not bars[0].low - tolerance <= price <= bars[0].high + tolerance
+        ):
+            return None
+        return price
+
+    async def _buy(self, item, day, budget):
+        price = await self._price(item.instrument_id, day, "vwap")
+        if price is None:
+            return "首日无有效 VWAP"
+        rules = await self.market.list_trading_rules([item.instrument_id], day, day)
+        if len(rules) != 1:
+            return "缺少唯一交易单位规则"
+        rule = rules[0].quantity_rule
+        quantity = rule.buy_quantity(int(budget / price))
+        while quantity > 0:
+            fee = self.fees.compute(OrderSide.BUY, quantity, price).total
+            if price * quantity + fee <= budget:
+                return quantity, price, fee
+            quantity = rule.buy_quantity(quantity - 1)
+        return "分配预算不足最低买入数量"
+
+    async def run_events(self, start, end, cash, exit_price):
+        days = await self._days(start, end)
+        candidates = 0
+        trades = []
+        skipped = []
+        for index, today in enumerate(days):
+            ipos = await self._ipos(today)
+            candidates += len(ipos)
+            for item in ipos:
+                if index == len(days) - 1:
+                    skipped.append(f"{item.instrument_id} {today}: 区间无次日卖出数据")
+                    continue
+                purchase = await self._buy(item, today, cash)
+                if isinstance(purchase, str):
+                    skipped.append(f"{item.instrument_id} {today}: {purchase}")
+                    continue
+                quantity, buy_price, buy_fee = purchase
+                next_day = days[index + 1]
+                sell_price = await self._price(item.instrument_id, next_day, exit_price)
+                if sell_price is None:
+                    skipped.append(f"{item.instrument_id} {next_day}: 次日无有效 {exit_price} 价格")
+                    continue
+                sell_fee = self.fees.compute(OrderSide.SELL, quantity, sell_price).total
+                trades.append(
+                    IpoTrade(
+                        item.instrument_id,
+                        today,
+                        next_day,
+                        quantity,
+                        buy_price,
+                        sell_price,
+                        (sell_price - buy_price) * quantity,
+                        buy_fee,
+                        sell_fee,
+                    )
+                )
+        net = [trade.net_pnl for trade in trades]
+        return {
+            "candidates": candidates,
+            "trades": trades,
+            "skipped": skipped,
+            "mean_return": sum(net, Decimal(0)) / (cash * len(net)) if net else None,
+            "win_rate": Decimal(sum(value > 0 for value in net)) / len(net) if net else None,
+        }
+
+    async def run_portfolio(self, start, end, cash, exit_price):
+        days = await self._days(start, end)
+        initial_cash = cash
+        pending = []
+        trades = []
+        skipped = []
+        for index, today in enumerate(days):
+            had_pending = bool(pending)
+            for instrument_id, listed_date, quantity, buy_price in pending:
+                sell_price = await self._price(instrument_id, today, exit_price)
+                if sell_price is None:
+                    raise ValueError(f"{instrument_id} {today}: 次日无有效 {exit_price} 价格")
+                buy_fee = self.fees.compute(OrderSide.BUY, quantity, buy_price).total
+                sell_fee = self.fees.compute(OrderSide.SELL, quantity, sell_price).total
+                cash += sell_price * quantity - sell_fee
+                trades.append(
+                    IpoTrade(
+                        instrument_id,
+                        listed_date,
+                        today,
+                        quantity,
+                        buy_price,
+                        sell_price,
+                        (sell_price - buy_price) * quantity,
+                        buy_fee,
+                        sell_fee,
+                    )
+                )
+            pending = []
+            ipos = await self._ipos(today)
+            if index == len(days) - 1 or had_pending:
+                reason = (
+                    "区间无次日卖出数据" if index == len(days) - 1 else "同日卖出款不可预知用于买入"
+                )
+                skipped.extend(f"{item.instrument_id} {today}: {reason}" for item in ipos)
+                continue
+            budget = cash / len(ipos) if ipos else Decimal(0)
+            for item in ipos:
+                purchase = await self._buy(item, today, budget)
+                if isinstance(purchase, str):
+                    skipped.append(f"{item.instrument_id} {today}: {purchase}")
+                    continue
+                quantity, buy_price, buy_fee = purchase
+                cash -= buy_price * quantity + buy_fee
+                pending.append((item.instrument_id, today, quantity, buy_price))
+        return {
+            "initial_cash": initial_cash,
+            "ending_cash": cash,
+            "trades": trades,
+            "skipped": skipped,
+            "total_return": cash / initial_cash - 1,
+        }
+
+
+async def run(context, parameters):
+    mode = parameters.get("mode", "events")
+    if mode not in {"events", "portfolio"}:
+        raise ValueError("mode 只能为 events 或 portfolio")
+    exit_price = parameters.get("exit_price", "open")
+    if exit_price not in {"open", "vwap"}:
+        raise ValueError("exit_price 只能为 open 或 vwap")
+    cash = Decimal(str(parameters.get("cash", "100000")))
+    if not cash.is_finite() or cash <= 0:
+        raise ValueError("资金必须为正的有限数")
+    study = IpoVwapStudy(context.market)
+    common = {
+        "question": "上市首日按全天 VWAP 理论买入、下一交易日卖出，历史样本表现如何？",
+        "sample_start": context.start,
+        "sample_end": context.end,
+        "methodology": (
+            f"首日全天 VWAP 买入、次日{('开盘价' if exit_price == 'open' else '全天 VWAP')}"
+            "卖出；按标的生效的最低买入量与递增单位下单。买卖佣金各 0.03%、每笔最低 5 元，"
+            "卖出印花税 0.05%，转让费按 0 估算。"
+        ),
+        "limitations": [
+            "首日全天 VWAP 是收盘后才能知道的价格，不能保证盘中按此价格买入。",
+            "未模拟新股排队、滑点、冲击和实际可成交量；不是可执行策略回测。",
+            "数据 revisions 是运行时观察到的同步水位摘要，不等于旧行情逐行归档。",
+        ],
+    }
+    if mode == "events":
+        outcome = await study.run_events(context.start, context.end, cash, exit_price)
+        mean = outcome["mean_return"]
+        conclusion = (
+            f"{len(outcome['trades'])} 只可测新股的平均单次净收益"
+            f"{(mean * 100):+.2f}%；这是每只独立投入 {cash:,.0f} 元的事件均值，"
+            "不是一个账户的累计收益。"
+            if mean is not None
+            else "该区间没有可测新股，不能给出平均收益。"
+        )
+        metrics = []
+        if mean is not None:
+            returns = sorted(trade.net_pnl / cash * 100 for trade in outcome["trades"])
+            midpoint = len(returns) // 2
+            median = (
+                returns[midpoint]
+                if len(returns) % 2
+                else (returns[midpoint - 1] + returns[midpoint]) / 2
+            )
+            metrics = [
+                {
+                    "key": "mean_return_per_ipo",
+                    "label": "平均单次净收益",
+                    "value": mean * 100,
+                    "unit": "percent",
+                    "explanation": (
+                        "每只新股独立投入相同预算，逐只净盈亏相加后除以"
+                        "预算×可测只数；非账户累计收益。"
+                    ),
+                },
+                {
+                    "key": "win_rate",
+                    "label": "盈利样本比例",
+                    "value": outcome["win_rate"] * 100,
+                    "unit": "percent",
+                    "explanation": "净盈亏为正的样本数÷可测样本数。",
+                },
+                {
+                    "key": "median_return_per_ipo",
+                    "label": "单次净收益中位数",
+                    "value": median,
+                    "unit": "percent",
+                    "explanation": "逐只独立样本净收益率排序后的中间值。",
+                },
+                {
+                    "key": "min_return_per_ipo",
+                    "label": "最差单次净收益",
+                    "value": returns[0],
+                    "unit": "percent",
+                    "explanation": "可测样本中最低的单次净收益率。",
+                },
+                {
+                    "key": "max_return_per_ipo",
+                    "label": "最好单次净收益",
+                    "value": returns[-1],
+                    "unit": "percent",
+                    "explanation": "可测样本中最高的单次净收益率。",
+                },
+            ]
+        return {
+            **common,
+            "kind": "event_study",
+            "conclusion": conclusion,
+            "candidate_count": outcome["candidates"],
+            "observations": [_trade(item) for item in outcome["trades"]],
+            "exclusions": [_exclusion(item) for item in outcome["skipped"]],
+            "metrics": metrics,
+        }
+    outcome = await study.run_portfolio(context.start, context.end, cash, exit_price)
+    return {
+        **common,
+        "kind": "theoretical_scenario",
+        "conclusion": (
+            f"单一 {cash:,.0f} 元现金账户理论情景完成 {len(outcome['trades'])} 笔，"
+            f"期末现金 {outcome['ending_cash']:,.2f} 元、累计收益"
+            f" {outcome['total_return'] * 100:+.2f}%。"
+            "此结果受预算不足和同日资金不可提前复用影响，不能解释为所有新股的平均表现。"
+        ),
+        "candidate_count": len(outcome["trades"]) + len(outcome["skipped"]),
+        "observations": [_trade(item) for item in outcome["trades"]],
+        "exclusions": [_exclusion(item) for item in outcome["skipped"]],
+        "metrics": [
+            {
+                "key": "scenario_total_return",
+                "label": "理论单账户累计收益",
+                "value": outcome["total_return"] * 100,
+                "unit": "percent",
+                "explanation": "(期末现金÷初始现金−1)×100%；仅适用于当前理论资金规则。",
+            },
+            {
+                "key": "ending_cash",
+                "label": "期末现金",
+                "value": outcome["ending_cash"],
+                "unit": "cny",
+                "explanation": "所有理论买卖和模拟费用后剩余现金。",
+            },
+        ],
+        "limitations": [
+            *common["limitations"],
+            "同日卖出的资金不用于同日新买入；这一保守规则会使部分新股跳过。",
+        ],
+    }
+
+
+def _trade(item):
+    return {
+        "instrument_id": item.instrument_id,
+        "listed_date": item.listed_date.isoformat(),
+        "exit_date": item.exit_date.isoformat(),
+        "quantity": item.quantity,
+        "buy_vwap": str(item.buy_vwap),
+        "sell_price": str(item.sell_price),
+        "buy_fee": str(item.buy_fee),
+        "sell_fee": str(item.sell_fee),
+        "net_pnl": str(item.net_pnl),
+    }
+
+
+def _exclusion(item):
+    subject, _, reason = item.partition(": ")
+    return {"subject": subject, "reason": reason or item}

quant_cli/examples/selection/README.md

@@ -0,0 +1,59 @@
+# 正式命令示例
+
+在已安装 pq 的环境执行。prepare.json 中的股票和日期是固定工程样本，可按实际覆盖调整。
+
+```powershell
+pq data prepare --config prepare.json
+```
+
+将返回的 manifest_path 填入 compute.json 和 select.json。它必须是完整数据集的 manifest.json，不能用只有 Bar 的 bars-v2 清单替代。
+
+```powershell
+pq factor compute --config compute.json --source ../factors/multi_intraday_screen.py
+```
+
+将返回 uuid 填入 select.json 的 factor_run_uuid，再执行：
+
+```powershell
+pq factor select --config select.json
+pq factor selection-get --run <选股运行UUID>
+pq factor selection-list
+```
+
+默认归档 ~/.powerquant/workspace.duckdb，使用 --database 或 PQ_LOCAL_DATABASE 可覆盖。失败运行也归档，返回非零退出码。日期、因子身份、源快照保持一致；股票池可取因子运行的子集，首批不合并多个运行。
+
+四因子各权重 0.25；先按上市、ST、停牌、涨停状态过滤，再在剩余股票中计算百分位，方向调整后加权求和。并列值平均排名，单股截面百分位 0.5；同分按证券 ID 升序。权重必须正且有限，不自动归一化；低波动配方已取负，direction 保持 desc。
+
+日线因子保守按下一交易日 09:30 可见，因此示例用 9 月 29 日因子，在 9 月 30 日决策。快照必须包含后续交易日历。资格状态用当前修订中的目标日历史事实，不代表历史知识版本；无法自动证明下一日可成交。
+
+示例明确使用未复权价格，计算日内比值；这不是遇到缺复权数据时的自动降级。价格跨日因子应显式选择可信复权口径。快照暂未提供行业/市值暴露，请求中性化会明确失败。
+
+## 独立回测示例
+
+backtest.json 的 manifest_path 替换为通过完整性审计的回测数据集，不要假定选股快照天然完整。执行：
+
+```powershell
+pq backtest run --config backtest.json --source buy_hold.py
+pq backtest get --run <回测运行UUID>
+```
+
+buy_hold.py 为固定日期买入并持有的核算示例，不消费本次选股名单，也不是投资建议。
+
+## Python 调用
+
+```python
+from pathlib import Path
+from quant_cli.api import (
+    LocalSelectionRequest, build_local_factor_store,
+    build_local_selection_store, run_local_selection,
+)
+
+request = LocalSelectionRequest.model_validate_json(Path("select.json").read_text())
+# 已有异步调用方使用 await；同步脚本在顶层使用 asyncio.run。
+record = await run_local_selection(
+    request, build_local_factor_store(Path("workspace.duckdb")),
+    build_local_selection_store(Path("workspace.duckdb")),
+)
+```
+
+公开函数返回记录而不输出终端内容；调用方检查 status/error。纯计算使用 compute_local_selection，不自动归档。

quant_cli/examples/selection/backtest.json

@@ -0,0 +1,18 @@
+{
+  "manifest_path": "REPLACE_WITH_COMPLETE_BACKTEST_MANIFEST",
+  "config": {
+    "strategy_id": "cli_buy_hold",
+    "instrument_ids": [
+      "CN.XSHE.002371",
+      "CN.XSHG.600141",
+      "CN.XSHG.603015",
+      "CN.XSHG.605580",
+      "CN.XSHG.688679"
+    ],
+    "frequency": "1d",
+    "start": "2026-09-28T09:30:00+08:00",
+    "end": "2026-09-30T15:00:00+08:00",
+    "initial_cash": "1000000",
+    "strategy_adjustment_type": "none"
+  }
+}

quant_cli/examples/selection/buy_hold.py

@@ -0,0 +1,7 @@
+"""固定日买入并持有，用于命令和核算验证。"""
+
+
+def handle_bar(context, bars):
+    if context.event_time.date().isoformat() == "2026-09-28":
+        for instrument_id in context.universe:
+            context.order_shares(instrument_id, 200)

quant_cli/examples/selection/compute.json

@@ -0,0 +1,15 @@
+{
+  "manifest_path": "REPLACE_WITH_MANIFEST_PATH",
+  "instrument_ids": [
+    "CN.XSHE.002371",
+    "CN.XSHG.600141",
+    "CN.XSHG.603015",
+    "CN.XSHG.605580",
+    "CN.XSHG.688679"
+  ],
+  "start": "2026-09-29",
+  "end": "2026-09-29",
+  "view": {
+    "adjustment_type": "none"
+  }
+}

quant_cli/examples/selection/prepare.json

@@ -0,0 +1,13 @@
+{
+  "instrument_ids": [
+    "CN.XSHE.002371",
+    "CN.XSHG.600141",
+    "CN.XSHG.603015",
+    "CN.XSHG.605580",
+    "CN.XSHG.688679"
+  ],
+  "start": "2026-09-22T00:00:00+08:00",
+  "end": "2026-09-30T23:59:59+08:00",
+  "lookback_days": 0,
+  "adjustment_type": "none"
+}

quant_cli/examples/selection/select.json

@@ -0,0 +1,44 @@
+{
+  "manifest_path": "REPLACE_WITH_MANIFEST_PATH",
+  "factor_run_uuid": "REPLACE_WITH_FACTOR_RUN_UUID",
+  "instrument_ids": [
+    "CN.XSHE.002371",
+    "CN.XSHG.600141",
+    "CN.XSHG.603015",
+    "CN.XSHG.605580",
+    "CN.XSHG.688679"
+  ],
+  "factors": [
+    {
+      "name": "close_pressure_5d",
+      "weight": "0.25",
+      "transform": {
+        "normalization": "rank"
+      }
+    },
+    {
+      "name": "intraday_strength_5d",
+      "weight": "0.25",
+      "transform": {
+        "normalization": "rank"
+      }
+    },
+    {
+      "name": "low_intraday_volatility_5d",
+      "weight": "0.25",
+      "transform": {
+        "normalization": "rank"
+      }
+    },
+    {
+      "name": "volume_expansion",
+      "weight": "0.25",
+      "transform": {
+        "normalization": "rank"
+      }
+    }
+  ],
+  "target_as_of": "2026-09-29",
+  "decision_time": "2026-09-30T10:00:00+08:00",
+  "top_n": 3
+}

quant_cli/examples/strategies/bar_roundtrip.py

@@ -0,0 +1,12 @@
+"""日线策略链路验收：首根收盘后买，持仓后收盘卖。"""
+
+
+async def on_bar(event, context):
+    instrument_id = event.payload.instrument_id
+    position = await context.portfolio.get_position(instrument_id)
+    if position and position.quantity:
+        context.order(instrument_id, -position.quantity)
+    elif not context.state.get(instrument_id):
+        context.order(instrument_id, 100)
+        context.state[instrument_id] = True
+    return []

quant_cli/examples/strategies/buy_and_hold.py

@@ -0,0 +1,11 @@
+"""买入持有基线：首个日线收盘后买入 100 股，此后不交易。"""
+
+
+async def on_bar(event, context):
+    instrument_id = event.payload.instrument_id
+    if instrument_id != context.universe[0]:
+        return []
+    if not context.state.get("entry_submitted"):
+        context.order(instrument_id, 100)
+        context.state["entry_submitted"] = True
+    return []

quant_cli/examples/strategies/contrarian_timing.py

@@ -0,0 +1,14 @@
+"""20 日动量反向择时样例：负动量持有 100 股，否则空仓。"""
+
+
+async def on_bar(event, context):
+    instrument_id = event.payload.instrument_id
+    momentum = context.factor_value("momentum_20d", instrument_id)
+    if momentum is None:
+        return []
+    target = 100 if momentum < 0 else 0
+    position = await context.portfolio.get_position(instrument_id)
+    held = position.quantity if position else 0
+    if held != target and not context.get_open_orders(instrument_id):
+        context.order_target(instrument_id, target)
+    return []

quant_cli/examples/strategies/factor_gate_vwap.py

@@ -0,0 +1,22 @@
+"""Three-factor PIT demonstration using the shared strategy callback contract."""
+
+from decimal import Decimal
+
+from quant_core.app.data.constants import MarketEventType
+
+
+async def on_session(event, context):
+    if event.payload.session is not MarketEventType.SESSION_OPEN:
+        return []
+    for instrument_id in context.universe:
+        momentum = context.factor_value("momentum_20d", instrument_id)
+        volume_ratio = context.factor_value("volume_ratio_5d", instrument_id)
+        moving_average = context.factor_value("ma_close_10", instrument_id)
+        if None in (momentum, volume_ratio, moving_average):
+            continue
+        position = await context.portfolio.get_position(instrument_id)
+        if position and position.quantity:
+            context.order(instrument_id, -position.quantity)
+        elif momentum > 0 and volume_ratio > Decimal("0.5") and moving_average > 0:
+            context.order(instrument_id, 100)
+    return []

quant_cli/examples/strategies/ipo_next_day_vwap.py

@@ -0,0 +1,31 @@
+"""Theoretical IPO first-day buy and next-day sell using daily VWAP fills."""
+
+from quant_core.app.data.constants import MarketEventType
+
+
+async def on_session(event, context):
+    if event.payload.session is not MarketEventType.SESSION_OPEN:
+        return []
+    today = context.event_time.date()
+    listed = await context.market.list_instruments_on(today)
+    eligible = {
+        item.instrument_id
+        for item in listed
+        if item.listed_date == today and item.instrument_id in context.universe
+    }
+    for instrument_id in sorted(eligible):
+        context.order(instrument_id, 100)
+        context.state[f"bought:{instrument_id}"] = today
+    for instrument_id in context.universe:
+        position = await context.portfolio.get_position(instrument_id)
+        buy_date = context.state.get(f"bought:{instrument_id}")
+        if (
+            position
+            and position.quantity
+            and buy_date is not None
+            and buy_date != today
+            and not context.state.get(f"sold:{instrument_id}")
+        ):
+            context.order(instrument_id, -position.quantity)
+            context.state[f"sold:{instrument_id}"] = True
+    return []

quant_cli/examples/strategies/momentum_timing.py

@@ -0,0 +1,14 @@
+"""20 日动量择时样例：正动量持有 100 股，否则空仓。"""
+
+
+async def on_bar(event, context):
+    instrument_id = event.payload.instrument_id
+    momentum = context.factor_value("momentum_20d", instrument_id)
+    if momentum is None:
+        return []
+    target = 100 if momentum > 0 else 0
+    position = await context.portfolio.get_position(instrument_id)
+    held = position.quantity if position else 0
+    if held != target and not context.get_open_orders(instrument_id):
+        context.order_target(instrument_id, target)
+    return []

quant_cli/examples/strategies/monthly_equal_weight.py

@@ -0,0 +1,19 @@
+"""月度等权再平衡样例：两只或更多股票，保留 10% 现金缓冲。"""
+
+from decimal import Decimal
+
+
+async def on_bar(event, context):
+    month = (context.event_time.year, context.event_time.month)
+    if context.state.get("rebalance_month") == month:
+        return []
+    # 同一时点必须每只标的都有新鲜价格；停牌/缺失时延后本月调仓。
+    if any(
+        (bar := context.current(instrument_id)) is None or bar.timestamp != context.event_time
+        for instrument_id in context.universe
+    ):
+        return []
+    weight = Decimal("0.9") / len(context.universe)
+    context.rebalance({instrument_id: weight for instrument_id in context.universe})
+    context.state["rebalance_month"] = month
+    return []

quant_cli/examples/strategies/session_roundtrip.py

@@ -0,0 +1,16 @@
+"""Small trusted-local strategy for backtest smoke tests."""
+
+from quant_core.app.data.constants import MarketEventType
+
+
+async def on_session(event, context):
+    if event.payload.session is not MarketEventType.SESSION_OPEN:
+        return []
+    for instrument_id in context.universe:
+        position = await context.portfolio.get_position(instrument_id)
+        if position and position.quantity:
+            context.order(instrument_id, -position.quantity)
+        elif not context.state.get(instrument_id):
+            context.order(instrument_id, 100)
+            context.state[instrument_id] = True
+    return []