A high-performance inference engine for AI models
mod python;
mod rust;
mod swift;
mod swift_extensions;
mod typescript;
mod wasm;
use std::path::Path;
use anyhow::{Result, anyhow};
use colored::Colorize;
pub use python::PythonLanguageBackend;
pub use rust::RustLanguageBackend;
pub use swift::SwiftLanguageBackend;
pub use swift_extensions::generate_swift_extensions;
pub use typescript::TypeScriptLanguageBackend;
pub use wasm::WasmLanguageBackend;
use crate::{
configs::{HOST_TARGET, PlatformsConfig},
types::{Configuration, Language},
};
#[derive(Clone)]
pub struct LanguageBackendTarget {
pub name: String,
pub features: Vec<String>,
}
impl LanguageBackendTarget {
pub fn new(
name: String,
features: Vec<String>,
) -> Self {
Self {
name,
features,
}
}
}
pub trait LanguageBackend {
fn config(&self) -> PlatformsConfig;
fn language(&self) -> Language;
fn expects_prebuild_for_run(&self) -> bool {
true
}
fn default_targets(&self) -> Vec<String> {
vec![HOST_TARGET.to_string()]
}
fn install(&self) -> Result<()> {
let language = self.language();
let tools = self.config().tools_for_language(language)?;
for tool in tools {
let command = tool.command();
command.run()?;
}
Ok(())
}
fn build(
&self,
configuration: Configuration,
targets: Vec<String>,
) -> Result<()> {
let targets = self.resolve_targets("build".to_string(), configuration, targets)?;
self.build_targets(configuration, targets)?;
Ok(())
}
fn build_targets(
&self,
_configuration: Configuration,
_targets: Vec<LanguageBackendTarget>,
) -> Result<()> {
Ok(())
}
fn test(
&self,
configuration: Configuration,
target: String,
) -> Result<()> {
let targets = self.resolve_targets("test".to_string(), configuration, vec![target])?;
if targets.len() != 1 {
return Err(anyhow!("Expected 1 target for test, got {}", targets.len()));
}
let target = targets.first().cloned().ok_or(anyhow!("Target not found"))?;
self.test_target(configuration, target)?;
Ok(())
}
fn test_target(
&self,
_configuration: Configuration,
_target: LanguageBackendTarget,
) -> Result<()> {
Ok(())
}
fn example(
&self,
name: &str,
configuration: Configuration,
targets: Vec<String>,
) -> Result<()> {
let targets = self.resolve_targets("example".to_string(), configuration, targets)?;
if targets.len() != 1 {
return Err(anyhow!("Expected 1 target for example, got {}", targets.len()));
}
let target = targets.first().cloned().ok_or(anyhow!("Target not found"))?;
self.example_target(name, configuration, target)?;
Ok(())
}
fn example_target(
&self,
_name: &str,
_configuration: Configuration,
_target: LanguageBackendTarget,
) -> Result<()> {
Ok(())
}
fn release(
&self,
_version: &str,
_release_path: &Path,
) -> Result<()> {
Ok(())
}
fn resolve_targets(
&self,
name: String,
configuration: Configuration,
targets: Vec<String>,
) -> Result<Vec<LanguageBackendTarget>> {
let separator = "--------------------------------------------------".green();
let language = self.language();
let bindings = self.config().bindings_for_language(language)?;
let resolved_targets = self.config().targets_for_language(language, targets.clone())?;
if resolved_targets.is_empty() {
return Err(anyhow!("None of the provided targets are supported for language: {language:?}"));
}
println!("{separator}");
println!(
"Running {} of {} ({}) for targets: {} (resolved from: {})",
name.green(),
format!("{:?}", language).green(),
format!("{:?}", configuration).green(),
format!("{:?}", resolved_targets).green(),
format!("{:?}", targets).yellow()
);
println!("{separator}");
let targets = resolved_targets
.iter()
.map(|target| {
println!("Resolving target: {}", target.green());
let mut features = self.config().features_for_target(target.clone())?;
features.extend(bindings.iter().map(|binding| binding.feature()));
println!("Features: {}", format!("{:?}", features).green());
println!("{separator}");
Ok(LanguageBackendTarget::new(target.clone(), features.clone()))
})
.collect::<Vec<Result<LanguageBackendTarget>>>()
.into_iter()
.collect::<Result<Vec<_>>>()?;
Ok(targets)
}
}