Coverage for src/copytrading_engine/execution/adapters/alpaca/models.py: 98%
111 statements
« prev ^ index » next coverage.py v7.16.2, created at 2026-11-16 16:55 +0000
« prev ^ index » next coverage.py v7.16.2, created at 2026-11-16 16:55 +0000
1import datetime as dt
2from typing import Self
4from pydantic import (
5 BaseModel,
6 ConfigDict,
7 Field,
8 StrictBool,
9 TypeAdapter,
10 field_validator,
11 model_validator,
12)
14from copytrading_engine.execution.domain.market import (
15 Account,
16 Asset,
17 Bar,
18 BrokerOrder,
19 CalendarDay,
20 DailyBar,
21 EquityHistory,
22 EquityPoint,
23 HistoryWindow,
24 Position,
25 Quote,
26 QuoteFeed,
27)
28from copytrading_engine.execution.domain.values import Identifier, Money, Positive, Quantity, Side
29from copytrading_engine.shared.symbols import held_symbol
32class AlpacaValue(BaseModel):
33 model_config = ConfigDict(frozen=True, extra="ignore", hide_input_in_errors=True)
36class AlpacaAccount(AlpacaValue):
37 id: Identifier
38 status: Identifier
39 cash: Money
40 buying_power: Money
41 equity: Money
42 last_equity: Money
43 trading_blocked: StrictBool
44 account_blocked: StrictBool
45 trade_suspended_by_user: StrictBool
46 currency: str
49class AlpacaAsset(AlpacaValue):
50 symbol: Identifier
51 asset_class: str = Field(alias="class")
52 status: str
53 tradable: StrictBool
54 fractionable: StrictBool
55 attributes: tuple[str, ...] = ()
56 overnight_tradable: StrictBool = False
57 overnight_halted: StrictBool = False
58 # Given only for a coin; a stock's are null.
59 min_order_size: Positive | None = None
60 min_trade_increment: Positive | None = None
61 price_increment: Positive | None = None
64class AlpacaPosition(AlpacaValue):
65 symbol: Identifier
66 qty: Money
67 market_value: Money | None = None
68 avg_entry_price: Money | None = None
69 current_price: Money | None = None
70 unrealized_pl: Money | None = None
71 unrealized_plpc: Money | None = None
72 asset_class: str = Field(alias="asset_class")
73 currency: str | None = None
76class AlpacaCalendarDay(AlpacaValue):
77 date: dt.date
78 open: dt.time
79 close: dt.time
80 session_open: dt.time = dt.time(4)
81 session_close: dt.time | None = None
83 @field_validator("open", "close", "session_open", "session_close", mode="before")
84 @classmethod
85 def time_value(cls, value: object) -> object:
86 if isinstance(value, str): 86 ↛ 90line 86 didn't jump to line 90 because the condition on line 86 was always true
87 if len(value) == 4 and value.isdecimal():
88 value = f"{value[:2]}:{value[2:]}"
89 return dt.time.fromisoformat(value)
90 return value
93class AlpacaBrokerOrder(AlpacaValue):
94 id: Identifier
95 client_order_id: Identifier
96 symbol: Identifier
97 side: Side
98 qty: Positive
99 filled_qty: Quantity
100 filled_avg_price: Positive | None
101 status: Identifier
102 position_intent: str | None = None
105def _exact_decimal(value: object) -> object:
106 # JSON numbers arrive as floats; their shortest text form is the value Alpaca sent.
107 return str(value) if isinstance(value, float) else value
110class AlpacaBar(AlpacaValue):
111 t: dt.datetime
112 o: Quantity
113 c: Quantity
115 @field_validator("o", "c", mode="before")
116 @classmethod
117 def exact_price(cls, value: object) -> object:
118 return _exact_decimal(value)
121class AlpacaDailyBar(AlpacaValue):
122 t: dt.datetime
123 o: Quantity
124 h: Quantity
125 l: Quantity # noqa: E741
126 c: Quantity
127 v: int
129 @field_validator("o", "h", "l", "c", mode="before")
130 @classmethod
131 def exact_price(cls, value: object) -> object:
132 return _exact_decimal(value)
134 @field_validator("v", mode="before")
135 @classmethod
136 def whole_volume(cls, value: object) -> object:
137 # A coin's volume is fractional; a daily bar's is read in whole shares.
138 return int(value) if isinstance(value, float) else value
141class AlpacaPortfolioHistory(AlpacaValue):
142 timestamp: tuple[int, ...]
143 equity: tuple[Money | None, ...]
144 base_value: Money | None = None
146 @field_validator("equity", mode="before")
147 @classmethod
148 def exact_equity(cls, value: object) -> object:
149 return [_exact_decimal(item) for item in value] if isinstance(value, list) else value
151 @field_validator("base_value", mode="before")
152 @classmethod
153 def exact_base(cls, value: object) -> object:
154 return _exact_decimal(value)
156 @model_validator(mode="after")
157 def aligned_series(self) -> Self:
158 if len(self.timestamp) != len(self.equity):
159 raise ValueError("Portfolio history series differ in length")
160 return self
163class AlpacaQuote(AlpacaValue):
164 """A latest quote. Alpaca sends a side with no quote as 0, which means no price at all."""
166 bp: Quantity | None = None
167 ap: Quantity | None = None
168 t: dt.datetime | None = None
170 @field_validator("bp", "ap", mode="before")
171 @classmethod
172 def exact_side(cls, value: object) -> object:
173 return None if value in (0, "0", None) else _exact_decimal(value)
176def decode_quote(value: object, feed: QuoteFeed) -> Quote:
177 # A reply without a quote object fails validation like any other malformed response.
178 wire = AlpacaQuote.model_validate(value.get("quote") if isinstance(value, dict) else None)
179 return Quote(feed=feed, bid=wire.bp, ask=wire.ap, timestamp=wire.t)
182def decode_crypto_quote(value: object, symbol: str) -> Quote:
183 """A coin's latest quote, from Alpaca's crypto feed, which answers for a list of pairs."""
184 quotes = value.get("quotes") if isinstance(value, dict) else None
185 wire = AlpacaQuote.model_validate(quotes.get(symbol) if isinstance(quotes, dict) else None)
186 return Quote(feed="crypto", bid=wire.bp, ask=wire.ap, timestamp=wire.t)
189def decode_bars(value: object) -> tuple[Bar, ...]:
190 """The bars of one symbol: a stock's reply lists them, a coin's keys them by pair."""
191 wire = TypeAdapter(tuple[AlpacaBar, ...]).validate_python(value)
192 return tuple(Bar(at=bar.t, open=bar.o, close=bar.c) for bar in wire)
195def decode_daily_bars(value: object) -> tuple[DailyBar, ...]:
196 """The daily bars of one symbol, oldest first."""
197 wire = TypeAdapter(tuple[AlpacaDailyBar, ...]).validate_python(value)
198 return tuple(
199 DailyBar(at=bar.t, open=bar.o, high=bar.h, low=bar.l, close=bar.c, volume=bar.v)
200 for bar in wire
201 )
204def decode_portfolio_history(value: object, window: HistoryWindow) -> EquityHistory:
205 wire = AlpacaPortfolioHistory.model_validate(value)
206 return EquityHistory(
207 window=window,
208 base_value=wire.base_value,
209 points=tuple(
210 EquityPoint(at=dt.datetime.fromtimestamp(stamp, dt.UTC), equity=equity)
211 for stamp, equity in zip(wire.timestamp, wire.equity, strict=True)
212 if equity is not None
213 ),
214 )
217def decode_account(value: object) -> Account:
218 wire = AlpacaAccount.model_validate(value)
219 return Account.model_validate(wire.model_dump())
222def decode_asset(value: object) -> Asset:
223 wire = AlpacaAsset.model_validate(value)
224 return Asset.model_validate(wire.model_dump())
227def decode_calendar(value: object) -> tuple[CalendarDay, ...]:
228 wire_days = TypeAdapter(tuple[AlpacaCalendarDay, ...]).validate_python(value)
229 return tuple(CalendarDay.model_validate(day.model_dump()) for day in wire_days)
232def decode_positions(value: object, *, account_currency: str | None = None) -> tuple[Position, ...]:
233 wire_positions = TypeAdapter(tuple[AlpacaPosition, ...]).validate_python(value)
234 return tuple(
235 Position.model_validate(
236 position.model_dump()
237 | {
238 "currency": position.currency
239 if position.currency is not None
240 else account_currency,
241 # Alpaca lists a coin held as BTCUSD; everywhere else it is the pair, BTC/USD.
242 "symbol": held_symbol(position.symbol, position.asset_class),
243 }
244 )
245 for position in wire_positions
246 )
249def decode_broker_order(value: object) -> BrokerOrder:
250 wire = AlpacaBrokerOrder.model_validate(value)
251 return BrokerOrder.model_validate(wire.model_dump())
254def decode_orders(value: object) -> tuple[BrokerOrder, ...]:
255 wire_orders = TypeAdapter(tuple[AlpacaBrokerOrder, ...]).validate_python(value)
256 return tuple(BrokerOrder.model_validate(order.model_dump()) for order in wire_orders)