use std::path::{Path, PathBuf};
use openreadout_core::parallel::ReadContext;
use openreadout_core::{Dataset, Error, Registry, Result};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, schemars::JsonSchema)]
#[serde(rename_all = "kebab-case")]
pub enum AnalyzeKind {
Peaks,
Chromatogram,
NmrPeaks,
EphysFeatures,
Spikes,
Qpcr,
Assay,
Gate,
}
impl AnalyzeKind {
pub fn name(self) -> &'static str {
match self {
Self::Peaks => "peaks",
Self::Chromatogram => "chromatogram",
Self::NmrPeaks => "nmr-peaks",
Self::EphysFeatures => "ephys-features",
Self::Spikes => "spikes",
Self::Qpcr => "qpcr",
Self::Assay => "assay",
Self::Gate => "gate",
}
}
pub const ALL: [AnalyzeKind; 8] = [
Self::Peaks,
Self::Chromatogram,
Self::NmrPeaks,
Self::EphysFeatures,
Self::Spikes,
Self::Qpcr,
Self::Assay,
Self::Gate,
];
pub fn parse(name: &str) -> Result<Self> {
Self::ALL
.into_iter()
.find(|k| k.name() == name)
.ok_or_else(|| {
let names: Vec<&str> = Self::ALL.iter().map(|k| k.name()).collect();
Error::Usage(format!(
"unknown analysis kind {name:?}: one of {}",
names.join(", ")
))
})
}
pub fn reads_dataset(self) -> bool {
!matches!(self, Self::Qpcr | Self::Assay | Self::Gate)
}
}
#[derive(Debug, Deserialize, schemars::JsonSchema)]
pub struct QpcrOptions {
#[serde(flatten)]
pub query: crate::measures::QpcrQuery,
pub max_records: Option<usize>,
}
#[derive(Debug, Deserialize, schemars::JsonSchema)]
pub struct AssayOptions {
#[serde(default)]
pub plot: bool,
#[serde(flatten)]
pub request: openreadout_assay::AssayRequest,
}
#[derive(Debug, Default, Deserialize, schemars::JsonSchema)]
pub struct GateOptions {
pub workspace: Option<String>,
pub gatingml: Option<String>,
pub sample: Option<String>,
#[serde(default)]
pub populations: Vec<String>,
#[serde(default)]
pub table: u32,
#[serde(default)]
pub medians: Vec<String>,
}
#[derive(schemars::JsonSchema)]
#[serde(untagged)]
#[allow(dead_code)]
enum AnalyzeOptions {
Peaks(openreadout_quant::api::PeaksQuery),
Chromatogram(openreadout_quant::api::ChromatogramQuery),
NmrPeaks(openreadout_signal::api::NmrQuery),
EphysFeatures(openreadout_signal::api::EphysQuery),
Spikes(openreadout_signal::api::SpikesQuery),
Qpcr(QpcrOptions),
Assay(AssayOptions),
Gate(GateOptions),
}
#[derive(Debug, Deserialize, schemars::JsonSchema)]
pub struct AnalyzeArgs {
pub file: String,
pub kind: AnalyzeKind,
#[serde(default)]
#[schemars(with = "Option<AnalyzeOptions>")]
pub options: Map<String, Value>,
#[serde(default)]
pub strict: Option<bool>,
}
#[derive(Debug, Serialize, schemars::JsonSchema)]
#[serde(untagged)]
#[allow(clippy::large_enum_variant)]
pub enum AnalyzeOutput {
Peaks(openreadout_quant::analyze::PeaksOutput),
Chromatogram(openreadout_quant::extract::ChromatogramOutput),
NmrPeaks(openreadout_signal::nmr::NmrReport),
EphysFeatures(openreadout_signal::ephys::CellReport),
Spikes(openreadout_signal::ephys::SpikesReport),
Qpcr(openreadout_qpcr::QpcrReport),
Assay(openreadout_assay::AssayOutput),
Gate(openreadout_core::flow::GateOutput),
}
fn with_file<T>(
reg: &Registry,
file: &str,
f: impl FnOnce(&mut dyn Dataset, &openreadout_core::FileInfo, &ReadContext<'_>) -> Result<T>,
) -> Result<T> {
let (_, mut ds) = reg.open(Path::new(file))?;
let info = ds.info()?;
let opener = || -> Result<Box<dyn Dataset>> { reg.open(Path::new(file)).map(|(_, d)| d) };
f(
ds.as_mut(),
&info,
&ReadContext {
opener: Some(&opener),
progress: None,
},
)
}
fn parse<T: serde::de::DeserializeOwned + schemars::JsonSchema>(
kind: AnalyzeKind,
options: &Map<String, Value>,
) -> Result<T> {
crate::measures::parse_options(kind.name(), options)
}
pub fn run(reg: &Registry, a: &AnalyzeArgs) -> Result<(AnalyzeOutput, Option<Vec<u8>>)> {
let o = &a.options;
let out = match a.kind {
AnalyzeKind::Qpcr => {
let q: QpcrOptions = parse(a.kind, o)?;
AnalyzeOutput::Qpcr(qpcr(reg, &a.file, q)?)
}
AnalyzeKind::Assay => {
let mut opts = o.clone();
match opts.remove("plate_options") {
None | Some(Value::Null) => {}
Some(Value::Object(inner)) => {
for (k, v) in inner {
if opts.contains_key(&k) {
return Err(Error::Usage(format!(
"`{k}` is given twice, at the top level and in plate_options"
)));
}
opts.insert(k, v);
}
}
Some(other) => {
return Err(Error::Usage(format!(
"`plate_options` must be an object, got {other}"
)));
}
}
let plot = match opts.remove("plot") {
None => false,
Some(Value::Bool(b)) => b,
Some(other) => {
return Err(Error::Usage(format!(
"`plot` must be true or false, got {other}"
)));
}
};
let request: openreadout_assay::AssayRequest = parse(a.kind, &opts)?;
let out = openreadout_assay::analyze_file(reg, Path::new(&a.file), &request)?;
let png = if plot {
openreadout_assay::render_plot(&out)?.map(|(bytes, _)| bytes)
} else {
None
};
return Ok((AnalyzeOutput::Assay(out), png));
}
AnalyzeKind::Gate => {
let g: GateOptions = parse(a.kind, o)?;
AnalyzeOutput::Gate(gate(&a.file, g)?)
}
kind => with_file(reg, &a.file, |ds, info, ctx| {
run_dataset(kind, o, ds, info, ctx)
})?,
};
Ok((out, None))
}
pub fn run_dataset(
kind: AnalyzeKind,
o: &Map<String, Value>,
ds: &mut dyn Dataset,
info: &openreadout_core::FileInfo,
ctx: &ReadContext<'_>,
) -> Result<AnalyzeOutput> {
Ok(match kind {
AnalyzeKind::Peaks => {
let q: openreadout_quant::api::PeaksQuery = parse(kind, o)?;
AnalyzeOutput::Peaks(openreadout_quant::api::peaks(ds, info, &q, ctx)?)
}
AnalyzeKind::Chromatogram => {
let q: openreadout_quant::api::ChromatogramQuery = parse(kind, o)?;
AnalyzeOutput::Chromatogram(openreadout_quant::api::chromatogram(ds, info, &q, ctx)?)
}
AnalyzeKind::NmrPeaks => {
let q: openreadout_signal::api::NmrQuery = parse(kind, o)?;
AnalyzeOutput::NmrPeaks(openreadout_signal::nmr::analyze(ds, info, &q.request()?)?)
}
AnalyzeKind::EphysFeatures => {
let q: openreadout_signal::api::EphysQuery = parse(kind, o)?;
AnalyzeOutput::EphysFeatures(openreadout_signal::ephys::analyze_cell(
ds,
info,
&q.request()?,
)?)
}
AnalyzeKind::Spikes => {
let q: openreadout_signal::api::SpikesQuery = parse(kind, o)?;
AnalyzeOutput::Spikes(openreadout_signal::ephys::analyze_extracellular(
ds,
info,
&q.request()?,
)?)
}
AnalyzeKind::Qpcr | AnalyzeKind::Assay | AnalyzeKind::Gate => {
return Err(Error::Usage(format!(
"analysis {:?} opens its file itself: give it a path",
kind.name()
)));
}
})
}
fn qpcr(reg: &Registry, file: &str, o: QpcrOptions) -> Result<openreadout_qpcr::QpcrReport> {
let q = o.query;
let ds = openreadout_qpcr::open_qpcr(reg, Path::new(file))?;
let mut req = openreadout_qpcr::QpcrReportRequest::default();
req.well = q.well;
req.target = q.target;
req.sample = q.sample;
req.run = q.run;
req.compute_cq = q.compute_cq;
req.cq_method = q.cq_method;
req.threshold = q.threshold;
req.baseline = match (q.baseline_start, q.baseline_end) {
(Some(s), Some(e)) if s >= 1 && e > s => Some((s, e)),
(None, None) => None,
_ => {
return Err(Error::Usage(
"baseline_start and baseline_end go together, with 1 <= start < end".into(),
));
}
};
req.relative = q.ddcq;
req.reference_targets = q.reference_targets;
req.control_sample = q.control_sample;
req.standard_curve = q.standard_curve;
req.max_records = Some(o.max_records.unwrap_or(500));
req.undetermined_cq = q.undetermined_cq;
openreadout_qpcr::qpcr_report(&ds, &req)
}
fn gate(file: &str, g: GateOptions) -> Result<openreadout_core::flow::GateOutput> {
let (gating, fcs) = match g.workspace.as_ref().or(g.gatingml.as_ref()) {
Some(w) => (PathBuf::from(w), Some(PathBuf::from(file))),
None => (PathBuf::from(file), None),
};
let mut req = openreadout_fcs::analysis::GateRequest::new(gating, fcs);
req.sample = g.sample;
req.table = g.table;
req.populations = g.populations;
req.medians = g.medians;
openreadout_fcs::analysis::gate(&req)
}