oxen-cli 0.50.6

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

pub mod add;
pub use add::WorkspaceAddCmd;

pub mod clear;
pub use clear::WorkspaceClearCmd;

pub mod create;
pub use create::WorkspaceCreateCmd;

pub mod commit;
pub use commit::WorkspaceCommitCmd;

pub mod diff;
pub use diff::WorkspaceDiffCmd;

pub mod df;
pub use df::WorkspaceDfCmd;

pub mod delete;
pub use delete::WorkspaceDeleteCmd;

pub mod download;
pub use download::WorkspaceDownloadCmd;

pub mod list;
pub use list::WorkspaceListCmd;

pub mod restore;
pub use restore::WorkspaceRestoreCmd;

pub mod rm;
pub use rm::WorkspaceRmCmd;

pub mod status;
pub use status::WorkspaceStatusCmd;

use async_trait::async_trait;
use clap::Command;

use std::collections::HashMap;

use crate::{
    cli_error::UnknownSubcommand,
    cmd::{RunCmd, Runners},
};
pub const NAME: &str = "workspace";
pub struct WorkspaceCmd;

#[async_trait]
impl RunCmd for WorkspaceCmd {
    fn name(&self) -> &str {
        NAME
    }

    fn args(&self) -> Command {
        // Setups the CLI args for the command
        let mut command = Command::new(NAME)
            .about("Manage workspaces")
            .subcommand_required(true)
            .arg_required_else_help(true);

        // These are all the subcommands for the schemas command
        // including `create`, `add`, `rm`, `commit`, and `status`
        let sub_commands = Self::get_subcommands();
        for cmd in sub_commands.values() {
            command = command.subcommand(cmd.args());
        }
        command
    }

    async fn run(&self, args: &clap::ArgMatches) -> Result<(), anyhow::Error> {
        let sub_commands = Self::get_subcommands();
        if let Some((name, sub_matches)) = args.subcommand() {
            let Some(cmd) = sub_commands.get(name) else {
                return Err(UnknownSubcommand {
                    parent: "workspace",
                    name: name.to_string(),
                })?;
            };

            // Calling await within an await is making it complain?
            tokio::task::block_in_place(|| {
                tokio::runtime::Handle::current().block_on(cmd.run(sub_matches))
            })?;
        }
        Ok(())
    }
}

impl WorkspaceCmd {
    fn get_subcommands() -> Runners {
        let commands: [Box<dyn RunCmd>; 12] = [
            Box::new(WorkspaceAddCmd),
            Box::new(WorkspaceClearCmd),
            Box::new(WorkspaceCommitCmd),
            Box::new(WorkspaceCreateCmd),
            Box::new(WorkspaceDfCmd),
            Box::new(WorkspaceDiffCmd),
            Box::new(WorkspaceDeleteCmd),
            Box::new(WorkspaceListCmd),
            Box::new(WorkspaceRmCmd),
            Box::new(WorkspaceRestoreCmd),
            Box::new(WorkspaceStatusCmd),
            Box::new(WorkspaceDownloadCmd),
        ];
        let mut runners = HashMap::new();
        for cmd in commands {
            runners.insert(cmd.name().to_string(), cmd);
        }
        runners
    }

    pub async fn run_subcommands(
        name: &str,
        sub_matches: &clap::ArgMatches,
    ) -> Result<(), anyhow::Error> {
        let sub_commands = Self::get_subcommands();
        let Some(cmd) = sub_commands.get(name) else {
            return Err(UnknownSubcommand {
                parent: "workspace",
                name: name.to_string(),
            })?;
        };

        tokio::task::block_in_place(|| {
            tokio::runtime::Handle::current().block_on(cmd.run(sub_matches))
        })?;

        Ok(())
    }
}