synpath 0.1.0__py3-none-any.whl

synpath/engine/orders/stop.py

@@ -0,0 +1,240 @@
+"""Stops: stop-market, stop-limit, and trailing.
+
+None of the three venues holds a stop on a prediction market, so the engine
+watches the price and sends a child when the level is reached. What "the
+price" means is the whole question, and the answer here is the touch on the
+side that would fill you: a buy stop watches the best ask, a sell stop the
+best bid.
+
+Why not the last trade or the mid, which most venues use? A prediction
+market's book is thin and its tape is slow. A market that last traded four
+hours ago would leave a last-trade stop asleep through a move; a mid sitting
+between a 0.30 bid and a 0.70 ask is a number nobody can trade at. The touch
+is the price at which the triggered order could actually execute, so it is
+the price the trigger should use. `trigger_source` takes `last` or `mid` for
+callers who disagree, and says so in the journal either way.
+
+**Trailing** ratchets: a sell stop follows the highest bid seen, a buy stop
+the lowest ask, never the other way. The distance is `trail` in price units
+or `trail_percent` of the watched price, and the current stop is persisted,
+so a restart resumes from the level the market actually reached rather than
+from where it started.
+
+**Triggering is one-way.** Once fired, the child is out; a price that comes
+back does not un-trigger it. A stop-market child is an immediate-or-cancel
+limit at a protection price (the touch plus `max_slippage`, or the caller's
+own), because no venue here accepts a market order without one.
+"""
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any
+
+from ...trading.types import Fill, Order, OrderRequest, OrderType, Side, TimeInForce
+from .base import ZERO, Child, Context, D, ManagedOrder
+from .manager import register
+
+TRIGGER_SOURCES = ("touch", "last", "mid")
+
+
+class _Stop(ManagedOrder):
+    """Shared machinery: watch a price, fire once, then work the child."""
+
+    default_slippage = Decimal("0.05")
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.stop_price: Decimal = D(self.request.stop_price)
+        self.trigger_source: str = str(self.params.get("trigger_source") or "touch")
+        if self.trigger_source not in TRIGGER_SOURCES:
+            raise ValueError(f"trigger_source must be one of {TRIGGER_SOURCES}, not {self.trigger_source!r}")
+        self.triggered_at: int | None = None
+        self.trigger_price: Decimal | None = None
+
+    # -- the watched price ----------------------------------------------------
+
+    def watched(self, ctx: Context) -> Decimal | None:
+        if self.trigger_source == "touch":
+            return ctx.touch(self.side)
+        if self.trigger_source == "mid":
+            return ctx.mid()
+        return ctx.last()
+
+    def reached(self, price: Decimal) -> bool:
+        """A buy stop fires when the price rises to it, a sell stop when it falls."""
+        return price >= self.stop_price if self.side == Side.BUY else price <= self.stop_price
+
+    async def on_book(self, ctx: Context, market_id: str) -> None:
+        if self.trigger_source in ("touch", "mid"):
+            await self.consider(ctx)
+
+    async def on_trade(self, ctx: Context, market_id: str, price: Decimal, amount: Decimal) -> None:
+        if self.trigger_source == "last":
+            await self.consider(ctx, price)
+
+    async def consider(self, ctx: Context, price: Decimal | None = None) -> None:
+        if self.state != "waiting":
+            return
+        watched = price if price is not None else self.watched(ctx)
+        if watched is None:
+            return
+        await self.adjust(ctx, watched)
+        if self.reached(watched):
+            await self.trigger(ctx, watched)
+
+    async def adjust(self, ctx: Context, watched: Decimal) -> None:
+        """Trailing overrides this; a fixed stop does not move."""
+
+    # -- firing ---------------------------------------------------------------
+
+    async def trigger(self, ctx: Context, watched: Decimal) -> None:
+        self.state = "working"
+        self.triggered_at = int(ctx.now * 1000)
+        self.trigger_price = watched
+        await ctx.publish("managed.triggered", {
+            "kind": self.kind, "stop_price": str(self.stop_price), "trigger_price": str(watched),
+            "trigger_source": self.trigger_source,
+        })
+        await self.send_child(ctx, watched)
+
+    async def send_child(self, ctx: Context, watched: Decimal) -> None:
+        raise NotImplementedError
+
+    def protection(self, ctx: Context, watched: Decimal) -> Decimal | None:
+        """The worst price the triggered order may pay."""
+        given = D(self.params.get("protection"))
+        if given is not None:
+            return given
+        slippage = D(self.params.get("max_slippage"), self.default_slippage)
+        touch = ctx.touch(self.side)
+        if touch is None:
+            # No book to price against. A last-trade trigger can fire on a
+            # market nobody is quoting, and an order sent then would take
+            # whatever appears.
+            return None
+        return touch + slippage if self.side == Side.BUY else touch - slippage
+
+    async def on_fill(self, ctx: Context, fill: Fill, child: Child) -> None:
+        await self.complete_if_done(ctx)
+
+    async def on_child(self, ctx: Context, order: Order, child: Child) -> None:
+        if not order.is_terminal or self.state != "working":
+            return
+        if self.remaining <= 0:
+            await self.finish(ctx, "done", "filled")
+        elif not self.live_children:
+            # The child ended without finishing the job: say so rather than
+            # quietly leaving a stop that has already fired.
+            await self.finish(ctx, "done", f"child {order.status.value} with {self.remaining} unfilled")
+
+    # -- persistence ----------------------------------------------------------
+
+    def extra(self) -> dict[str, Any]:
+        return {
+            "stop_price": str(self.stop_price), "trigger_source": self.trigger_source,
+            "triggered_at": self.triggered_at,
+            "trigger_price": str(self.trigger_price) if self.trigger_price is not None else None,
+        }
+
+    def load_extra(self, extra: dict[str, Any]) -> None:
+        self.stop_price = D(extra.get("stop_price"), self.stop_price)
+        self.trigger_source = extra.get("trigger_source", self.trigger_source)
+        self.triggered_at = extra.get("triggered_at")
+        self.trigger_price = D(extra.get("trigger_price"))
+
+
+@register
+class StopMarket(_Stop):
+    """Fires an immediate-or-cancel child at the protection price."""
+
+    kind = "stop_market"
+    order_type = OrderType.STOP_MARKET
+
+    async def send_child(self, ctx: Context, watched: Decimal) -> None:
+        price = self.protection(ctx, watched)
+        if price is None:
+            await self.finish(ctx, "rejected", "no book and no protection price: refusing to send at any price")
+            return
+        request = self.child_request(amount=self.remaining, price=price, type=OrderType.MARKET,
+                                     time_in_force=TimeInForce.IOC)
+        order = await ctx.submit_child(request)
+        self.track(order, request.amount, price)
+        await ctx.save()
+
+
+@register
+class StopLimit(_Stop):
+    """Fires a limit child at the price the caller named."""
+
+    kind = "stop_limit"
+    order_type = OrderType.STOP_LIMIT
+
+    async def send_child(self, ctx: Context, watched: Decimal) -> None:
+        price = D(self.request.price)
+        request = self.child_request(amount=self.remaining, price=price, type=OrderType.LIMIT,
+                                     time_in_force=self.request.time_in_force or TimeInForce.GTC,
+                                     expires_at=self.request.expires_at)
+        order = await ctx.submit_child(request)
+        self.track(order, request.amount, price)
+        await ctx.save()
+
+
+@register
+class TrailingStop(_Stop):
+    """A stop that follows the market one way and never the other."""
+
+    kind = "trailing_stop"
+    order_type = OrderType.TRAILING_STOP
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.trail = D(self.params.get("trail"))
+        self.trail_percent = D(self.params.get("trail_percent"))
+        if self.trail is None and self.trail_percent is None:
+            raise ValueError("a trailing stop needs params trail or trail_percent")
+        self.extreme: Decimal | None = None
+        """The best price seen: the highest for a sell stop, the lowest for a buy."""
+
+    def distance(self, watched: Decimal) -> Decimal:
+        if self.trail is not None:
+            return self.trail
+        return watched * self.trail_percent / Decimal("100")
+
+    async def adjust(self, ctx: Context, watched: Decimal) -> None:
+        improved = (
+            self.extreme is None
+            or (self.side == Side.SELL and watched > self.extreme)
+            or (self.side == Side.BUY and watched < self.extreme)
+        )
+        if not improved:
+            return
+        self.extreme = watched
+        distance = self.distance(watched)
+        moved = watched - distance if self.side == Side.SELL else watched + distance
+        # The stop only ever tightens towards the market.
+        if self.stop_price is None or (moved > self.stop_price if self.side == Side.SELL else moved < self.stop_price):
+            self.stop_price = moved
+            await ctx.publish("managed.trailed", {"stop_price": str(moved), "watched": str(watched)})
+            await ctx.save()
+
+    async def send_child(self, ctx: Context, watched: Decimal) -> None:
+        price = D(self.request.price) or self.protection(ctx, watched)
+        kind = OrderType.LIMIT if self.request.price is not None else OrderType.MARKET
+        request = self.child_request(amount=self.remaining, price=price, type=kind,
+                                     time_in_force=TimeInForce.IOC if kind == OrderType.MARKET else TimeInForce.GTC)
+        order = await ctx.submit_child(request)
+        self.track(order, request.amount, price)
+        await ctx.save()
+
+    def extra(self) -> dict[str, Any]:
+        return super().extra() | {
+            "trail": str(self.trail) if self.trail is not None else None,
+            "trail_percent": str(self.trail_percent) if self.trail_percent is not None else None,
+            "extreme": str(self.extreme) if self.extreme is not None else None,
+        }
+
+    def load_extra(self, extra: dict[str, Any]) -> None:
+        super().load_extra(extra)
+        self.trail = D(extra.get("trail"))
+        self.trail_percent = D(extra.get("trail_percent"))
+        self.extreme = D(extra.get("extreme"))

