Initial commit

Author: bytesnake

.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

Cargo.toml

@@ -0,0 +1,2 @@
+[workspace]
+members = ["tsap", "tsap_macro", "tests"]

tests/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "tsap_tests"
+version = "0.0.0"
+authors = ["Lorenz Schmidt <[email protected]>"]
+edition = "2021"
+publish = false
+
+[dependencies]
+tsap = { path = "../tsap" }
+
+[dev-dependencies]
+macrotest = "=1.0.9"
+trybuild = "1.0"

tests/tests/expandtest.rs

@@ -0,0 +1,4 @@
+#[test]
+pub fn expandtest() {
+    macrotest::expand("tests/expand/*.rs");
+}

tests/tests/uitest.rs

@@ -0,0 +1,5 @@
+#[test]
+fn ui() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/*.rs");
+}

tsap/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "tsap"
+version = "0.1.0"
+edition = "2018"
+
+[[bin]]
+name = "example"
+path = "src/example.rs"
+
+[dependencies]
+thiserror = "1.0"
+tsap_macro = { version = "0.1.0", path = "../tsap_macro" }
+toml = { version = "0.5", optional = true }
+serde = { version = "1.0", optional = true, features = ["derive"] }
+glob = "0.3"
+
+[features]
+default = ["toml"]
+toml = ["dep:serde", "dep:toml"]

tsap/src/error.rs

@@ -0,0 +1,26 @@
+use thiserror::Error;
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[cfg(feature = "toml")]
+    #[error("could not parse configuration")]
+    TomlParse(#[from] toml::de::Error),
+    #[cfg(feature = "toml")]
+    #[error("invalid key path")]
+    InvalidPath(String),
+    #[error("invalid argument")]
+    InvalidArg(String),
+    #[error("merging dictionaries failed")]
+    MergeFailed,
+    #[error("key {0} does not exist in {1}")]
+    KeyNotExists(String, String),
+    #[error("parameter violates constrain: {0}")]
+    InvalidParam(String),
+    #[error("input/output error")]
+    Io {
+        #[from]
+        source: std::io::Error,
+    },
+}

tsap/src/example.rs

@@ -0,0 +1,187 @@
+#![feature(try_trait_v2)]
+
+use tsap::{param, ParamGuard, Call};
+
+/*
+#[param]
+#[derive(Debug)]
+pub struct SVClassifier {
+    nu: f32
+}
+
+impl ParamGuard for SVClassifier {
+    type Error = tsap::Error;
+
+    fn check(&self) -> Result<(), Self::Error> {
+        if self.nu < 0.0 {
+            return Err(tsap::Error::InvalidParam(
+                format!("SV classifier regularization should be positive, but {}", self.nu)
+            ));
+        }
+
+        Ok(())
+    }
+}
+
+impl Default for SVClassifier {
+    fn default() -> Self {
+        SVClassifier {
+            nu: 100.0,
+        }
+    }
+}
+
+#[param]
+#[derive(Debug)]
+pub enum ModelParam {
+    RandomForest {
+        ntrees: usize
+    },
+    SVClassifier(SVClassifier),
+}
+
+impl From<SVClassifier> for Call<ModelParam> {
+    fn from(val: SVClassifier) -> Self {
+        Call::from(ModelParam::SVClassifier(val))
+    }
+}
+
+impl ParamGuard for ModelParam {
+    type Error = tsap::Error;
+}
+*/
+
+//#[param]
+//pub enum Param<const C: bool> {
+//    Blub(Param2<C, C>, u32),
+//    Bla
+//}
+//#[param]
+//#[derive(Debug)]
+//pub struct SVClassifier<const C: bool> {
+//    nu: f32
+//}
+//
+//impl<const C: bool> ParamGuard for SVClassifier<C> {
+//    type Error = tsap::Error;
+//
+//    fn check(&self) -> Result<(), Self::Error> {
+//        Ok(())
+//    }
+//}
+//
+//impl Default for SVClassifier<true> {
+//    fn default() -> Self {
+//        SVClassifier {
+//            nu: 0.1
+//        }
+//    }
+//}
+//
+//#[param]
+//#[derive(Debug)]
+//pub enum Model<const C: bool> {
+//    SVClassifier(SVClassifier<C>),
+//}
+//
+//impl Default for Model<true> {
+//    fn default() -> Self {
+//        Model::SVClassifier(SVClassifier::default())
+//    }
+//}
+//
+//impl<const C: bool> ParamGuard for Model<C> {
+//    type Error = tsap::Error;
+//
+//    fn check(&self) -> Result<(), Self::Error> {
+//        Ok(())
+//    }
+//}
+
+#[param]
+#[derive(Debug)]
+pub struct Param<const C: bool, T: Default> {
+    seed: T,
+    //model: Model<C>,
+    //rev: String,
+    //date: String,
+
+    //model: ModelParam,
+}
+
+impl<T: Default> Default for Param<true, T> {
+    fn default() -> Self {
+        Param {
+            seed: T::default()
+            //rev: "Blub".into(),
+            //date: "null".into(),
+            //model: ModelParam::RandomForest { ntrees: 10 }
+        }
+    }
+}
+
+impl<const C: bool, T: Default> ParamGuard for Param<C, T> {
+    type Error = tsap::Error;
+
+    fn check(&self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+fn main() -> Result<(), tsap::Error> {
+    let param = Param::default()
+        .seed(|x| x+1)?;
+
+    Ok(())
+}
+
+/*
+
+
+
+fn main() -> Result<(), tsap::Error> {
+    let p = Param::default()
+        .seed(100)
+        .build()?
+        .seed(|x| x+1)
+        //.try_seed(|x| Ok(x + 1000))
+        .model(|x| x.svclassifier(|x| x.nu(10.0)))
+        // do we really need a Box<TryInto<SVClassifierParam>> here? Distinction between Param and
+        // ParamBuilder not easy to make, but how plays this together with trait bound on return
+        // value
+        //.try_model(|x| x.try_svclassifier(|x| x.nu(10.0)))
+        //.model(|obj| obj.nu(1000.0).build()?)
+        //.model(ModelParam::SVClassifier { nu: 100.0 })
+        .build()?;
+
+    Ok(())
+}*/
+
+/*fn main() -> Result<(), tsap::Error> {
+    let p = Param::from(toml::toml!(
+        rev = { cmd = "git rev-parse --short HEAD" }
+        date = { cmd = "date '+%d-%m-%Y %H:%M:%S'" }
+        seed = 100
+
+        [model]
+        from_file = { base_path = "config/models/", default = "randomforest" }
+    ));
+
+    dbg!(&p.0.root);
+
+    let p = Param::from_file("config/main.toml")?
+        .seed(50)
+        .seed(|x| x+3)
+        .seed(|x| x+3)
+        .amend_file("config/main.toml")?;
+
+    dbg!(&p.get_seed());
+
+    let p: Param = p.try_into()?;
+
+    dbg!(&p);
+
+    Ok(())
+}*/
+
+//https://ferrous-systems.com/blog/testing-proc-macros/
+//https://github.com/ferrous-systems/testing-proc-macros/blob/main/src/lib.rs

tsap/src/lib.rs

@@ -0,0 +1,80 @@
+extern crate tsap_macro;
+
+pub use tsap_macro::param;
+
+#[cfg(feature = "toml")]
+pub mod toml_builder;
+#[cfg(feature = "toml")]
+pub mod templates;
+
+mod error;
+
+pub use error::{Result, Error};
+pub use toml_builder::TomlBuilder;
+
+pub trait ParamGuard {
+    type Error;
+
+    fn check(&self) -> std::result::Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+/// Caller semantic to accept owned values and closures in builder pattern
+pub struct Call<T>(Box<dyn FnOnce(T) -> T>);
+
+impl<T> Call<T> {
+    pub fn call(self, val: T) -> T {
+        self.0(val)
+    }
+}
+
+//impl<T: 'static> From<T> for Call<T> {
+//    fn from(val: T) -> Call<T> {
+//        Call(Box::new(move |_| val))
+//    }
+//}
+
+impl<F: 'static, T> From<F> for Call<T> where F: FnOnce(T) -> T {
+    fn from(val: F) -> Call<T> {
+        Call(Box::new(val))
+    }
+}
+//impl<F: 'static> From<F> for Call<usize> where F: FnOnce(usize) -> usize {
+//    fn from(val: F) -> Call<usize> {
+//        Call(Box::new(val))
+//    }
+//}
+//
+//impl<F: 'static> From<F> for Call<f64> where F: FnOnce(f64) -> f64 {
+//    fn from(val: F) -> Call<f64> {
+//        Call(Box::new(val))
+//    }
+//}
+
+/// Caller semantic to accept owned values and closures in builder pattern
+pub struct TryCall<T>(Box<dyn FnOnce(T) -> Result<T>>);
+
+impl<T> TryCall<T> {
+    pub fn call(self, val: T) -> Result<T> {
+        self.0(val)
+    }
+}
+
+impl<T: 'static> From<Result<T>> for TryCall<T> {
+    fn from(val: Result<T>) -> TryCall<T> {
+        TryCall(Box::new(move |_| val))
+    }
+}
+
+impl<F: 'static> From<F> for TryCall<usize> where F: FnOnce(usize) -> Result<usize> {
+    fn from(val: F) -> TryCall<usize> {
+        TryCall(Box::new(val))
+    }
+}
+
+impl<F: 'static> From<F> for TryCall<f64> where F: FnOnce(f64) -> Result<f64> {
+    fn from(val: F) -> TryCall<f64> {
+        TryCall(Box::new(val))
+    }
+}