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

1import datetime as dt 

2from typing import Self 

3 

4from pydantic import ( 

5 BaseModel, 

6 ConfigDict, 

7 Field, 

8 StrictBool, 

9 TypeAdapter, 

10 field_validator, 

11 model_validator, 

12) 

13 

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 

30 

31 

32class AlpacaValue(BaseModel): 

33 model_config = ConfigDict(frozen=True, extra="ignore", hide_input_in_errors=True) 

34 

35 

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 

47 

48 

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 

62 

63 

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 

74 

75 

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 

82 

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 

91 

92 

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 

103 

104 

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 

108 

109 

110class AlpacaBar(AlpacaValue): 

111 t: dt.datetime 

112 o: Quantity 

113 c: Quantity 

114 

115 @field_validator("o", "c", mode="before") 

116 @classmethod 

117 def exact_price(cls, value: object) -> object: 

118 return _exact_decimal(value) 

119 

120 

121class AlpacaDailyBar(AlpacaValue): 

122 t: dt.datetime 

123 o: Quantity 

124 h: Quantity 

125 l: Quantity # noqa: E741 

126 c: Quantity 

127 v: int 

128 

129 @field_validator("o", "h", "l", "c", mode="before") 

130 @classmethod 

131 def exact_price(cls, value: object) -> object: 

132 return _exact_decimal(value) 

133 

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 

139 

140 

141class AlpacaPortfolioHistory(AlpacaValue): 

142 timestamp: tuple[int, ...] 

143 equity: tuple[Money | None, ...] 

144 base_value: Money | None = None 

145 

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 

150 

151 @field_validator("base_value", mode="before") 

152 @classmethod 

153 def exact_base(cls, value: object) -> object: 

154 return _exact_decimal(value) 

155 

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 

161 

162 

163class AlpacaQuote(AlpacaValue): 

164 """A latest quote. Alpaca sends a side with no quote as 0, which means no price at all.""" 

165 

166 bp: Quantity | None = None 

167 ap: Quantity | None = None 

168 t: dt.datetime | None = None 

169 

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) 

174 

175 

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) 

180 

181 

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) 

187 

188 

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) 

193 

194 

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 ) 

202 

203 

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 ) 

215 

216 

217def decode_account(value: object) -> Account: 

218 wire = AlpacaAccount.model_validate(value) 

219 return Account.model_validate(wire.model_dump()) 

220 

221 

222def decode_asset(value: object) -> Asset: 

223 wire = AlpacaAsset.model_validate(value) 

224 return Asset.model_validate(wire.model_dump()) 

225 

226 

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) 

230 

231 

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 ) 

247 

248 

249def decode_broker_order(value: object) -> BrokerOrder: 

250 wire = AlpacaBrokerOrder.model_validate(value) 

251 return BrokerOrder.model_validate(wire.model_dump()) 

252 

253 

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)