Skip to content

armgit / uzu

Public Imported from GitHub
0

A high-performance inference engine for AI models

4.9 KB
Raw Blame
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)
    }
}