encoderfile 0.6.2

Distribute and run transformer encoders with a single file.
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

use crate::builder::{base_binary::TargetSpec, terminal};

use super::GlobalArguments;
use anyhow::{Context, Result};
use std::path::PathBuf;

use clap_derive::Args;

#[derive(Debug, Args)]
pub struct BuildArgs {
    #[arg(short = 'f', help = "Path to config file. Required.")]
    pub config: PathBuf,
    #[arg(
        short = 'o',
        long = "output-path",
        help = "Output path, e.g., `./my_model.encoderfile`. Optional"
    )]
    pub output_path: Option<PathBuf>,
    #[arg(
        long = "base-binary-path",
        help = "Path to base binary to use. Optional."
    )]
    pub base_binary_path: Option<PathBuf>,
    #[arg(
        long = "platform",
        help = "Target platform to build. Follows standard rust target triple format."
    )]
    pub platform: Option<TargetSpec>,
    #[arg(
        long,
        help = "Encoderfile version override (defaults to current version)."
    )]
    pub version: Option<String>,
    #[arg(
        long = "no-download",
        help = "Disable downloading",
        default_value = "false"
    )]
    pub no_download: bool,
    #[arg(
        long = "directory", // working-dir???
        help = "Set the working directory for the build process. Optional.",
        default_value = None
    )]
    pub working_dir: Option<PathBuf>,
}

impl BuildArgs {
    pub fn run(&self, global: &GlobalArguments) -> Result<()> {
        terminal::info("Loading config...");
        let mut config = crate::builder::config::BuildConfig::load(&self.config)?;

        // change working dir if specified
        if let Some(working_dir) = &self.working_dir {
            std::env::set_current_dir(working_dir).context(format!(
                "Failed to change working directory to {:?}",
                working_dir.as_path()
            ))?;
        }

        // --- handle user flags ---------------------------------------------------
        if let Some(o) = &self.output_path {
            config.encoderfile.output_path = Some(o.to_path_buf());
        }

        if let Some(cache_dir) = &global.cache_dir {
            config.encoderfile.cache_dir = Some(cache_dir.to_path_buf());
        }

        if let Some(base_binary_path) = &self.base_binary_path {
            config.encoderfile.base_binary_path = Some(base_binary_path.to_path_buf());
        }

        if let Some(platform) = &self.platform {
            config.encoderfile.target = Some(platform.clone());
        }

        super::super::builder::EncoderfileBuilder::new(config)
            .build(&self.version, self.no_download)
    }
}

#[cfg(feature = "dev-utils")]
pub fn test_build_args(
    config: impl Into<PathBuf>,
    base_binary_path: impl Into<PathBuf>,
) -> BuildArgs {
    BuildArgs {
        config: config.into(),
        output_path: None,
        base_binary_path: Some(base_binary_path.into()),
        platform: None,
        version: None,
        no_download: true,
        working_dir: None,
    }
}

#[cfg(feature = "dev-utils")]
pub fn test_build_args_working_dir(
    config: impl Into<PathBuf>,
    base_binary_path: impl Into<PathBuf>,
    working_dir: impl Into<PathBuf>,
) -> BuildArgs {
    BuildArgs {
        config: config.into(),
        output_path: None,
        base_binary_path: Some(base_binary_path.into()),
        platform: None,
        version: None,
        no_download: true,
        working_dir: Some(working_dir.into()),
    }
}