hlx 1.2.5

Configuration language designed specifically for ml/ai/data systems
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


use clap::{Args, Subcommand, ValueEnum};
use std::path::PathBuf;

#[derive(Args, Debug)]
pub struct MaintenanceArgs {
    #[command(subcommand)]
    pub command: MaintenanceCommand,
}

#[derive(Subcommand, Debug)]
pub enum MaintenanceCommand {
    /// Publish the package to a registry
    Publish(PublishArgs),
    /// Sign the package or artifact
    Sign(SignArgs),
    /// Export the package in a specific format
    Export(ExportArgs),
    /// Import a package from a registry
    Import(ImportArgs),
}

#[derive(Args, Debug)]
pub struct PublishArgs {
    #[arg(short, long)]
    pub registry: Option<String>,
    #[arg(short, long)]
    pub token: Option<String>,
    #[arg(long)]
    pub dry_run: bool,
}

#[derive(Args, Debug)]
pub struct SignArgs {
    pub input: PathBuf,
    #[arg(short, long)]
    pub key: Option<String>,
    #[arg(short, long)]
    pub output: Option<PathBuf>,
    #[arg(long)]
    pub verify: bool,
}

#[derive(ValueEnum, Clone, Debug)]
pub enum ExportFormat {
    Json,
    Yaml,
    Toml,
}

#[derive(Args, Debug)]
pub struct ExportArgs {
    #[arg(value_enum)]
    pub format: ExportFormat,
    #[arg(short, long)]
    pub output: Option<PathBuf>,
    #[arg(long)]
    pub include_deps: bool,
}

#[derive(Args, Debug)]
pub struct ImportArgs {
    #[arg(short, long)]
    pub input: PathBuf,
    #[arg(short, long)]
    pub registry: Option<String>,
    #[arg(short, long)]
    pub token: Option<String>,
}

pub async fn run(args: MaintenanceArgs) -> anyhow::Result<()> {
    match args.command {
        MaintenanceCommand::Publish(ref publish_args) => {
            println!("Publish: registry={:?}, token={:?}, dry_run={}",
                     publish_args.registry, publish_args.token, publish_args.dry_run);
            Ok(())
        }
        MaintenanceCommand::Sign(ref sign_args) => {
            println!("Sign: input={}, key={:?}, output={:?}, verify={}",
                     sign_args.input.display(),
                     sign_args.key,
                     sign_args.output,
                     sign_args.verify);
            Ok(())
        }
        MaintenanceCommand::Export(ref export_args) => {
            println!("Export: format={:?}, output={:?}, include_deps={}",
                     export_args.format, export_args.output, export_args.include_deps);
            Ok(())
        }
        MaintenanceCommand::Import(ref import_args) => {
            println!("Import: input={}, registry={:?}, token={:?}",
                     import_args.input.display(), import_args.registry, import_args.token);
            Ok(())
        }
    }
}