use serde::Serialize;
use crate::query::{
CompetitionCategory,
CompetitionGroup,
CompetitionSortBy,
DatasetFileType,
DatasetGroup,
DatasetLicenseName,
Group,
KernelType,
Language,
OutputType,
SortBy,
};
use std::path::{Path, PathBuf};
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CompetitionsList {
#[serde(with = "crate::none_as_empty")]
group: Option<CompetitionGroup>,
#[serde(with = "crate::none_as_empty")]
category: Option<CompetitionCategory>,
#[serde(with = "crate::none_as_empty")]
sort_by: Option<CompetitionSortBy>,
page: usize,
#[serde(with = "crate::none_as_empty")]
search: Option<String>,
}
impl CompetitionsList {
pub fn new(page: usize) -> Self {
Self {
group: None,
category: None,
sort_by: None,
page,
search: None,
}
}
pub fn group(mut self, group: CompetitionGroup) -> Self {
self.group = Some(group);
self
}
pub fn category(mut self, category: CompetitionCategory) -> Self {
self.category = Some(category);
self
}
pub fn sort_by(mut self, sort_by: CompetitionSortBy) -> Self {
self.sort_by = Some(sort_by);
self
}
pub fn search(mut self, search: impl ToString) -> Self {
self.search = Some(search.to_string());
self
}
}
impl Default for CompetitionsList {
fn default() -> Self {
Self::new(1)
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct KernelsList {
page: usize,
page_size: usize,
#[serde(with = "crate::none_as_empty")]
dataset: Option<String>,
#[serde(with = "crate::none_as_empty")]
competition: Option<String>,
#[serde(with = "crate::none_as_empty")]
parent_kernel: Option<String>,
#[serde(with = "crate::none_as_empty")]
search: Option<String>,
group: Group,
#[serde(with = "crate::none_as_empty")]
user: Option<String>,
language: Language,
kernel_type: KernelType,
output_type: OutputType,
sort_by: SortBy,
}
impl Default for KernelsList {
fn default() -> Self {
Self::with_page(1)
}
}
impl KernelsList {
pub fn with_page(page: usize) -> Self {
Self {
page,
page_size: 20,
dataset: None,
competition: None,
parent_kernel: None,
search: None,
group: Default::default(),
user: None,
language: Default::default(),
kernel_type: Default::default(),
output_type: Default::default(),
sort_by: Default::default(),
}
}
pub fn page_size(mut self, page_size: usize) -> Self {
self.page_size = page_size;
self
}
pub fn mine(mut self, group: Group) -> Self {
self.group = group;
self
}
pub fn dataset(mut self, dataset: impl ToString) -> Self {
self.dataset = Some(dataset.to_string());
self
}
pub fn competition(mut self, competition: impl ToString) -> Self {
self.competition = Some(competition.to_string());
self
}
pub fn parent_kernel(mut self, parent_kernel: impl ToString) -> Self {
self.parent_kernel = Some(parent_kernel.to_string());
self
}
pub fn search(mut self, search: impl ToString) -> Self {
self.search = Some(search.to_string());
self
}
pub fn user(mut self, user: impl ToString) -> Self {
self.user = Some(user.to_string());
self
}
pub fn language(mut self, language: Language) -> Self {
self.language = language;
self
}
pub fn kernel_type(mut self, kernel_type: KernelType) -> Self {
self.kernel_type = kernel_type;
self
}
pub fn output_type(mut self, output_type: OutputType) -> Self {
self.output_type = output_type;
self
}
pub fn sort_by(mut self, sort_by: SortBy) -> Self {
self.sort_by = sort_by;
self
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DatasetsList {
group: DatasetGroup,
sort_by: SortBy,
filetype: DatasetFileType,
#[serde(with = "crate::none_as_empty")]
tagids: Option<String>,
license: DatasetLicenseName,
#[serde(with = "crate::none_as_empty")]
search: Option<String>,
#[serde(with = "crate::none_as_empty")]
user: Option<String>,
page: usize,
#[serde(skip_serializing_if = "Option::is_none")]
max_size: Option<usize>,
#[serde(skip_serializing_if = "Option::is_none")]
min_size: Option<usize>,
}
impl DatasetsList {
pub fn with_page(page: usize) -> Self {
Self {
page,
sort_by: SortBy::Hotness,
filetype: DatasetFileType::All,
tagids: None,
license: DatasetLicenseName::All,
search: None,
user: None,
max_size: None,
min_size: None,
group: DatasetGroup::default(),
}
}
pub fn page(mut self, page: usize) -> Self {
self.page = page;
self
}
pub fn max_size(mut self, max_size: usize) -> Self {
self.max_size = Some(max_size);
self
}
pub fn min_size(mut self, min_size: usize) -> Self {
self.min_size = Some(min_size);
self
}
pub fn file_type(mut self, file_type: DatasetFileType) -> Self {
self.filetype = file_type;
self
}
pub fn search(mut self, search: impl ToString) -> Self {
self.search = Some(search.to_string());
self
}
pub fn user(mut self, user: impl ToString) -> Self {
self.user = Some(user.to_string());
self.group = DatasetGroup::User;
self
}
pub fn mine(mut self) -> Self {
self.user = None;
self.group = DatasetGroup::My;
self
}
pub fn public(mut self) -> Self {
self.user = None;
self.group = DatasetGroup::Public;
self
}
pub fn license_name(mut self, license_name: DatasetLicenseName) -> Self {
self.license = license_name;
self
}
pub fn sort_by(mut self, sort_by: SortBy) -> Self {
self.sort_by = sort_by;
self
}
pub fn tag_ids(mut self, tag_ids: impl ToString) -> Self {
self.tagids = Some(tag_ids.to_string());
self
}
}
impl Default for DatasetsList {
fn default() -> Self {
Self::with_page(1)
}
}
#[derive(Debug, Clone)]
pub struct KernelPullRequest {
pub with_metadata: bool,
pub name: String,
pub output: Option<PathBuf>,
}
impl KernelPullRequest {
pub fn new(name: impl ToString) -> Self {
Self {
with_metadata: false,
name: name.to_string(),
output: None,
}
}
pub fn output(mut self, output: impl AsRef<Path>) -> Self {
self.output = Some(output.as_ref().to_path_buf());
self
}
pub fn with_metadata(mut self, with_metadata: bool) -> Self {
self.with_metadata = with_metadata;
self
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ser_empty() {
#[derive(Serialize)]
struct Dummy {
#[serde(with = "crate::none_as_empty")]
group: Option<CompetitionGroup>,
}
let x = Dummy { group: None };
assert_eq!(r#"{"group":""}"#, serde_json::to_string(&x).unwrap());
}
}