litchee 0.1.6

Async, builder-pattern Rust client for the Lichess API: full endpoint coverage, NDJSON streaming, and OAuth2 PKCE ('Log in with Lichess').
Documentation 
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
215
216
217
218
219
220
221
222

//! DTOs for a user's per-perf statistics (`GET /api/user/{username}/perf/{perf}`).
//!
//! Models the full `PerfStat` schema, including the deeply-nested `stat`
//! aggregate (counts, best/worst results, and result/play streaks).

use serde::{Deserialize, Serialize};

use super::LichessGlicko;
use crate::model::LichessLightUser;

/// The rating part of a [`LichessPerfStat`].
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct LichessPerfStatPerf {
    /// The Glicko-2 rating.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub glicko: Option<LichessGlicko>,
    /// Number of games played.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nb: Option<u32>,
    /// Recent progress.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub progress: Option<i32>,
}

/// A rating extreme (highest/lowest) with the game it occurred in.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct LichessPerfStatRatingAt {
    /// The rating value.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub int: Option<i32>,
    /// When it was reached (ISO 8601).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub at: Option<String>,
    /// The game in which it was reached.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub game_id: Option<String>,
}

/// A single notable result (a best win or a worst loss).
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct LichessPerfStatResult {
    /// The opponent's rating.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub op_rating: Option<i32>,
    /// The opponent.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub op_id: Option<LichessLightUser>,
    /// When the game was played (ISO 8601).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub at: Option<String>,
    /// The game id.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub game_id: Option<String>,
}

/// A wrapper around a list of notable results.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct LichessPerfStatResults {
    /// The notable results.
    #[serde(default)]
    pub results: Vec<LichessPerfStatResult>,
}

/// Aggregate game counts for a perf.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct LichessPerfStatCount {
    /// Total games.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub all: Option<u32>,
    /// Rated games.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rated: Option<u32>,
    /// Wins.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub win: Option<u32>,
    /// Losses.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub loss: Option<u32>,
    /// Draws.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub draw: Option<u32>,
    /// Tournament games.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tour: Option<u32>,
    /// Berserked games.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub berserk: Option<u32>,
    /// Average opponent rating.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub op_avg: Option<f64>,
    /// Total time spent, in seconds.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub seconds: Option<u64>,
    /// Number of disconnects.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disconnects: Option<u32>,
}

/// The game boundary (start or end) of a streak span.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct LichessPerfStatStreakStamp {
    /// When the boundary game was played (ISO 8601).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub at: Option<String>,
    /// The boundary game id.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub game_id: Option<String>,
}

/// One streak span: its length and the games that bound it.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct LichessPerfStatStreakSpan {
    /// The span length (games, or seconds for time streaks).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub v: Option<u64>,
    /// The first game of the span.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from: Option<LichessPerfStatStreakStamp>,
    /// The last game of the span.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub to: Option<LichessPerfStatStreakStamp>,
}

/// A current and maximum streak span.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct LichessPerfStatStreak {
    /// The current span.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cur: Option<LichessPerfStatStreakSpan>,
    /// The longest span.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max: Option<LichessPerfStatStreakSpan>,
}

/// Win and loss streaks by result.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct LichessPerfStatResultStreak {
    /// The winning streaks.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub win: Option<LichessPerfStatStreak>,
    /// The losing streaks.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub loss: Option<LichessPerfStatStreak>,
}

/// Streaks by number of games and by time played.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct LichessPerfStatPlayStreak {
    /// Streaks measured in games.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nb: Option<LichessPerfStatStreak>,
    /// Streaks measured in time.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub time: Option<LichessPerfStatStreak>,
    /// When the user last played this perf (ISO 8601).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_date: Option<String>,
}

/// The detailed `stat` aggregate of a [`LichessPerfStat`].
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct LichessPerfStatDetails {
    /// The highest rating ever reached.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub highest: Option<LichessPerfStatRatingAt>,
    /// The lowest rating ever reached.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub lowest: Option<LichessPerfStatRatingAt>,
    /// The best wins by opponent rating.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub best_wins: Option<LichessPerfStatResults>,
    /// The worst losses by opponent rating.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worst_losses: Option<LichessPerfStatResults>,
    /// Aggregate game counts.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub count: Option<LichessPerfStatCount>,
    /// Win/loss streaks.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result_streak: Option<LichessPerfStatResultStreak>,
    /// Games/time streaks.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub play_streak: Option<LichessPerfStatPlayStreak>,
}

/// Statistics for one of a user's perfs. `GET /api/user/{username}/perf/{perf}`
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub struct LichessPerfStat {
    /// The user's percentile within this perf.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub percentile: Option<f64>,
    /// The user's rank within this perf.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rank: Option<u32>,
    /// The user.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<LichessLightUser>,
    /// The rating details.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub perf: Option<LichessPerfStatPerf>,
    /// The detailed statistics aggregate.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stat: Option<LichessPerfStatDetails>,
}