oxen-cli 0.50.4

Oxen is a fast, unstructured data version control, to help version large machine learning datasets written in Rust.
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

use async_trait::async_trait;
use clap::{Arg, ArgMatches, Command};

use liboxen::api;
use liboxen::constants::DEFAULT_HOST;
use liboxen::constants::DEFAULT_REMOTE_NAME;
use liboxen::constants::DEFAULT_SCHEME;
use liboxen::opts::UploadOpts;
use liboxen::repositories;

use std::path::PathBuf;

use crate::helpers::check_remote_version_blocking;

use crate::cmd::RunCmd;
pub const NAME: &str = "upload";
pub struct UploadCmd;

#[async_trait]
impl RunCmd for UploadCmd {
    fn name(&self) -> &str {
        NAME
    }
    fn args(&self) -> Command {
        Command::new(NAME)
        .about("Upload a specific file to the remote repository.")
        .arg(
            Arg::new("paths")
                .required(true)
                .action(clap::ArgAction::Append),
        )
        .arg(
            Arg::new("dst")
                .long("destination")
                .short('d')
                .help("The destination directory to upload the data to. Defaults to the root './' of the repository.")
                .action(clap::ArgAction::Set),
        )
        .arg(
            Arg::new("branch")
                .long("branch")
                .short('b')
                .help("The branch to upload the data to. Defaults to main branch.")
                .action(clap::ArgAction::Set),
        )
        .arg(
            Arg::new("message")
                .help("The message for the commit. Should be descriptive about what changed.")
                .long("message")
                .short('m')
                .required(true)
                .action(clap::ArgAction::Set),
        )
        .arg(
            Arg::new("host")
                .long("host")
                .help("Host to upload the data to, for example: 'hub.oxen.ai'")
                .action(clap::ArgAction::Set),
        )
        .arg(
            Arg::new("scheme")
                .long("scheme")
                .help("Scheme for the host to upload the data to, for example: 'https'")
                .action(clap::ArgAction::Set),
        )
        .arg(
            Arg::new("remote")
                .long("remote")
                .help("Remote to upload the data to, for example: 'origin'")
                .action(clap::ArgAction::Set),
        )
    }

    async fn run(&self, args: &ArgMatches) -> Result<(), anyhow::Error> {
        let opts = UploadOpts {
            paths: args
                .get_many::<String>("paths")
                .expect("Must supply paths")
                .map(PathBuf::from)
                .collect(),
            dst: args
                .get_one::<String>("dst")
                .map(PathBuf::from)
                .unwrap_or(PathBuf::from(".")),
            message: args
                .get_one::<String>("message")
                .map(String::from)
                .expect("Must supply a commit message"),
            branch: args.get_one::<String>("branch").map(String::from),
            remote: args
                .get_one::<String>("remote")
                .map(String::from)
                .unwrap_or(DEFAULT_REMOTE_NAME.to_string()),
            host: args
                .get_one::<String>("host")
                .map(String::from)
                .unwrap_or(DEFAULT_HOST.to_string()),
            scheme: args
                .get_one::<String>("scheme")
                .map(String::from)
                .unwrap_or(DEFAULT_SCHEME.to_string()),
        };

        // `oxen upload $namespace/$repo_name $path`
        let paths = &opts.paths;
        if paths.len() < 2 {
            return Err(anyhow::anyhow!(
                "Must supply repository and a file to upload.",
            ));
        }

        check_remote_version_blocking(&opts.scheme, opts.clone().host).await?;

        // Check if the first path is a valid remote repo
        let name = paths[0].to_string_lossy();

        let remote_repo = api::client::repositories::get_by_name_host_and_remote(
            &name,
            &opts.host,
            &opts.scheme,
            &opts.remote,
        )
        .await?;

        // Remove the repo name from the list of paths
        let remote_paths = paths[1..].to_vec();
        let opts = UploadOpts {
            paths: remote_paths,
            ..opts
        };

        repositories::workspaces::upload(&remote_repo, &opts).await?;
        Ok(())
    }
}