```json { "rows": [ { "key": "f-quote-age", "spreads_acted": [ 1, 2, 3, 4 ], "off_equals_n": true, "code_sha256": "35cb7a9112227f249caa8f5b4e6101e4362421c9ff685a620e60ab8f62795e9d", "assembled_sha256": "cbeaebbee7e0357ddece0f85fa65ab890082e72d6c36cbd7a5e1c2521de3fc3a", "tuning": { "mean_diff": -0.03163299586800074, "se": 0.1069885454072102 }, "paired": { "n": 500, "complete": true, "incumbent_mean": 104.4137531881468, "mean_diff": 0.11318337429079979, "se": 0.16642112417107266, "sum_d": 56.591687145399895, "sum_d2": 6916.55488541364, "retail_diff": 0.09398898731520024, "arb_diff": 0.019194386980400005, "failures": 0 }, "by_spread": { "1": { "runs": 115, "mean_diff": -0.2541400437878268, "se": 0.1390246458974571, "sum_d": -29.22610503560008, "sum_d2": 260.8156655217288 }, "2": { "runs": 116, "mean_diff": 0.06250483192241374, "se": 0.11832119145960329, "sum_d": 7.250560502999994, "sum_d2": 187.21191907350737 }, "3": { "runs": 138, "mean_diff": -0.06119003765217422, "se": 0.03675006345750325, "sum_d": -8.444225196000042, "sum_d2": 26.050525262738212 }, "4": { "runs": 131, "mean_diff": 0.6642095944580154, "se": 0.6122972985893271, "sum_d": 87.01145687400003, "sum_d2": 6442.476775555665 } }, "flag": [] }, { "key": "f-boundary", "spreads_acted": [ 2 ], "off_equals_n": true, "code_sha256": "4e5eeb89bf80374db02f4c99e8675bfb0a6b523284fb48816179e565175aa114", "assembled_sha256": "e79e0fce84fea5d735cd353bf8ac1b55d7c0ce392789cfdfbf635cca2109b743", "tuning": { "mean_diff": 0.318514, "se": 0.355087 }, "paired": { "n": 500, "complete": true, "incumbent_mean": 104.413753, "mean_diff": -1.765506, "se": 1.112315, "sum_d": -882.752798, "sum_d2": 310251.037534, "retail_diff": 0.165674, "arb_diff": -1.93118, "failures": 0 }, "by_spread": { "1": { "runs": 115, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 }, "2": { "runs": 116, "mean_diff": -7.609938, "se": 4.770076, "sum_d": -882.752798, "sum_d2": 310251.037534 }, "3": { "runs": 138, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 }, "4": { "runs": 131, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 } }, "flag": [] }, { "key": "f-step-inside", "spreads_acted": [ 2 ], "off_equals_n": true, "code_sha256": "706c66ded92f9ed83a8e68a67b95a07f32f2553c77337f29b760bb3189798b4c", "assembled_sha256": "2fabfee2a8a44bdc34ad4e1c65379df7c4b9fdaf93c431f27710ead9d79624c8", "tuning": { "mean_diff": 0.0006398837305000171, "se": 0.0006011241195053529 }, "paired": { "n": 500, "complete": true, "incumbent_mean": 104.4137531881468, "mean_diff": 0.0008917695677999547, "se": 0.00035265207303674886, "sum_d": 0.4458847838999773, "sum_d2": 0.031426315892997624, "retail_diff": 0, "arb_diff": 0.0008917695678000009, "failures": [] }, "by_spread": { "1": { "runs": 115, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 }, "2": { "runs": 116, "mean_diff": 0.003843834343965322, "se": 0.001492419843758561, "sum_d": 0.4458847838999773, "sum_d2": 0.031426315892997624 }, "3": { "runs": 138, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 }, "4": { "runs": 131, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 } }, "flag": [] }, { "key": "f-retail-reach", "spreads_acted": [ 3 ], "off_equals_n": true, "code_sha256": "1b2361fa0566e3f25083f9cfd44b430da624d5ce321ae4bda582504dad6a5316", "assembled_sha256": "43c611444e9194efdf64fafba88b095574dfdd6efdee370d47d183051d6afe8c", "tuning": { "mean_diff": 0.008152, "se": 0.012858 }, "paired": { "n": 500, "complete": true, "incumbent_mean": 104.392176, "mean_diff": -0.104299, "se": 0.07199, "sum_d": -52.149546, "sum_d2": 1298.49414, "retail_diff": -0.014461, "arb_diff": -0.089838, "failures": 0 }, "by_spread": { "1": { "runs": 115, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 }, "2": { "runs": 116, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 }, "3": { "runs": 138, "mean_diff": -0.377895, "se": 0.260075, "sum_d": -52.149546, "sum_d2": 1298.49414 }, "4": { "runs": 131, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 } }, "flag": [ "incumbent_mean unlike the other rows" ] }, { "key": "f-fill-imbalance", "spreads_acted": [ 2 ], "off_equals_n": true, "code_sha256": "2ebc1d2958aaa086ba3467b9295a07a0b9fc9cd94e882f4ce2148ef66d6306bf", "assembled_sha256": "88d65086163c21f6e5bd808a8509b1530b49331cee3f128dd51a3d974c561804", "tuning": { "mean_diff": -0.29641540954949985, "se": 0.11646691350741475 }, "paired": { "n": 500, "complete": true, "incumbent_mean": 104.39217582931519, "mean_diff": -0.29910455828379984, "se": 0.09448538194529064, "sum_d": -149.55227914189993, "sum_d2": 2272.1398750292637, "retail_diff": 0.25743266281519955, "arb_diff": -0.5565372210972002, "failures": 0 }, "by_spread": { "1": { "runs": 115, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 }, "2": { "runs": 116, "mean_diff": -1.289243785706034, "se": 0.39480609634502734, "sum_d": -149.55227914189993, "sum_d2": 2272.1398750292637 }, "3": { "runs": 138, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 }, "4": { "runs": 131, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 } }, "flag": [ "incumbent_mean unlike the other rows" ] }, { "key": "f-partial-keep", "spreads_acted": [ 1 ], "off_equals_n": true, "code_sha256": "ec0c7e6e7258241803cd1781e690287f211db7d1ff322a46c9c79ba18711e9d7", "assembled_sha256": "0fb7d12cdf380157cf5da73c851d059862c6f3c88707b7d71e7f385ad512a672", "tuning": { "mean_diff": 0.00018210142500000082, "se": 0.00016932320397428162 }, "paired": { "n": 500, "complete": true, "incumbent_mean": 104.4137531881468, "mean_diff": -0.0010023571944000052, "se": 0.0010808006472422462, "sum_d": -0.5011785972000026, "sum_d2": 0.29195080472285767, "retail_diff": 0.00018090335100005283, "arb_diff": -0.001183260545799989, "failures": 0 }, "by_spread": { "1": { "runs": 115, "mean_diff": -0.0043580747582608916, "se": 0.004701352767401744, "sum_d": -0.5011785972000026, "sum_d2": 0.29195080472285767 }, "2": { "runs": 116, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 }, "3": { "runs": 138, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 }, "4": { "runs": 131, "mean_diff": 0, "se": 0, "sum_d": 0, "sum_d2": 0 } }, "flag": [] } ], "top": [ { "key": "f-step-inside", "spread": 2, "code": "# Antithetic posterior integration; only public StepState history is used.\nimport math as _fsi_math\nfrom statistics import NormalDist as _FsiNormal\nfrom dataclasses import replace as _fsi_replace\nfrom orderbook_pm_challenge.types import PlaceOrder as _FsiPlace, CancelOrder as _FsiCancel, CancelAll as _FsiAll, Side as _FsiSide\n\nclass Strategy(BaseStrategy):\n SPREADS = (2,)\n ENABLED = True\n FRACTION = 0.25\n CAP = 6.0\n HURDLE = 1.25\n _prefix = 'fsi-antithetic-'\n\n def __init__(self):\n self._n = _N()\n self._spread = None\n self._mean = 0.5\n self._var = 0.0001\n self._prev_mid = None\n self._jump_rate = 0.0019\n self._ticks = 0\n self._jumps = 0\n self._normal = _FsiNormal()\n self._nodes = ((0.0, 2.0/3.0), (-1.7320508075688772, 1.0/6.0), (1.7320508075688772, 1.0/6.0))\n\n def _posterior(self, state):\n b, a = state.competitor_best_bid_ticks, state.competitor_best_ask_ticks\n lo = (b or 0) / 100.0\n hi = (a if a is not None else 100) / 100.0\n mid = (lo + hi) * 0.5\n horizon = max(1, state.steps_remaining)\n tau = _fsi_math.sqrt(horizon * (0.0004 + self._jump_rate * 0.17333333333333334))\n p = min(0.99999, max(0.00001, self._mean))\n z = self._normal.inv_cdf(p)\n dp = 0.02 * _fsi_math.exp(-0.5*z*z) / (_fsi_math.sqrt(2*_fsi_math.pi)*tau)\n if self._prev_mid is None:\n # The initial ladder brackets p within one tick after removing s-1.\n lo = min(hi, lo + (self._spread-1)/100.0)\n hi = max(lo, hi - (self._spread-1)/100.0)\n self._mean = (lo+hi)/2.0\n self._var = max(1e-7, (hi-lo)**2/12.0)\n else:\n self._ticks += 1\n change = abs(mid-self._prev_mid)\n if change > max(0.035, 6.0*dp):\n self._jumps += 1\n self._jump_rate = min(0.003, max(0.0008, (1.9+self._jumps)/(1000.0+self._ticks)))\n v = self._var + dp*dp\n sd = _fsi_math.sqrt(max(v, 1e-9))\n # Retail can also remove competitor quotes: soften the interval.\n lower, upper = max(0.0,lo-0.0025), min(1.0,hi+0.0025)\n al, be = (lower-self._mean)/sd, (upper-self._mean)/sd\n mass = self._normal.cdf(be)-self._normal.cdf(al)\n if mass < 1e-6:\n self._mean = min(upper,max(lower,self._mean))\n self._var = max(dp*dp, min(0.0001,(upper-lower)**2/12.0))\n else:\n pa = _fsi_math.exp(-0.5*al*al)/_fsi_math.sqrt(2*_fsi_math.pi)\n pb = _fsi_math.exp(-0.5*be*be)/_fsi_math.sqrt(2*_fsi_math.pi)\n delta = (pa-pb)/mass\n self._mean += sd*delta\n self._var = max(1e-8, v*(1.0+(al*pa-be*pb)/mass-delta*delta))\n self._prev_mid = mid\n self._mean = min(0.99999,max(0.00001,self._mean))\n return tau\n\n def _predict(self, state, tau):\n # Posterior, diffusion and jump nodes each come in antithetic pairs.\n horizon = max(1,state.steps_remaining)\n next_tau = tau*_fsi_math.sqrt(max(0.5,horizon-1)/horizon)\n sd = _fsi_math.sqrt(self._var)\n lam = self._jump_rate\n points = []\n for u, wu in self._nodes:\n p = min(0.99999,max(0.00001,self._mean+u*sd))\n score = self._normal.inv_cdf(p)*tau\n for d, wd in self._nodes:\n x = score+0.02*d\n points.append((self._normal.cdf(x/next_tau),wu*wd*(1-lam)))\n for j, wj in self._nodes:\n points.append((self._normal.cdf((x+_fsi_math.sqrt(0.17333333333333334)*j)/next_tau),wu*wd*lam*wj))\n return points\n\n def _worth(self, side, tick, quantity, points, ahead):\n price = tick/100.0\n loss = retail = 0.0\n # Mean retail parameters under the stated randomization prior.\n # Six antithetic lognormal nodes integrate priority fill quantity.\n flow = ((-1.382994,1/6),(-0.674490,1/6),(-0.210428,1/6),\n (0.210428,1/6),(0.674490,1/6),(1.382994,1/6))\n notionals = [(_fsi_math.exp(_fsi_math.log(4.488)-0.72+1.2*z),w) for z,w in flow]\n for p,w in points:\n margin = p-price if side == _FsiSide.BUY else price-p\n if margin < 0:\n loss -= w*quantity*margin\n else:\n denom = max(p,0.05) if side == _FsiSide.BUY else price\n filled = sum(v*min(quantity,max(0.0,n/denom-ahead)) for n,v in notionals)\n retail += w*0.1265*filled*margin\n return retail > self.HURDLE*loss and retail > 1e-7\n\n def on_step(self, state):\n if self._spread is None:\n b,a = state.competitor_best_bid_ticks,state.competitor_best_ask_ticks\n self._spread = max(1,(a-b+1)//2) if a is not None and b is not None else 0\n if not self.ENABLED or self._spread not in self.SPREADS:\n return self._n.on_step(state)\n hidden = tuple(o for o in state.own_orders if o.order_id.startswith(self._prefix))\n visible = tuple(o for o in state.own_orders if not o.order_id.startswith(self._prefix))\n clean = _fsi_replace(state,own_orders=visible)\n actions = list(self._n.on_step(clean))\n expiry = [_FsiCancel(o.order_id) for o in hidden]\n tau = self._posterior(state)\n # Project N's surviving book, keeping original action locations.\n book = {o.order_id:(o.side,o.price_ticks,o.remaining_quantity,None,o.order_id) for o in visible}\n for i,act in enumerate(actions):\n if isinstance(act,_FsiAll):\n book.clear()\n elif isinstance(act,_FsiCancel):\n book.pop(act.order_id,None)\n elif isinstance(act,_FsiPlace):\n book[act.client_order_id or ('new',i)] = (act.side,act.price_ticks,act.quantity,i,act.client_order_id)\n points = None\n extras = []\n original_actions = list(actions)\n for side in (_FsiSide.BUY,_FsiSide.SELL):\n candidates = [(k,v) for k,v in book.items() if v[0] == side]\n if not candidates:\n continue\n key,entry = (max(candidates,key=lambda kv:kv[1][1]) if side == _FsiSide.BUY else min(candidates,key=lambda kv:kv[1][1]))\n _,old,q,index,oid = entry\n bid,ask = state.competitor_best_bid_ticks,state.competitor_best_ask_ticks\n target = (bid+1 if bid is not None else 0) if side == _FsiSide.BUY else (ask-1 if ask is not None else 100)\n if not 1 <= target <= 99:\n continue\n if side == _FsiSide.BUY:\n if target == old or (ask is not None and target >= ask):\n continue\n elif target == old or (bid is not None and target <= bid):\n continue\n part = _fsi_math.floor(min(self.CAP,q*self.FRACTION)*100)/100.0\n if part < 0.01 or q-part < 0.01:\n continue\n if points is None:\n points = self._predict(state,tau)\n ahead = sum(v[2] for v in book.values() if v[0] == side and ((v[1] > target) if side == _FsiSide.BUY else (v[1] < target)))\n if (old > target if side == _FsiSide.BUY else old < target):\n ahead = max(0.0,ahead-part)\n if not self._worth(side,target,part,points,ahead):\n continue\n rest = _fsi_math.floor((q-part+1e-9)*100)/100.0\n if index is None:\n extras.extend((_FsiCancel(oid),_FsiPlace(side,old,rest,oid)))\n else:\n actions[index] = _fsi_replace(actions[index],quantity=rest)\n new_id = self._prefix+str(state.step)+'-'+side.value\n extras.append(_FsiPlace(side,target,part,new_id))\n book[key] = (side,old,rest,index,oid)\n book[new_id] = (side,target,part,None,new_id)\n if not extras:\n return expiry+actions\n # All-sells-uncovered is a conservative collateral bound. Initial N\n # actions only shrink; the added orders are placed after those actions.\n worst = sum((p/100 if side == _FsiSide.BUY else 1-p/100)*q for side,p,q,_,_ in book.values())\n if worst > state.cash-0.02:\n return expiry+original_actions\n return expiry+actions+extras\n" }, { "key": "f-quote-age", "spread": 4, "code": "from orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, CancelAll, Side\n\nclass Strategy(BaseStrategy):\n def __init__(self):\n self.n = _N()\n self.spread = None\n self.history = {}\n\n def on_step(self, state):\n cb = state.competitor_best_bid_ticks\n ca = state.competitor_best_ask_ticks\n if self.spread is None:\n self.spread = max(1, ((ca or 100) - (cb or 0) + 1) // 2)\n self.history[state.step] = (cb, ca)\n actions = list(self.n.on_step(state))\n if self.spread not in (1, 2, 3, 4):\n return actions\n canceled = {a.order_id for a in actions if isinstance(a, CancelOrder)}\n cancel_all = any(isinstance(a, CancelAll) for a in actions)\n for order in state.own_orders:\n base = self.history.get(order.submitted_step)\n if base is None:\n continue\n age = max(0, state.step - order.submitted_step)\n if order.side is Side.BUY and cb is not None and base[0] is not None:\n drift = abs(base[0] - order.price_ticks) - abs(cb - order.price_ticks)\n elif order.side is Side.SELL and ca is not None and base[1] is not None:\n drift = abs(base[1] - order.price_ticks) - abs(ca - order.price_ticks)\n else:\n continue\n limit = max(1, 3 - age // 100)\n if drift >= limit and not cancel_all and order.order_id not in canceled:\n actions.append(CancelOrder(order.order_id))\n return actions\n" }, { "key": "f-partial-keep", "spread": 1, "code": "# f-partial-keep overlay. When N cancels a partly filled order that is still on the\n# right side of the competitor's quotes, the remainder stays in the book (it holds its\n# FIFO place) and one of N's new orders on that side shrinks by the same quantity.\n# N is shown a view in which the kept remainder is part of that new order, so it sees\n# the book it asked for. If N later cancels that order the remainder is judged again.\nfrom dataclasses import replace as _replace\n\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import (\n CancelAll,\n CancelOrder,\n OwnOrderView,\n PlaceOrder,\n Side,\n)\n\n\nclass Strategy(BaseStrategy):\n SPREADS = frozenset({1})\n SAME_LEVEL_ONLY = False\n\n def __init__(self):\n self._n = _N()\n self._s = None\n self._orig = {} # real order id -> size placed\n self._pend = {} # (side, tick) -> sizes placed last step, in order\n self._back = {} # N's order id -> ids of kept remainders inside it\n self._meta = {} # N's order id -> (side, tick, step)\n\n def on_step(self, state):\n if self._s is None:\n b, a = state.competitor_best_bid_ticks, state.competitor_best_ask_ticks\n self._s = 0 if b is None or a is None else max(1, (a - b + 1) // 2)\n if self._s not in self.SPREADS:\n return self._n.on_step(state)\n self._learn_sizes(state)\n real = {o.order_id: o for o in state.own_orders}\n forced = self._prune(state, real)\n actions = self._n.on_step(self._view(state, real, forced))\n out = self._apply(state, actions, real, forced, True)\n self._remember(out)\n return out\n\n def _learn_sizes(self, state):\n # Same side, price and step fill FIFO, so the survivors are the last placed.\n groups = {}\n for o in state.own_orders:\n if o.order_id not in self._orig and o.submitted_step == state.step - 1:\n groups.setdefault((o.side, o.price_ticks), []).append(o)\n for key, views in groups.items():\n qs = self._pend.get(key, [])\n for o, q in zip(views, qs[max(0, len(qs) - len(views)):]):\n self._orig[o.order_id] = q\n self._pend = {}\n\n def _remember(self, actions):\n for a in actions:\n if isinstance(a, PlaceOrder):\n q = int(a.quantity * 100 + 1e-7) / 100\n self._pend.setdefault((a.side, a.price_ticks), []).append(q)\n\n @staticmethod\n def _right_side(state, o):\n if o.side is Side.BUY:\n ask = state.competitor_best_ask_ticks\n return ask is not None and o.price_ticks < ask\n bid = state.competitor_best_bid_ticks\n return bid is not None and o.price_ticks > bid\n\n def _prune(self, state, real):\n # Forget filled remainders; cancel any that crossed to the wrong side.\n forced = []\n for vid in list(self._back):\n live = []\n for oid in self._back[vid]:\n o = real.get(oid)\n if o is None:\n continue\n if self._right_side(state, o):\n live.append(oid)\n else:\n forced.append(oid)\n if live:\n self._back[vid] = live\n else:\n del self._back[vid]\n self._meta.pop(vid, None)\n return forced\n\n def _view(self, state, real, forced):\n if not self._back and not forced:\n return state\n hidden = set(forced)\n for ids in self._back.values():\n hidden.update(ids)\n extra = {\n v: sum(real[i].remaining_quantity for i in ids) for v, ids in self._back.items()\n }\n rows = []\n for o in state.own_orders:\n if o.order_id in hidden:\n continue\n if o.order_id in extra:\n q = round(o.remaining_quantity + extra[o.order_id], 10)\n o = _replace(o, remaining_quantity=q)\n rows.append(o)\n for v, q in extra.items():\n if v not in real:\n side, tick, step = self._meta[v]\n rows.append(OwnOrderView(v, side, tick, round(q, 10), step))\n rows.sort(key=lambda o: (o.side.value, o.price_ticks if o.side is Side.SELL else -o.price_ticks))\n return _replace(state, own_orders=tuple(rows))\n\n def _is_partial(self, o):\n q = self._orig.get(o.order_id)\n return q is not None and o.remaining_quantity < q - 1e-9\n\n def _apply(self, state, actions, real, forced, allow):\n hidden = set(forced)\n for ids in self._back.values():\n hidden.update(ids)\n if any(isinstance(a, CancelAll) for a in actions):\n cancelled = [o for o in real if o not in hidden]\n cancelled += [v for v in self._back if v not in real]\n else:\n cancelled = [a.order_id for a in actions if isinstance(a, CancelOrder)]\n places = [a for a in actions if isinstance(a, PlaceOrder)]\n cands, drop = [], list(forced)\n back = {k: list(v) for k, v in self._back.items()}\n for vid in cancelled:\n own = real.get(vid)\n if own is not None and vid not in hidden:\n if self._is_partial(own) and self._right_side(state, own):\n cands.append(own)\n else:\n drop.append(vid)\n for oid in back.pop(vid, ()):\n if self._right_side(state, real[oid]):\n cands.append(real[oid])\n else:\n drop.append(oid)\n if not cands and not forced and not any(p.client_order_id in hidden for p in places):\n self._back = back\n return actions\n sizes = {i: p.quantity for i, p in enumerate(places)}\n meta = {}\n for o in cands:\n i = self._pick(o, places, sizes) if allow else None\n if i is None:\n drop.append(o.order_id)\n continue\n sizes[i] = round(sizes[i] - o.remaining_quantity, 10)\n vid = places[i].client_order_id\n back.setdefault(vid, []).append(o.order_id)\n meta[vid] = (places[i].side, places[i].price_ticks, state.step)\n # A new id equal to a hidden id would be refused by the book.\n new_ids = {p.client_order_id for p in places}\n for v in list(back):\n keep = [x for x in back[v] if x not in new_ids]\n drop += [x for x in back[v] if x in new_ids]\n if keep:\n back[v] = keep\n else:\n del back[v]\n out = [CancelOrder(x) for x in drop]\n for i, p in enumerate(places):\n q = int(sizes[i] * 100 + 1e-7) / 100\n if q >= 0.01:\n out.append(p if sizes[i] == p.quantity else _replace(p, quantity=q))\n # Collateral guard: kept reservations are not re-derived, so if the placements\n # could not be paid from free cash alone, this step keeps nothing.\n need = sum(\n max(a.price_ticks, 100 - a.price_ticks) / 100 * a.quantity\n for a in out\n if isinstance(a, PlaceOrder)\n )\n if allow and cands and need > state.free_cash:\n return self._apply(state, actions, real, forced, False)\n self._back = back\n self._meta = {k: v for k, v in self._meta.items() if k in back}\n self._meta.update(meta)\n return out\n\n def _pick(self, o, places, sizes):\n # Which of N's new tagged orders absorbs this remainder: same price, then the\n # deepest level behind it, then the nearest better one. None means cancel it.\n buy = o.side is Side.BUY\n key = lambda p: p.price_ticks if buy else -p.price_ticks\n side = [i for i, p in enumerate(places) if p.side is o.side]\n if not side:\n return None\n mine = key(o)\n if mine > max(key(places[i]) for i in side):\n return None # N has pulled back past this price: respect the cancel\n if self.SAME_LEVEL_ONLY and not any(key(places[i]) == mine for i in side):\n return None\n best, rank = None, None\n for i in side:\n if places[i].client_order_id is None or sizes[i] < o.remaining_quantity - 1e-9:\n continue\n p = key(places[i])\n r = (0, 0) if p == mine else ((1, p) if p < mine else (2, p))\n if rank is None or r < rank:\n best, rank = i, r\n return best\n" } ] } ```