synpath/engine/orders/taker.py

@@ -0,0 +1,187 @@
+"""Taking liquidity: the market order these venues do not have, and a patient one.
+
+**Market.** None of the three venues holds a market order: Kalshi's V2 has
+only limits, and the other two turn one into an immediate limit. Sending a
+single limit at the far touch fills what is there and cancels the rest, which
+is not what "market" means either. So the engine walks the book: an
+immediate-or-cancel clip at each level in turn, stopping at the caller's
+protection price or when `max_slippage` from the first touch is spent. What
+it cannot buy within that range it reports unfilled, because the alternative
+is paying any price at all.
+
+**Smart taker** is the same walk with patience: clips of `clip` contracts,
+`interval_s` apart, up to `limit`. It exists because taking two hundred
+contracts in one clip pays for depth that would have refilled in thirty
+seconds. Between clips it does nothing, which is the point; if the market
+improves it takes the better price, and if it runs away it stops at the
+limit.
+
+Both count what the book actually offered, so a caller can tell a fill that
+cost slippage from one that did not.
+"""
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any
+
+from ...trading.types import Fill, Order, OrderRequest, OrderType, Side, TimeInForce
+from .base import ZERO, Child, Context, D, ManagedOrder
+from .manager import register
+
+
+class _Taker(ManagedOrder):
+    """Shared: a price bound, a clip, and one live child at a time."""
+
+    default_slippage = Decimal("0.05")
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.limit = D(self.params.get("limit")) or D(self.request.price)
+        self.max_slippage = D(self.params.get("max_slippage"), self.default_slippage)
+        self.first_touch: Decimal | None = None
+        self.clips = 0
+        self.next_clip_at: float = 0.0
+        self.paid: Decimal = ZERO
+
+    def bound(self, ctx: Context) -> Decimal | None:
+        """The worst price this order may pay, from the limit or the slippage."""
+        if self.limit is not None:
+            return self.limit
+        if self.first_touch is None:
+            self.first_touch = ctx.touch(self.side)
+        if self.first_touch is None:
+            return None
+        return (self.first_touch + self.max_slippage) if self.side == Side.BUY else (self.first_touch - self.max_slippage)
+
+    def affordable(self, ctx: Context) -> tuple[Decimal, Decimal] | None:
+        """How much of the far side is inside the bound, and at what price."""
+        bound = self.bound(ctx)
+        if bound is None:
+            return None
+        available = ZERO
+        worst: Decimal | None = None
+        for price, size in ctx.levels(self.side):
+            if (self.side == Side.BUY and price > bound) or (self.side == Side.SELL and price < bound):
+                break
+            available += size
+            worst = price
+        if available <= 0 or worst is None:
+            return None
+        return available, bound
+
+    async def take(self, ctx: Context, size: Decimal) -> bool:
+        """One immediate-or-cancel clip. `False` when there is nothing to take."""
+        offered = self.affordable(ctx)
+        if offered is None:
+            return False
+        available, bound = offered
+        amount = min(size, available, self.remaining)
+        if amount <= 0:
+            return False
+        request = self.child_request(amount=amount, price=bound, type=OrderType.MARKET,
+                                     time_in_force=TimeInForce.IOC)
+        order = await ctx.submit_child(request)
+        self.track(order, amount, bound)
+        self.clips += 1
+        await ctx.publish("managed.clip", {"amount": str(amount), "bound": str(bound), "clip": self.clips})
+        await ctx.save()
+        return True
+
+    async def on_fill(self, ctx: Context, fill: Fill, child: Child) -> None:
+        self.paid += fill.price * fill.amount
+        await self.complete_if_done(ctx)
+
+    def extra(self) -> dict[str, Any]:
+        return {
+            "limit": str(self.limit) if self.limit is not None else None,
+            "max_slippage": str(self.max_slippage),
+            "first_touch": str(self.first_touch) if self.first_touch is not None else None,
+            "clips": self.clips, "next_clip_at": self.next_clip_at, "paid": str(self.paid),
+        }
+
+    def load_extra(self, extra: dict[str, Any]) -> None:
+        self.limit = D(extra.get("limit"))
+        self.max_slippage = D(extra.get("max_slippage"), self.default_slippage)
+        self.first_touch = D(extra.get("first_touch"))
+        self.clips = int(extra.get("clips") or 0)
+        self.next_clip_at = float(extra.get("next_clip_at") or 0)
+        self.paid = D(extra.get("paid"), ZERO)
+
+
+@register
+class MarketOrder(_Taker):
+    """A market order the engine holds: walk the book inside the bound, now."""
+
+    kind = "market_engine"
+    order_type = OrderType.MARKET
+
+    async def start(self, ctx: Context) -> None:
+        self.state = "working"
+        if not await self.take(ctx, self.remaining):
+            await self.finish(ctx, "canceled", "nothing on the book inside the price bound")
+
+    async def on_child(self, ctx: Context, order: Order, child: Child) -> None:
+        if self.state != "working" or not order.is_terminal:
+            return
+        if self.remaining <= 0:
+            await self.finish(ctx, "done", "filled")
+            return
+        # The clip took what was there; try the next level, once.
+        if not await self.take(ctx, self.remaining):
+            await self.finish(ctx, "done" if self.filled else "canceled",
+                              f"stopped with {self.remaining} unfilled: the book ran out inside the bound")
+
+
+@register
+class SmartTaker(_Taker):
+    """`params`: `clip`, `interval_s`, `limit`, `max_slippage`, `expires_s`."""
+
+    kind = "smart_taker"
+    order_type = OrderType.SMART_TAKER
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.clip = D(self.params.get("clip")) or self.amount
+        self.interval_s = float(self.params.get("interval_s") or 1.0)
+        self.expires_s = float(self.params.get("expires_s") or 0)
+        self.started_at: float = 0.0
+
+    async def start(self, ctx: Context) -> None:
+        self.state = "working"
+        self.started_at = ctx.now
+        await self.clip_now(ctx)
+
+    async def clip_now(self, ctx: Context) -> None:
+        if await self.take(ctx, self.clip):
+            self.next_clip_at = ctx.now + self.interval_s
+        else:
+            # Nothing inside the bound: wait and look again.
+            self.next_clip_at = ctx.now + self.interval_s
+
+    async def on_timer(self, ctx: Context) -> None:
+        if self.state != "working":
+            return
+        if self.expires_s and ctx.now - self.started_at >= self.expires_s:
+            await self.finish(ctx, "done" if self.filled else "canceled",
+                              f"expired with {self.remaining} unfilled")
+            return
+        if self.live_children or ctx.now < self.next_clip_at or self.remaining <= 0:
+            return
+        await self.clip_now(ctx)
+
+    async def on_child(self, ctx: Context, order: Order, child: Child) -> None:
+        if self.state == "working" and self.remaining <= 0 and not self.live_children:
+            await self.finish(ctx, "done", "filled")
+
+    def extra(self) -> dict[str, Any]:
+        return super().extra() | {
+            "clip": str(self.clip), "interval_s": self.interval_s, "expires_s": self.expires_s,
+            "started_at": self.started_at,
+        }
+
+    def load_extra(self, extra: dict[str, Any]) -> None:
+        super().load_extra(extra)
+        self.clip = D(extra.get("clip"), self.amount)
+        self.interval_s = float(extra.get("interval_s") or 1.0)
+        self.expires_s = float(extra.get("expires_s") or 0)
+        self.started_at = float(extra.get("started_at") or 0)

