@@ -31,9 +31,11 @@
@@ -7,15 +7,15 @@ - - + + - - + + - - - + + + diff --git a/crates/brk_interface/examples/main.rs b/crates/brk_interface/examples/main.rs new file mode 100644 index 000000000..3bf1d70d6 --- /dev/null +++ b/crates/brk_interface/examples/main.rs @@ -0,0 +1,33 @@ +use std::path::Path; + +use brk_computer::Computer; +use brk_indexer::Indexer; +use brk_interface::{Index, Interface, Params, ParamsOpt}; +use brk_vec::{Computation, Format}; + +pub fn main() -> color_eyre::Result<()> { + color_eyre::install()?; + + let outputs_dir = Path::new("../../_outputs"); + + let format = Format::Compressed; + + let indexer = Indexer::forced_import(outputs_dir)?; + + let computer = Computer::forced_import(outputs_dir, &indexer, Computation::Lazy, None, format)?; + + let interface = Interface::build(&indexer, &computer); + + dbg!(interface.search_and_format(Params { + index: Index::Height, + ids: vec!["date"].into(), + rest: ParamsOpt::default().set_from(-1), + })?); + dbg!(interface.search_and_format(Params { + index: Index::Height, + ids: vec!["date", "timestamp"].into(), + rest: ParamsOpt::default().set_from(-10).set_count(5), + })?); + + Ok(()) +} diff --git a/crates/brk_query/src/format.rs b/crates/brk_interface/src/format.rs similarity index 88% rename from crates/brk_query/src/format.rs rename to crates/brk_interface/src/format.rs index 78279d02d..6f75cb719 100644 --- a/crates/brk_query/src/format.rs +++ b/crates/brk_interface/src/format.rs @@ -1,9 +1,9 @@ -use clap_derive::ValueEnum; use color_eyre::eyre::eyre; +use rmcp::schemars::JsonSchema; use serde::Deserialize; #[allow(clippy::upper_case_acronyms)] -#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum, Deserialize)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, JsonSchema)] pub enum Format { #[serde(alias = "json")] JSON, @@ -12,7 +12,6 @@ pub enum Format { #[serde(alias = "tsv")] TSV, #[serde(alias = "md", alias = "markdown")] - #[value(alias("markdown"))] MD, } diff --git a/crates/brk_query/src/index.rs b/crates/brk_interface/src/index.rs similarity index 58% rename from crates/brk_query/src/index.rs rename to crates/brk_interface/src/index.rs index 5469a86a0..f62a0438d 100644 --- a/crates/brk_query/src/index.rs +++ b/crates/brk_interface/src/index.rs @@ -1,8 +1,16 @@ use std::fmt::{self, Debug}; +use brk_core::{ + DateIndex, DecadeIndex, DifficultyEpoch, EmptyOutputIndex, HalvingEpoch, Height, InputIndex, + MonthIndex, OpReturnIndex, OutputIndex, P2AIndex, P2MSIndex, P2PK33Index, P2PK65Index, + P2PKHIndex, P2SHIndex, P2TRIndex, P2WPKHIndex, P2WSHIndex, Printable, QuarterIndex, TxIndex, + UnknownOutputIndex, WeekIndex, YearIndex, +}; use color_eyre::eyre::eyre; +use schemars::JsonSchema; +use serde::{Deserialize, de::Error}; -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, JsonSchema)] pub enum Index { DateIndex, DecadeIndex, @@ -60,53 +68,51 @@ impl Index { ] } - pub fn possible_values(&self) -> &[&str] { - // Always have the "correct" id at the end + pub fn possible_values(&self) -> &'static [&'static str] { match self { - Self::DateIndex => &["d", "date", "dateindex"], - Self::DecadeIndex => &["decade", "decadeindex"], - Self::DifficultyEpoch => &["difficulty", "difficultyepoch"], - Self::EmptyOutputIndex => &["empty", "emptyoutputindex"], - Self::HalvingEpoch => &["halving", "halvingepoch"], - Self::Height => &["h", "height"], - Self::InputIndex => &["txin", "inputindex"], - Self::MonthIndex => &["m", "month", "monthindex"], - Self::OpReturnIndex => &["opreturn", "opreturnindex"], - Self::OutputIndex => &["txout", "outputindex"], - Self::P2AIndex => &["p2a", "p2aindex"], - Self::P2MSIndex => &["p2ms", "p2msindex"], - Self::P2PK33Index => &["p2pk33", "p2pk33index"], - Self::P2PK65Index => &["p2pk65", "p2pk65index"], - Self::P2PKHIndex => &["p2pkh", "p2pkhindex"], - Self::P2SHIndex => &["p2sh", "p2shindex"], - Self::P2TRIndex => &["p2tr", "p2trindex"], - Self::P2WPKHIndex => &["p2wpkh", "p2wpkhindex"], - Self::P2WSHIndex => &["p2wsh", "p2wshindex"], - Self::QuarterIndex => &["q", "quarter", "quarterindex"], - Self::TxIndex => &["tx", "txindex"], - Self::UnknownOutputIndex => &["unknown", "unknownoutputindex"], - Self::WeekIndex => &["w", "week", "weekindex"], - Self::YearIndex => &["y", "year", "yearindex"], + Self::DateIndex => DateIndex::to_possible_strings(), + Self::DecadeIndex => DecadeIndex::to_possible_strings(), + Self::DifficultyEpoch => DifficultyEpoch::to_possible_strings(), + Self::EmptyOutputIndex => EmptyOutputIndex::to_possible_strings(), + Self::HalvingEpoch => HalvingEpoch::to_possible_strings(), + Self::Height => Height::to_possible_strings(), + Self::InputIndex => InputIndex::to_possible_strings(), + Self::MonthIndex => MonthIndex::to_possible_strings(), + Self::OpReturnIndex => OpReturnIndex::to_possible_strings(), + Self::OutputIndex => OutputIndex::to_possible_strings(), + Self::P2AIndex => P2AIndex::to_possible_strings(), + Self::P2MSIndex => P2MSIndex::to_possible_strings(), + Self::P2PK33Index => P2PK33Index::to_possible_strings(), + Self::P2PK65Index => P2PK65Index::to_possible_strings(), + Self::P2PKHIndex => P2PKHIndex::to_possible_strings(), + Self::P2SHIndex => P2SHIndex::to_possible_strings(), + Self::P2TRIndex => P2TRIndex::to_possible_strings(), + Self::P2WPKHIndex => P2WPKHIndex::to_possible_strings(), + Self::P2WSHIndex => P2WSHIndex::to_possible_strings(), + Self::QuarterIndex => QuarterIndex::to_possible_strings(), + Self::TxIndex => TxIndex::to_possible_strings(), + Self::UnknownOutputIndex => UnknownOutputIndex::to_possible_strings(), + Self::WeekIndex => WeekIndex::to_possible_strings(), + Self::YearIndex => YearIndex::to_possible_strings(), } } - pub fn all_possible_values() -> Vec { + pub fn all_possible_values() -> Vec<&'static str> { Self::all() - .iter() - .flat_map(|i| i.possible_values().iter().map(|s| s.to_string())) + .into_iter() + .flat_map(|i| i.possible_values().iter().cloned()) .collect::>() } - pub fn serialize_short(&self) -> String { + pub fn serialize_short(&self) -> &'static str { self.possible_values() .iter() .find(|str| str.len() > 1) .unwrap() - .to_string() } - pub fn serialize_long(&self) -> String { - self.possible_values().last().unwrap().to_string() + pub fn serialize_long(&self) -> &'static str { + self.possible_values().last().unwrap() } } @@ -148,6 +154,20 @@ impl TryFrom<&str> for Index { impl fmt::Display for Index { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - Debug::fmt(self, f) + write!(f, "{:?}", self) + } +} + +impl<'de> Deserialize<'de> for Index { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + let str = String::deserialize(deserializer)?; + if let Ok(index) = Index::try_from(str.as_str()) { + Ok(index) + } else { + Err(Error::custom("Bad index")) + } } } diff --git a/crates/brk_query/src/lib.rs b/crates/brk_interface/src/lib.rs similarity index 65% rename from crates/brk_query/src/lib.rs rename to crates/brk_interface/src/lib.rs index aad5ca73e..923fa82f4 100644 --- a/crates/brk_query/src/lib.rs +++ b/crates/brk_interface/src/lib.rs @@ -3,6 +3,8 @@ #![doc = include_str!("../examples/main.rs")] #![doc = "```"] +use std::collections::BTreeMap; + use brk_computer::Computer; use brk_core::Result; use brk_indexer::Indexer; @@ -11,52 +13,43 @@ use tabled::settings::Style; mod format; mod index; +mod maybe_ids; mod output; mod params; mod table; -mod vec_trees; +mod vecs; pub use format::Format; pub use index::Index; pub use output::{Output, Value}; -pub use params::{Params, ParamsOpt}; +pub use params::{Pagination, Params, ParamsOpt}; pub use table::Tabled; -use vec_trees::VecTrees; +use vecs::Vecs; -pub struct Query<'a> { - pub vec_trees: VecTrees<'a>, +use crate::vecs::{IdToVec, IndexToVec}; + +pub struct Interface<'a> { + vecs: Vecs<'a>, _indexer: &'a Indexer, _computer: &'a Computer, } -impl<'a> Query<'a> { +impl<'a> Interface<'a> { pub fn build(indexer: &'a Indexer, computer: &'a Computer) -> Self { - let mut vec_trees = VecTrees::default(); - - indexer - .vecs() - .vecs() - .into_iter() - .for_each(|vec| vec_trees.insert(vec)); - - computer - .vecs() - .into_iter() - .for_each(|vec| vec_trees.insert(vec)); - Self { - vec_trees, + vecs: Vecs::build(indexer, computer), _indexer: indexer, _computer: computer, } } - pub fn search(&self, index: Index, ids: &[&str]) -> Vec<(String, &&dyn AnyCollectableVec)> { - let tuples = ids + pub fn search(&self, params: &Params) -> Vec<(String, &&dyn AnyCollectableVec)> { + let tuples = params + .ids .iter() .flat_map(|s| { s.to_lowercase() - .replace("_", "-") + .replace("-", "_") .split_whitespace() .flat_map(|s| { s.split(',') @@ -65,11 +58,11 @@ impl<'a> Query<'a> { .collect::>() }) .map(|mut id| { - let mut res = self.vec_trees.id_to_index_to_vec.get(&id); + let mut res = self.vecs.id_to_index_to_vec.get(id.as_str()); if res.is_none() { if let Ok(index) = Index::try_from(id.as_str()) { id = index.possible_values().last().unwrap().to_string(); - res = self.vec_trees.id_to_index_to_vec.get(&id) + res = self.vecs.id_to_index_to_vec.get(id.as_str()) } } (id, res) @@ -80,17 +73,19 @@ impl<'a> Query<'a> { tuples .iter() - .flat_map(|(str, i_to_v)| i_to_v.get(&index).map(|vec| (str.to_owned(), vec))) + .flat_map(|(str, i_to_v)| i_to_v.get(¶ms.index).map(|vec| (str.to_owned(), vec))) .collect::>() } pub fn format( &self, vecs: Vec<(String, &&dyn AnyCollectableVec)>, - from: Option, - to: Option, - format: Option, + params: &ParamsOpt, ) -> color_eyre::Result { + let from = params.from(); + let to = params.to(); + let format = params.format(); + let mut values = vecs .iter() .map(|(_, vec)| -> Result> { @@ -165,14 +160,53 @@ impl<'a> Query<'a> { }) } - pub fn search_and_format( + pub fn search_and_format(&self, params: Params) -> color_eyre::Result { + self.format(self.search(¶ms), ¶ms.rest) + } + + pub fn id_to_index_to_vec(&self) -> &BTreeMap<&str, IndexToVec<'_>> { + &self.vecs.id_to_index_to_vec + } + + pub fn index_to_id_to_vec(&self) -> &BTreeMap> { + &self.vecs.index_to_id_to_vec + } + + pub fn get_vecid_count(&self) -> usize { + self.vecs.id_count + } + + pub fn get_index_count(&self) -> usize { + self.vecs.index_count + } + + pub fn get_vec_count(&self) -> usize { + self.vecs.vec_count + } + + pub fn get_indexes(&self) -> &[&'static str] { + &self.vecs.indexes + } + + pub fn get_accepted_indexes(&self) -> &BTreeMap<&'static str, &'static [&'static str]> { + &self.vecs.accepted_indexes + } + + pub fn get_vecids(&self, pagination: Pagination) -> &[&str] { + self.vecs.ids(pagination) + } + + pub fn get_indexes_to_vecids( &self, - index: Index, - ids: &[&str], - from: Option, - to: Option, - format: Option, - ) -> color_eyre::Result { - self.format(self.search(index, ids), from, to, format) + pagination: Pagination, + ) -> BTreeMap<&'static str, Vec<&str>> { + self.vecs.indexes_to_ids(pagination) + } + + pub fn get_vecids_to_indexes( + &self, + pagination: Pagination, + ) -> BTreeMap<&str, Vec<&'static str>> { + self.vecs.ids_to_indexes(pagination) } } diff --git a/crates/brk_interface/src/maybe_ids.rs b/crates/brk_interface/src/maybe_ids.rs new file mode 100644 index 000000000..50a4b0766 --- /dev/null +++ b/crates/brk_interface/src/maybe_ids.rs @@ -0,0 +1,30 @@ +use derive_deref::Deref; +use schemars::JsonSchema; +use serde::Deserialize; + +#[derive(Debug, Deref, JsonSchema)] +pub struct MaybeIds(Vec); + +impl From for MaybeIds { + fn from(value: String) -> Self { + Self(vec![value]) + } +} + +impl<'a> From> for MaybeIds { + fn from(value: Vec<&'a str>) -> Self { + Self(value.iter().map(|s| s.to_string()).collect::>()) + } +} + +impl<'de> Deserialize<'de> for MaybeIds { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + let str = String::deserialize(deserializer)?; + Ok(MaybeIds( + str.split(",").map(|s| s.to_string()).collect::>(), + )) + } +} diff --git a/crates/brk_query/src/output.rs b/crates/brk_interface/src/output.rs similarity index 97% rename from crates/brk_query/src/output.rs rename to crates/brk_interface/src/output.rs index 80300ae54..22028124c 100644 --- a/crates/brk_query/src/output.rs +++ b/crates/brk_interface/src/output.rs @@ -5,7 +5,7 @@ use tabled::Tabled as TabledTabled; use crate::Format; -#[derive(Debug)] +#[derive(Debug, Serialize)] pub enum Output { Json(Value), CSV(String), diff --git a/crates/brk_interface/src/params.rs b/crates/brk_interface/src/params.rs new file mode 100644 index 000000000..37a5d873b --- /dev/null +++ b/crates/brk_interface/src/params.rs @@ -0,0 +1,175 @@ +use std::ops::Deref; + +use rmcp::schemars::{self, JsonSchema}; +use serde::{Deserialize, Deserializer}; + +use crate::{Format, Index, maybe_ids::MaybeIds}; + +#[derive(Debug, Deserialize, JsonSchema)] +pub struct Params { + #[serde(alias = "i")] + #[schemars(description = "Index of the values requested")] + pub index: Index, + + #[serde(alias = "v")] + #[schemars(description = "Ids of the requested vecs")] + pub ids: MaybeIds, + + #[serde(flatten)] + pub rest: ParamsOpt, +} +serde_with::flattened_maybe!(deserialize_rest, "rest"); + +impl Deref for Params { + type Target = ParamsOpt; + fn deref(&self) -> &Self::Target { + &self.rest + } +} + +impl From<((Index, String), ParamsOpt)> for Params { + fn from(((index, id), rest): ((Index, String), ParamsOpt)) -> Self { + Self { + index, + ids: MaybeIds::from(id), + rest, + } + } +} + +#[derive(Default, Debug, Deserialize, JsonSchema)] +pub struct ParamsOpt { + #[serde(default, alias = "f", deserialize_with = "de_unquote_i64")] + /// Inclusive starting index, if negative will be from the end + from: Option, + + #[serde(default, alias = "t", deserialize_with = "de_unquote_i64")] + /// Exclusive ending index, if negative will be from the end, overrides 'count' + to: Option, + + #[serde(default, alias = "c", deserialize_with = "de_unquote_usize")] + /// Number of values + count: Option, + + /// Format of the output + format: Option, +} + +impl ParamsOpt { + pub fn set_from(mut self, from: i64) -> Self { + self.from.replace(from); + self + } + + pub fn set_to(mut self, to: i64) -> Self { + self.to.replace(to); + self + } + + pub fn set_count(mut self, count: usize) -> Self { + self.count.replace(count); + self + } + + pub fn set_format(mut self, format: Format) -> Self { + self.format.replace(format); + self + } + + pub fn from(&self) -> Option { + self.from + } + + pub fn to(&self) -> Option { + if self.to.is_none() { + if let Some(c) = self.count { + let c = c as i64; + if let Some(f) = self.from { + if f.is_positive() || f.abs() > c { + return Some(f + c); + } + } else { + return Some(c); + } + } + } + self.to + } + + pub fn format(&self) -> Option { + self.format + } +} + +fn de_unquote_i64<'de, D>(deserializer: D) -> Result, D::Error> +where + D: Deserializer<'de>, +{ + let value: Option = Option::deserialize(deserializer)?; + + match value { + None => Ok(None), + Some(serde_json::Value::String(mut s)) => { + if s.starts_with('"') && s.ends_with('"') && s.len() >= 2 { + s = s[1..s.len() - 1].to_string(); + } + s.parse::().map(Some).map_err(serde::de::Error::custom) + } + Some(serde_json::Value::Number(n)) => { + // If it's a number, convert it to i64 + n.as_i64() + .ok_or_else(|| serde::de::Error::custom("number out of range")) + .map(Some) + } + _ => Err(serde::de::Error::custom("expected a string or number")), + } +} + +fn de_unquote_usize<'de, D>(deserializer: D) -> Result, D::Error> +where + D: Deserializer<'de>, +{ + let value: Option = Option::deserialize(deserializer)?; + + match value { + None => Ok(None), + Some(serde_json::Value::String(mut s)) => { + if s.starts_with('"') && s.ends_with('"') && s.len() >= 2 { + s = s[1..s.len() - 1].to_string(); + } + s.parse::() + .map(Some) + .map_err(serde::de::Error::custom) + } + Some(serde_json::Value::Number(n)) => { + // If it's a number, convert it to usize + n.as_u64() + .ok_or_else(|| serde::de::Error::custom("number out of range")) + .map(|v| v as usize) + .map(Some) + } + _ => { + dbg!(value); + Err(serde::de::Error::custom("expected a string or number")) + } + } +} + +#[derive(Debug, Default, Deserialize, JsonSchema)] +pub struct Pagination { + #[serde(alias = "p")] + #[schemars(description = "Pagination index")] + pub page: usize, +} + +impl Pagination { + const PER_PAGE: usize = 1_000; + + pub fn start(&self, len: usize) -> usize { + (self.page * Self::PER_PAGE).clamp(0, len) + } + + pub fn end(&self, len: usize) -> usize { + ((self.page + 1) * Self::PER_PAGE).clamp(0, len) + } +} diff --git a/crates/brk_query/src/table.rs b/crates/brk_interface/src/table.rs similarity index 100% rename from crates/brk_query/src/table.rs rename to crates/brk_interface/src/table.rs diff --git a/crates/brk_interface/src/vecs.rs b/crates/brk_interface/src/vecs.rs new file mode 100644 index 000000000..800f4c14d --- /dev/null +++ b/crates/brk_interface/src/vecs.rs @@ -0,0 +1,189 @@ +use std::collections::BTreeMap; + +use brk_computer::Computer; +use brk_indexer::Indexer; +use brk_vec::AnyCollectableVec; +use derive_deref::{Deref, DerefMut}; + +use crate::params::Pagination; + +use super::index::Index; + +#[derive(Default)] +pub struct Vecs<'a> { + pub id_to_index_to_vec: BTreeMap<&'a str, IndexToVec<'a>>, + pub index_to_id_to_vec: BTreeMap>, + pub ids: Vec<&'a str>, + pub indexes: Vec<&'static str>, + pub accepted_indexes: BTreeMap<&'static str, &'static [&'static str]>, + pub index_count: usize, + pub id_count: usize, + pub vec_count: usize, + serialized_id_to_indexes: BTreeMap<&'a str, Vec<&'static str>>, + serialized_indexes_to_ids: BTreeMap<&'static str, Vec<&'a str>>, +} + +impl<'a> Vecs<'a> { + pub fn build(indexer: &'a Indexer, computer: &'a Computer) -> Self { + let mut this = Vecs::default(); + + indexer + .vecs + .vecs() + .into_iter() + .for_each(|vec| this.insert(vec)); + + computer + .vecs + .vecs() + .into_iter() + .for_each(|vec| this.insert(vec)); + + let mut ids = this.id_to_index_to_vec.keys().cloned().collect::>(); + ids.sort_unstable_by(|a, b| { + let len_cmp = a.len().cmp(&b.len()); + if len_cmp == std::cmp::Ordering::Equal { + a.cmp(b) + } else { + len_cmp + } + }); + + this.ids = ids; + this.id_count = this.index_to_id_to_vec.keys().count(); + this.index_count = this.index_to_id_to_vec.keys().count(); + this.vec_count = this + .index_to_id_to_vec + .values() + .map(|tree| tree.len()) + .sum::(); + this.indexes = this + .index_to_id_to_vec + .keys() + .map(|i| i.serialize_long()) + .collect::>(); + this.accepted_indexes = this + .index_to_id_to_vec + .keys() + .map(|i| (i.serialize_long(), i.possible_values())) + .collect::>(); + this.serialized_id_to_indexes = this + .id_to_index_to_vec + .iter() + .map(|(id, index_to_vec)| { + ( + *id, + index_to_vec + .keys() + .map(|i| i.serialize_long()) + .collect::>(), + ) + }) + .collect(); + this.serialized_indexes_to_ids = this + .index_to_id_to_vec + .iter() + .map(|(index, id_to_vec)| { + ( + index.serialize_long(), + id_to_vec.keys().cloned().collect::>(), + ) + }) + .collect(); + + this + } + + // Not the most performant or type safe but only built once so that's okay + fn insert(&mut self, vec: &'a dyn AnyCollectableVec) { + let name = vec.name(); + let serialized_index = vec.index_type_to_string(); + let split = name.split("_to_").collect::>(); + if split.len() != 1 + && !(split.len() == 2 + && split.first().is_some_and(|s| { + s == &"up" + || s == &"start" + || s.ends_with("relative") + || s.starts_with("from") + || s == &"cumulative_up" + || s.starts_with("cumulative_start") + || s.starts_with("cumulative_from") + || s == &"activity" + })) + && !(split.len() == 3 + && split.first().is_some_and(|s| { + s == &"up" + || s == &"start" + || s.starts_with("from") + || s == &"cumulative_up" + || s == &"cumulative_start" + || s.starts_with("cumulative_from") + }) + && split.get(1).is_some_and(|s| s.ends_with("relative"))) + { + dbg!((&serialized_index, &name, &split)); + unreachable!(); + } + let index = Index::try_from(serialized_index) + .inspect_err(|_| { + dbg!(&serialized_index); + }) + .unwrap(); + let prev = self + .id_to_index_to_vec + .entry(name) + .or_default() + .insert(index, vec); + if prev.is_some() { + dbg!(serialized_index, name); + panic!() + } + let prev = self + .index_to_id_to_vec + .entry(index) + .or_default() + .insert(name, vec); + if prev.is_some() { + dbg!(serialized_index, name); + panic!() + } + } + + pub fn ids(&self, pagination: Pagination) -> &[&'_ str] { + let len = self.ids.len(); + let start = pagination.start(len); + let end = pagination.end(len); + &self.ids[start..end] + } + + pub fn ids_to_indexes(&self, pagination: Pagination) -> BTreeMap<&'_ str, Vec<&'static str>> { + let len = self.serialized_id_to_indexes.len(); + let start = pagination.start(len); + let end = pagination.end(len); + self.serialized_id_to_indexes + .iter() + .skip(start) + .take(end) + .map(|(ids, indexes)| (*ids, indexes.clone())) + .collect() + } + + pub fn indexes_to_ids(&self, pagination: Pagination) -> BTreeMap<&'static str, Vec<&'a str>> { + let len = self.serialized_indexes_to_ids.len(); + let start = pagination.start(len); + let end = pagination.end(len); + self.serialized_indexes_to_ids + .iter() + .skip(start) + .take(end) + .map(|(index, ids)| (*index, ids.clone())) + .collect() + } +} + +#[derive(Default, Deref, DerefMut)] +pub struct IndexToVec<'a>(BTreeMap); + +#[derive(Default, Deref, DerefMut)] +pub struct IdToVec<'a>(BTreeMap<&'a str, &'a dyn AnyCollectableVec>); diff --git a/crates/brk_query/examples/main.rs b/crates/brk_query/examples/main.rs deleted file mode 100644 index b28d7f88e..000000000 --- a/crates/brk_query/examples/main.rs +++ /dev/null @@ -1,28 +0,0 @@ -use std::path::Path; - -use brk_computer::Computer; -use brk_indexer::Indexer; -use brk_query::{Index, Query}; -use brk_vec::{Computation, Format}; - -pub fn main() -> color_eyre::Result<()> { - color_eyre::install()?; - - let outputs_dir = Path::new("../../_outputs"); - - let format = Format::Compressed; - - let mut indexer = Indexer::new(outputs_dir, true)?; - indexer.import_vecs()?; - - let mut computer = Computer::new(outputs_dir, None, format); - computer.import_vecs(&indexer, Computation::Lazy)?; - - let query = Query::build(&indexer, &computer); - - dbg!(query.search_and_format(Index::Height, &["date"], Some(-1), None, None)?); - dbg!(query.search_and_format(Index::Height, &["date"], Some(-10), None, None)?); - dbg!(query.search_and_format(Index::Height, &["date", "timestamp"], Some(-10), None, None)?); - - Ok(()) -} diff --git a/crates/brk_query/src/params.rs b/crates/brk_query/src/params.rs deleted file mode 100644 index 6446ac010..000000000 --- a/crates/brk_query/src/params.rs +++ /dev/null @@ -1,129 +0,0 @@ -use std::{fmt::Display, ops::Deref, str::FromStr}; - -use clap::builder::PossibleValuesParser; -use clap_derive::Parser; -use serde::{Deserialize, Deserializer}; -use serde_with::{OneOrMany, formats::PreferOne, serde_as}; - -use crate::{Format, Index}; - -#[serde_as] -#[derive(Debug, Deserialize, Parser)] -pub struct Params { - #[clap(short, long, value_parser = PossibleValuesParser::new(Index::all_possible_values()))] - #[serde(alias = "i")] - /// Index of the values requested - pub index: String, - #[clap(short, long, value_delimiter = ' ', num_args = 1..)] - #[serde(alias = "v")] - #[serde_as(as = "OneOrMany<_, PreferOne>")] - /// Names of the values requested - pub values: Vec, - - #[clap(flatten)] - #[serde(flatten)] - pub rest: ParamsOpt, -} - -// The macro creates custom deserialization code. -// You need to specify a function name and the field name of the flattened field. -serde_with::flattened_maybe!(deserialize_rest, "rest"); - -impl Deref for Params { - type Target = ParamsOpt; - fn deref(&self) -> &Self::Target { - &self.rest - } -} - -impl From<((String, String), ParamsOpt)> for Params { - fn from(((index, id), rest): ((String, String), ParamsOpt)) -> Self { - Self { - index, - values: vec![id], - rest, - } - } -} - -#[serde_as] -#[derive(Debug, Deserialize, Parser)] -pub struct ParamsOpt { - #[clap(short, long, allow_hyphen_values = true)] - #[serde(default, alias = "f", deserialize_with = "de_unquote_i64")] - /// Inclusive starting index, if negative will be from the end - from: Option, - #[clap(short, long, allow_hyphen_values = true)] - #[serde(default, alias = "t", deserialize_with = "de_unquote_i64")] - /// Exclusive ending index, if negative will be from the end, overrides 'count' - to: Option, - #[clap(short, long, allow_hyphen_values = true)] - #[serde(default, alias = "c", deserialize_with = "de_unquote_usize")] - /// Number of values - count: Option, - #[clap(short = 'F', long)] - /// Format of the output - format: Option, -} - -impl ParamsOpt { - pub fn from(&self) -> Option { - self.from - } - - pub fn to(&self) -> Option { - if self.to.is_none() { - if let Some(c) = self.count { - let c = c as i64; - if let Some(f) = self.from { - if f.is_positive() || f.abs() > c { - return Some(f + c); - } - } else { - return Some(c); - } - } - } - self.to - } - - pub fn format(&self) -> Option { - self.format - } -} - -fn de_unquote_i64<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de>, -{ - de_unquote(deserializer) -} - -fn de_unquote_usize<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de>, -{ - de_unquote(deserializer) -} - -fn de_unquote<'de, D, F>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de>, - F: FromStr + Display, - ::Err: Display, -{ - let opt: Option = Option::deserialize(deserializer)?; - let s = match opt { - None => return Ok(None), - Some(mut s) => { - // strip any leading/trailing quotes - if s.starts_with('"') && s.ends_with('"') && s.len() >= 2 { - s = s[1..s.len() - 1].to_string(); - } - s - } - }; - s.parse::() - .map(Some) - .map_err(|e| serde::de::Error::custom(format!("cannot parse `{}` as type: {}", s, e))) -} diff --git a/crates/brk_query/src/vec_trees.rs b/crates/brk_query/src/vec_trees.rs deleted file mode 100644 index 448366e3a..000000000 --- a/crates/brk_query/src/vec_trees.rs +++ /dev/null @@ -1,116 +0,0 @@ -use std::collections::BTreeMap; - -use brk_vec::AnyCollectableVec; -use derive_deref::{Deref, DerefMut}; - -use super::index::Index; - -#[derive(Default)] -pub struct VecTrees<'a> { - pub id_to_index_to_vec: BTreeMap>, - pub index_to_id_to_vec: BTreeMap>, -} - -impl<'a> VecTrees<'a> { - // Not the most performant or type safe but only built once so that's okay - pub fn insert(&mut self, vec: &'a dyn AnyCollectableVec) { - let name = vec.name(); - let split = name.split("_to_").collect::>(); - if split.len() != 2 - && !(split.len() == 3 - && split.get(1).is_some_and(|s| { - s == &"up" - || s == &"start" - || s.ends_with("relative") - || s.starts_with("from") - || s == &"cumulative_up" - || s.starts_with("cumulative_start") - || s.starts_with("cumulative_from") - || s == &"activity" - })) - && !(split.len() == 4 - && split.get(1).is_some_and(|s| { - s == &"up" - || s == &"start" - || s.starts_with("from") - || s == &"cumulative_up" - || s == &"cumulative_start" - || s.starts_with("cumulative_from") - }) - && split.get(2).is_some_and(|s| s.ends_with("relative"))) - { - dbg!(&name, &split); - panic!(); - } - let str = vec - .index_type_to_string() - .split("::") - .last() - .unwrap() - .to_lowercase(); - let index = Index::try_from(str.as_str()) - .inspect_err(|_| { - dbg!(&str); - }) - .unwrap(); - if split[0] != index.to_string().to_lowercase() { - dbg!(&name, split[0], index.to_string()); - panic!(); - } - let key = split[1..].join("_to_").to_string().replace("_", "-"); - let prev = self - .id_to_index_to_vec - .entry(key.clone()) - .or_default() - .insert(index, vec); - if prev.is_some() { - dbg!(&key, str, name); - panic!() - } - let prev = self - .index_to_id_to_vec - .entry(index) - .or_default() - .insert(key.clone(), vec); - if prev.is_some() { - dbg!(&key, str, name); - panic!() - } - } - - pub fn serialize_id_to_index_to_vec(&self) -> BTreeMap> { - self.id_to_index_to_vec - .iter() - .map(|(id, index_to_vec)| { - ( - id.to_string(), - index_to_vec - .keys() - .map(|i| i.serialize_long()) - .collect::>(), - ) - }) - .collect() - } - - pub fn serialize_index_to_id_to_vec(&self) -> BTreeMap> { - self.index_to_id_to_vec - .iter() - .map(|(index, id_to_vec)| { - ( - index.serialize_long(), - id_to_vec - .keys() - .map(|id| id.to_string()) - .collect::>(), - ) - }) - .collect() - } -} - -#[derive(Default, Deref, DerefMut)] -pub struct IndexToVec<'a>(BTreeMap); - -#[derive(Default, Deref, DerefMut)] -pub struct IdToVec<'a>(BTreeMap); diff --git a/crates/brk_server/Cargo.toml b/crates/brk_server/Cargo.toml index eccc9786f..e881c0003 100644 --- a/crates/brk_server/Cargo.toml +++ b/crates/brk_server/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "brk_server" -description = "A crate that serves Bitcoin data and swappable front-ends, built on top of brk_indexer, brk_computer and brk_query" +description = "A crate that serves Bitcoin data and swappable front-ends, built on top of brk_indexer, brk_computer and brk_interface" version.workspace = true edition.workspace = true license.workspace = true @@ -12,13 +12,13 @@ axum = { workspace = true } bitcoincore-rpc = { workspace = true } brk_bundler = { workspace = true } brk_computer = { workspace = true } -brk_exit = { workspace = true } brk_core = { workspace = true } +brk_exit = { workspace = true } brk_fetcher = { workspace = true } brk_indexer = { workspace = true } brk_logger = { workspace = true } brk_parser = { workspace = true } -brk_query = { workspace = true } +brk_interface = { workspace = true } brk_vec = { workspace = true } clap = { workspace = true } clap_derive = { workspace = true } @@ -26,12 +26,12 @@ color-eyre = { workspace = true } jiff = { workspace = true } log = { workspace = true } minreq = { workspace = true } -oxc = { version = "0.73.0", features = ["codegen", "minifier"] } +rmcp = { workspace = true } serde = { workspace = true } tokio = { workspace = true } tower-http = { version = "0.6.6", features = ["compression-full", "trace"] } -zip = "4.1.0" tracing = "0.1.41" +zip = "4.1.0" [package.metadata.cargo-machete] ignored = ["clap"] diff --git a/crates/brk_server/README.md b/crates/brk_server/README.md index ca61addc7..6c0099bfc 100644 --- a/crates/brk_server/README.md +++ b/crates/brk_server/README.md @@ -31,11 +31,11 @@
+ 
+