forked from Torom/BotLi
-
Notifications
You must be signed in to change notification settings - Fork 1
/
botli_dataclasses.py
214 lines (178 loc) · 6.85 KB
/
botli_dataclasses.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
from dataclasses import dataclass, field
from datetime import timedelta
from chess.polyglot import MemoryMappedReader
from aliases import Challenge_ID
from enums import Challenge_Color, Perf_Type, Variant
@dataclass
class API_Challenge_Reponse:
challenge_id: Challenge_ID | None = None
was_accepted: bool = False
error: str | None = None
was_declined: bool = False
invalid_initial: bool = False
invalid_increment: bool = False
has_reached_rate_limit: bool = False
@dataclass
class Bot:
username: str
tos_violation: bool
rating_diff: int
def __eq__(self, __o: object) -> bool:
if isinstance(__o, Bot):
return __o.username == self.username
return NotImplemented
@dataclass
class Challenge_Request:
opponent_username: str
initial_time: int
increment: int
rated: bool
color: Challenge_Color
variant: Variant
timeout: int
def __eq__(self, __o: object) -> bool:
if isinstance(__o, Challenge_Request):
return __o.opponent_username == self.opponent_username
return NotImplemented
@dataclass
class Challenge_Response:
challenge_id: Challenge_ID | None = None
success: bool = False
has_reached_rate_limit: bool = False
is_misconfigured: bool = False
@dataclass(frozen=True)
class Game_Information:
id_: str
white_title: str | None
white_name: str
white_rating: int | None
white_ai_level: int | None
white_provisional: bool
black_title: str | None
black_name: str
black_rating: int | None
black_ai_level: int | None
black_provisional: bool
initial_time_ms: int
increment_ms: int
speed: str
rated: bool
variant: Variant
variant_name: str
initial_fen: str
is_white: bool
state: dict
@classmethod
def from_gameFull_event(cls, gameFull_event: dict, username: str) -> 'Game_Information':
assert gameFull_event['type'] == 'gameFull'
id_ = gameFull_event['id']
white_title = gameFull_event['white'].get('title')
white_name = gameFull_event['white'].get('name', 'AI')
white_rating = gameFull_event['white'].get('rating')
white_ai_level = gameFull_event['white'].get('aiLevel')
white_provisional = gameFull_event['white'].get('provisional', False)
black_title = gameFull_event['black'].get('title')
black_name = gameFull_event['black'].get('name', 'AI')
black_rating = gameFull_event['black'].get('rating')
black_ai_level = gameFull_event['black'].get('aiLevel')
black_provisional = gameFull_event['black'].get('provisional', False)
initial_time_ms = gameFull_event['clock']['initial']
increment_ms = gameFull_event['clock']['increment']
speed = gameFull_event['speed']
rated = gameFull_event['rated']
variant = Variant(gameFull_event['variant']['key'])
variant_name = gameFull_event['variant']['name']
initial_fen = gameFull_event['initialFen']
is_white = white_name == username
state = gameFull_event['state']
return Game_Information(id_, white_title, white_name, white_rating, white_ai_level, white_provisional,
black_title, black_name, black_rating, black_ai_level, black_provisional,
initial_time_ms, increment_ms, speed, rated, variant, variant_name, initial_fen,
is_white, state)
@property
def id_str(self) -> str:
return f'ID: {self.id_}'
@property
def white_str(self) -> str:
title_str = f'{self.white_title} ' if self.white_title else ''
provisional_str = '?' if self.white_provisional else ''
rating_str = f'{self.white_rating}{provisional_str}' if self.white_rating else f'Level {self.white_ai_level}'
return f'{title_str}{self.white_name} ({rating_str})'
@property
def black_str(self) -> str:
title_str = f'{self.black_title} ' if self.black_title else ''
provisional_str = '?' if self.black_provisional else ''
rating_str = f'{self.black_rating}{provisional_str}' if self.black_rating else f'Level {self.black_ai_level}'
return f'{title_str}{self.black_name} ({rating_str})'
@property
def tc_str(self) -> str:
initial_time_min = self.initial_time_ms / 60_000
if initial_time_min.is_integer():
initial_time_str = str(int(initial_time_min))
elif initial_time_min == 0.25:
initial_time_str = '¼'
elif initial_time_min == 0.5:
initial_time_str = '½'
elif initial_time_min == 0.75:
initial_time_str = '¾'
else:
initial_time_str = str(initial_time_min)
increment_sec = self.increment_ms // 1000
return f'TC: {initial_time_str}+{increment_sec}'
@property
def rated_str(self) -> str:
return 'Rated' if self.rated else 'Casual'
@property
def variant_str(self) -> str:
return f'Variant: {self.variant_name}'
@property
def opponent_is_bot(self) -> bool:
return self.black_title == 'BOT' if self.is_white else self.white_title == 'BOT'
@property
def opponent_username(self) -> str:
return self.black_name if self.is_white else self.white_name
@property
def opponent_title(self) -> str | None:
return self.black_title if self.is_white else self.white_title
@property
def opponent_rating(self) -> int | None:
return self.black_rating if self.is_white else self.white_rating
@dataclass
class Matchmaking_Type:
name: str
initial_time: int
increment: int
estimated_game_duration: timedelta = field(init=False)
rated: bool
variant: Variant
perf_type: Perf_Type
multiplier: int
weight: int
min_rating_diff: int
max_rating_diff: int
def __post_init__(self) -> None:
self.estimated_game_duration = timedelta(seconds=(self.initial_time * 0.8 + self.increment * 80) * 2)
@property
def to_str(self) -> str:
name_str = f'{self.name}:'
initial_time_min = self.initial_time / 60
if initial_time_min.is_integer():
initial_time_str = str(int(initial_time_min))
elif initial_time_min == 0.25:
initial_time_str = '¼'
elif initial_time_min == 0.5:
initial_time_str = '½'
elif initial_time_min == 0.75:
initial_time_str = '¾'
else:
initial_time_str = str(initial_time_min)
tc_str = f'TC: {initial_time_str}+{self.increment}'
rated_str = 'Rated' if self.rated else 'Casual'
variant_str = f'Variant: {self.variant.value}'
delimiter = 5 * ' '
return delimiter.join([name_str, tc_str, rated_str, variant_str])
@dataclass
class Book_Settings:
selection: str = ''
max_depth: int = 600
readers: dict[str, MemoryMappedReader] = field(default_factory=dict)