synpath/engine/orders/twap.py

@@ -0,0 +1,190 @@
+"""TWAP: the same order, spread over time.
+
+Buying two hundred contracts at once on a book with forty at the touch pays
+for the privilege. A TWAP cuts the order into slices and works them across a
+window, so the average price is closer to the market's own average than to
+the depth of one moment.
+
+How it decides what to do, each slice:
+
+* **The schedule is by clock, not by fill.** Slices are due at even
+  intervals across the window. A slice that misses its turn is not skipped;
+  the next one carries what is behind, so the order still finishes on time.
+* **Patient or aggressive is a choice.** `style="limit"` posts at the near
+  touch and lets the market come; `style="taker"` crosses with an
+  immediate-or-cancel at the far touch. A limit slice that is still resting
+  when the next one is due is pulled first, so the order cannot end up with
+  five stale slices in the book.
+* **The end is respected.** With `finish="complete"` the remainder is taken
+  at the end of the window; with `finish="stop"` whatever is unfilled is
+  abandoned, which is what a caller who was only ever price-sensitive wants.
+
+A restart resumes the schedule from the clock, because the window's start and
+end are persisted; the engine does not need to remember how many timers it
+had running.
+"""
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any
+
+from ...trading.types import Fill, Order, OrderRequest, OrderType, Side, TimeInForce
+from .base import ZERO, Child, Context, D, ManagedOrder
+from .manager import register
+
+
+@register
+class TWAP(ManagedOrder):
+    """`params`: `window_s`, `slices`, `style`, `limit`, `finish`."""
+
+    kind = "twap"
+    order_type = OrderType.TWAP
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.window_s = float(self.params.get("window_s") or 0)
+        self.slices = int(self.params.get("slices") or 0)
+        if self.window_s <= 0 or self.slices <= 0:
+            raise ValueError("a TWAP needs params window_s and slices, both above zero")
+        self.style = str(self.params.get("style") or "limit")
+        if self.style not in ("limit", "taker"):
+            raise ValueError("a TWAP's style is 'limit' or 'taker'")
+        self.limit = D(self.params.get("limit")) or D(self.request.price)
+        """The worst price any slice may pay. `None` means the market's."""
+        self.at_end = str(self.params.get("finish") or "complete")
+        """What the end of the window does with anything unfilled."""
+        self.started_at: float = 0.0
+        self.sent_slices = 0
+
+    # -- the schedule ---------------------------------------------------------
+
+    @property
+    def interval(self) -> float:
+        return self.window_s / self.slices
+
+    def due_by(self, now: float) -> int:
+        """How many slices should have gone out by now."""
+        if self.started_at <= 0:
+            return 0
+        elapsed = max(0.0, now - self.started_at)
+        return min(self.slices, int(elapsed // self.interval) + 1)
+
+    def slice_size(self) -> Decimal:
+        per_slice = self.amount / self.slices
+        return min(per_slice, self.remaining)
+
+    def ends_at(self) -> float:
+        return self.started_at + self.window_s
+
+    # -- running --------------------------------------------------------------
+
+    async def start(self, ctx: Context) -> None:
+        self.state = "working"
+        self.started_at = ctx.now
+        await self.work(ctx)
+
+    async def on_timer(self, ctx: Context) -> None:
+        if self.state == "working":
+            await self.work(ctx)
+
+    async def work(self, ctx: Context) -> None:
+        if self.remaining <= 0:
+            await self.complete_if_done(ctx)
+            return
+        now = ctx.now
+        if now >= self.ends_at():
+            await self.close_out(ctx)
+            return
+        due = self.due_by(now)
+        if self.sent_slices >= due:
+            return
+        # A limit slice still resting when the next is due has had its turn.
+        for child in self.live_children:
+            await ctx.cancel_child(child.order_id)
+            child.status = "canceled"
+        behind = due - self.sent_slices
+        size = min(self.remaining, self.slice_size() * behind)
+        if size <= 0:
+            return
+        await self.send(ctx, size)
+        self.sent_slices = due
+        await ctx.save()
+
+    async def send(self, ctx: Context, size: Decimal) -> None:
+        if self.style == "taker":
+            price = ctx.touch(self.side) or self.limit
+            if self.limit is not None and price is not None:
+                price = min(price, self.limit) if self.side == Side.BUY else max(price, self.limit)
+            if price is None:
+                return
+            request = self.child_request(amount=size, price=price, type=OrderType.MARKET,
+                                         time_in_force=TimeInForce.IOC)
+        else:
+            near = ctx.book()
+            price = None
+            if near is not None:
+                price = near.best_bid if self.side == Side.BUY else near.best_ask
+            price = price or self.limit
+            if price is None:
+                return
+            if self.limit is not None:
+                price = min(price, self.limit) if self.side == Side.BUY else max(price, self.limit)
+            request = self.child_request(amount=size, price=price, type=OrderType.LIMIT,
+                                         time_in_force=TimeInForce.GTC, post_only=self.request.post_only)
+        order = await ctx.submit_child(request)
+        self.track(order, size, D(request.price))
+        await ctx.publish("managed.slice", {"amount": str(size), "price": str(request.price),
+                                            "slice": self.sent_slices + 1, "of": self.slices, "style": self.style})
+
+    async def close_out(self, ctx: Context) -> None:
+        """The window is over."""
+        for child in self.live_children:
+            await ctx.cancel_child(child.order_id)
+            child.status = "canceled"
+        if self.remaining > 0 and self.at_end == "complete":
+            price = ctx.touch(self.side) or self.limit
+            if price is not None:
+                if self.limit is not None:
+                    price = min(price, self.limit) if self.side == Side.BUY else max(price, self.limit)
+                request = self.child_request(amount=self.remaining, price=price, type=OrderType.MARKET,
+                                             time_in_force=TimeInForce.IOC)
+                order = await ctx.submit_child(request)
+                self.track(order, request.amount, price)
+                await ctx.publish("managed.close_out", {"amount": str(request.amount), "price": str(price)})
+                await ctx.save()
+                return
+        await self.finish_window(ctx)
+
+    async def finish_window(self, ctx: Context) -> None:
+        if self.remaining <= 0:
+            await self.finish(ctx, "done", "filled")
+        else:
+            await self.finish(ctx, "done" if self.filled > 0 else "canceled",
+                              f"the window ended with {self.remaining} unfilled")
+
+    async def on_fill(self, ctx: Context, fill: Fill, child: Child) -> None:
+        await self.complete_if_done(ctx)
+
+    async def on_child(self, ctx: Context, order: Order, child: Child) -> None:
+        if self.state != "working" or not order.is_terminal:
+            return
+        if self.remaining <= 0:
+            await self.finish(ctx, "done", "filled")
+        elif ctx.now >= self.ends_at() and not self.live_children:
+            await self.finish_window(ctx)
+
+    def extra(self) -> dict[str, Any]:
+        return {
+            "window_s": self.window_s, "slices": self.slices, "style": self.style, "finish": self.at_end,
+            "limit": str(self.limit) if self.limit is not None else None,
+            "started_at": self.started_at, "sent_slices": self.sent_slices,
+        }
+
+    def load_extra(self, extra: dict[str, Any]) -> None:
+        self.window_s = float(extra.get("window_s") or self.window_s)
+        self.slices = int(extra.get("slices") or self.slices)
+        self.style = extra.get("style", self.style)
+        self.at_end = extra.get("finish", self.at_end)
+        self.limit = D(extra.get("limit"))
+        self.started_at = float(extra.get("started_at") or 0)
+        self.sent_slices = int(extra.get("sent_slices") or 0)