kaggle 2.0.0

Unofficial rust implementation of the kaggle api
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

use serde::{Deserialize, Serialize};

use crate::models::DatasetUploadFile;

#[derive(Debug, Serialize, Deserialize)]
pub struct DatasetNewVersionRequest {
    /// The version notes for the new dataset version
    #[serde(rename = "versionNotes")]
    version_notes: String,
    /// The subtitle to set on the dataset
    subtitle: Option<String>,
    /// The description to set on the dataset
    description: Option<String>,
    /// A list of files that should be associated with the dataset
    files: Vec<DatasetUploadFile>,
    /// Whether or not a tabular dataset should be converted to csv
    #[serde(rename = "convertToCsv")]
    convert_to_csv: Option<bool>,
    /// A list of tag IDs to associated with the dataset
    #[serde(rename = "categoryIds")]
    category_ids: Option<Vec<String>>,
    /// Whether or not all previous versions of the dataset should be deleted
    /// upon creating the new version
    #[serde(rename = "deleteOldVersions")]
    delete_old_versions: Option<bool>,
}

impl DatasetNewVersionRequest {
    pub fn new(version_notes: String) -> DatasetNewVersionRequest {
        DatasetNewVersionRequest {
            version_notes,
            subtitle: None,
            description: None,
            files: Default::default(),
            convert_to_csv: None,
            category_ids: None,
            delete_old_versions: None,
        }
    }

    pub fn set_version_notes(&mut self, version_notes: String) {
        self.version_notes = version_notes;
    }

    pub fn with_version_notes(mut self, version_notes: String) -> DatasetNewVersionRequest {
        self.version_notes = version_notes;
        self
    }

    pub fn version_notes(&self) -> &String {
        &self.version_notes
    }

    pub fn set_subtitle(&mut self, subtitle: String) {
        self.subtitle = Some(subtitle);
    }

    pub fn with_subtitle(mut self, subtitle: String) -> DatasetNewVersionRequest {
        self.subtitle = Some(subtitle);
        self
    }

    pub fn subtitle(&self) -> Option<&String> {
        self.subtitle.as_ref()
    }

    pub fn reset_subtitle(&mut self) {
        self.subtitle = None;
    }

    pub fn set_description(&mut self, description: String) {
        self.description = Some(description);
    }

    pub fn with_description(mut self, description: String) -> DatasetNewVersionRequest {
        self.description = Some(description);
        self
    }

    pub fn description(&self) -> Option<&String> {
        self.description.as_ref()
    }

    pub fn reset_description(&mut self) {
        self.description = None;
    }

    pub fn set_files(&mut self, files: Vec<DatasetUploadFile>) {
        self.files = files;
    }

    pub fn with_files(mut self, files: Vec<DatasetUploadFile>) -> DatasetNewVersionRequest {
        self.files = files;
        self
    }

    pub fn files(&self) -> &Vec<DatasetUploadFile> {
        &self.files
    }

    pub fn set_convert_to_csv(&mut self, convert_to_csv: bool) {
        self.convert_to_csv = Some(convert_to_csv);
    }

    pub fn with_convert_to_csv(mut self, convert_to_csv: bool) -> DatasetNewVersionRequest {
        self.convert_to_csv = Some(convert_to_csv);
        self
    }

    pub fn convert_to_csv(&self) -> Option<&bool> {
        self.convert_to_csv.as_ref()
    }

    pub fn reset_convert_to_csv(&mut self) {
        self.convert_to_csv = None;
    }

    pub fn set_category_ids(&mut self, category_ids: Vec<String>) {
        self.category_ids = Some(category_ids);
    }

    pub fn with_category_ids(mut self, category_ids: Vec<String>) -> DatasetNewVersionRequest {
        self.category_ids = Some(category_ids);
        self
    }

    pub fn category_ids(&self) -> Option<&Vec<String>> {
        self.category_ids.as_ref()
    }

    pub fn reset_category_ids(&mut self) {
        self.category_ids = None;
    }

    pub fn set_delete_old_versions(&mut self, delete_old_versions: bool) {
        self.delete_old_versions = Some(delete_old_versions);
    }

    pub fn with_delete_old_versions(
        mut self,
        delete_old_versions: bool,
    ) -> DatasetNewVersionRequest {
        self.delete_old_versions = Some(delete_old_versions);
        self
    }

    pub fn delete_old_versions(&self) -> Option<&bool> {
        self.delete_old_versions.as_ref()
    }

    pub fn reset_delete_old_versions(&mut self) {
        self.delete_old_versions = None;
    }
}