#![allow(clippy::field_reassign_with_default)]
use std::path::PathBuf;
use openreadout_core::{Error, Registry, Result};
use serde::{Deserialize, Serialize};
use crate::link::Confidence;
use crate::measures::{MeasureSpec, build};
use crate::run::{BatchRequest, IndexQuery};
use crate::summarize::{Filter, SummarizeRequest, TestKind};
use crate::write::{TableMeta, read_table, save};
use crate::{BatchOutput, LinkOptions, LinkOutput, Pipeline, run_pipeline};
pub const DEFAULT_BATCH_ROWS: u64 = 20;
pub const MAX_BATCH_ROWS: u64 = 500;
#[derive(Debug, Default, Deserialize, schemars::JsonSchema)]
pub struct BatchToolArgs {
#[schemars(with = "MeasureName")]
pub measure: String,
#[serde(default)]
pub inputs: Vec<String>,
#[serde(default)]
pub recursive: bool,
pub from_index: Option<String>,
pub query: Option<String>,
#[serde(default)]
pub formats: Vec<String>,
#[serde(default)]
pub sample_sheets: Vec<String>,
pub worksheet: Option<String>,
#[serde(default)]
pub keys: Vec<String>,
#[serde(default, rename = "where")]
pub filters: Vec<String>,
#[serde(default)]
pub fields: Vec<String>,
#[serde(default)]
pub by: Vec<String>,
#[serde(default)]
pub values: Vec<String>,
pub replicate: Option<String>,
#[serde(default)]
pub exact_by: bool,
pub test: Option<String>,
pub control: Option<String>,
pub output: Option<String>,
#[serde(default)]
pub overwrite: bool,
pub limit: Option<u64>,
#[serde(default)]
pub offset: u64,
pub image: Option<u32>,
#[serde(default)]
pub level: u32,
#[serde(default)]
pub wells: Vec<String>,
#[serde(default)]
pub select: Vec<String>,
pub per: Option<String>,
pub mip: Option<String>,
pub trace: Option<u32>,
pub sweep: Option<u32>,
#[serde(default)]
pub channels: Vec<u32>,
pub table: Option<u32>,
#[serde(default)]
pub parameters: Vec<String>,
pub compensate: Option<String>,
pub transform: Option<String>,
pub workspace: Option<String>,
pub gatingml: Option<String>,
pub sample: Option<String>,
#[serde(default)]
pub populations: Vec<String>,
#[serde(default)]
pub medians: Vec<String>,
#[serde(default)]
pub options: serde_json::Map<String, serde_json::Value>,
}
#[derive(Debug, Clone, Copy, schemars::JsonSchema)]
#[serde(rename_all = "kebab-case")]
pub enum MeasureName {
Stats,
Trace,
Table,
Info,
Scans,
Peaks,
Chromatogram,
Assay,
NmrPeaks,
EphysFeatures,
Spikes,
Qpcr,
Gate,
}
pub fn run_batch(reg: &Registry, a: BatchToolArgs, paged: bool) -> Result<BatchOutput> {
let gating = a.workspace.clone().or_else(|| a.gatingml.clone());
let spec = {
let mut s = MeasureSpec::default();
s.measure = a.measure.clone();
s.image = a.image;
s.level = a.level;
s.wells = a.wells.clone();
s.select = a.select.clone();
s.per = a.per.clone();
s.mip = a.mip.clone();
s.trace = a.trace;
s.sweep = a.sweep;
s.channels = a.channels.clone();
s.table = a.table;
s.parameters = a.parameters.clone();
s.compensate = a.compensate.clone();
s.transform = a.transform.clone();
s.gating_file = gating.as_ref().map(PathBuf::from);
s.sample = a.sample.clone();
s.populations = a.populations.clone();
s.medians = a.medians.clone();
s.fields = a.fields.clone();
s.options = a.options.clone();
s
};
let measure = build(&spec)?;
let mut req = BatchRequest::default();
req.inputs = a.inputs.iter().map(PathBuf::from).collect();
if let Some(g) = &gating {
req.exclude.push(PathBuf::from(g));
}
req.recursive = a.recursive;
req.formats = a.formats.clone();
if let Some(ix) = &a.from_index {
req.index = Some(IndexQuery {
index_dir: PathBuf::from(ix),
query: a.query.clone().unwrap_or_default(),
});
}
let mut p = Pipeline::default();
p.request = req;
p.sample_sheets = a.sample_sheets.iter().map(PathBuf::from).collect();
p.worksheet = a.worksheet.clone();
p.keys = a.keys.clone();
p.filters = a
.filters
.iter()
.map(|f| Filter::parse(f))
.collect::<Result<_>>()?;
p.fields = a.fields.clone();
p.output = a.output.as_ref().map(PathBuf::from);
p.overwrite = a.overwrite;
if !a.by.is_empty() {
let mut s = SummarizeRequest::default();
s.by = a.by.clone();
s.values = a.values.clone();
s.replicate = a.replicate.clone();
s.control = a.control.clone();
s.exact_by = a.exact_by;
s.test = test_kind(a.test.as_deref())?;
p.summarize = Some(s);
}
let r = run_pipeline(reg, measure.as_ref(), &p, None, None)?;
let limit = if paged {
Some(
a.limit
.unwrap_or(if r.written.is_some() {
0
} else {
DEFAULT_BATCH_ROWS
})
.min(MAX_BATCH_ROWS),
)
} else {
a.limit
};
let mut out = r.output(a.offset, limit);
if paged && out.truncated && out.output.is_none() {
out.warnings.push(format!(
"{} of {} rows returned: page with offset, or pass output=\"table.csv\" (or .parquet) to write them all",
out.returned_rows, out.total_rows
));
}
Ok(out)
}
fn test_kind(t: Option<&str>) -> Result<Option<TestKind>> {
t.map(|x| {
TestKind::parse(x)
.ok_or_else(|| Error::Usage(format!("test `{x}`: use welch or mann-whitney")))
})
.transpose()
}
#[derive(Debug, Default, Deserialize, schemars::JsonSchema)]
pub struct SummarizeToolArgs {
pub table: String,
pub by: Vec<String>,
#[serde(default)]
pub values: Vec<String>,
pub replicate: Option<String>,
pub test: Option<String>,
pub control: Option<String>,
#[serde(default, rename = "where")]
pub filters: Vec<String>,
#[serde(default)]
pub exact_by: bool,
pub output: Option<String>,
#[serde(default)]
pub overwrite: bool,
}
#[derive(Debug, Serialize, schemars::JsonSchema)]
pub struct SummarizeToolOutput {
pub input: String,
pub summary: crate::SummaryOutput,
#[serde(skip_serializing_if = "Option::is_none")]
pub output: Option<crate::write::WrittenFile>,
}
pub fn run_summarize(a: SummarizeToolArgs) -> Result<SummarizeToolOutput> {
let (t, measure) = read_table(std::path::Path::new(&a.table))?;
let mut s = SummarizeRequest::default();
s.by = a.by.clone();
s.values = a.values.clone();
s.replicate = a.replicate.clone();
s.control = a.control.clone();
s.exact_by = a.exact_by;
s.test = test_kind(a.test.as_deref())?;
s.filters = a
.filters
.iter()
.map(|f| Filter::parse(f))
.collect::<Result<_>>()?;
let summary = crate::summarize(&t, measure.as_deref().unwrap_or(""), &s)?;
let output = match &a.output {
Some(o) => Some(save(
&summary.table,
std::path::Path::new(o),
None,
&TableMeta {
measure: measure.unwrap_or_default(),
grain: summary.group_by.clone(),
},
a.overwrite,
)?),
None => None,
};
Ok(SummarizeToolOutput {
input: a.table,
summary,
output,
})
}
#[derive(Debug, Default, Deserialize, schemars::JsonSchema)]
pub struct LinkToolArgs {
#[serde(default)]
pub paths: Vec<String>,
#[serde(default)]
pub no_recursive: bool,
pub min_confidence: Option<String>,
#[serde(default)]
pub formats: Vec<String>,
pub from_index: Option<String>,
pub query: Option<String>,
}
pub fn run_link(reg: &Registry, a: LinkToolArgs) -> Result<LinkOutput> {
let mut o = LinkOptions::default();
o.request.inputs = a.paths.iter().map(PathBuf::from).collect();
o.request.recursive = !a.no_recursive;
o.request.formats = a.formats;
if let Some(ix) = a.from_index {
o.request.index = Some(IndexQuery {
index_dir: PathBuf::from(ix),
query: a.query.unwrap_or_default(),
});
}
if let Some(c) = a.min_confidence.as_deref() {
o.min_confidence = Confidence::parse(c)
.ok_or_else(|| Error::Usage(format!("min_confidence `{c}`: low, medium or high")))?;
}
crate::link(reg, &o)
}