use qql_core::error::QqlError;
use super::catalog::short_alias_matches;
use super::catalog::{is_image_alias, is_multi_alias, is_reranker_alias, is_sparse_alias};
use super::{FastEmbedder, FastEmbedderOptions};
impl FastEmbedder {
pub fn try_default() -> Result<Self, QqlError> {
Self::try_with_options(FastEmbedderOptions::default())
}
pub fn try_from_model(model: &str) -> Result<Self, QqlError> {
Self::try_with_options(FastEmbedderOptions {
model: Some(model.to_string()),
..Default::default()
})
}
pub fn model_name(&self) -> &str {
&self.dense.model_name
}
pub fn model_code(&self) -> &str {
&self.dense.model_code
}
pub fn dimension(&self) -> usize {
self.dense.dim
}
pub fn multi_model_name(&self) -> Option<&str> {
self.multi.as_ref().map(|m| m.model_name.as_str())
}
pub fn multi_model_code(&self) -> Option<&str> {
self.multi.as_ref().map(|m| m.model_code.as_str())
}
pub fn multi_dimension(&self) -> Option<usize> {
self.multi.as_ref().map(|m| m.dim)
}
pub fn has_multi(&self) -> bool {
self.multi.is_some()
}
pub fn image_model_name(&self) -> Option<&str> {
self.image.as_ref().map(|m| m.model_name.as_str())
}
pub fn image_model_code(&self) -> Option<&str> {
self.image.as_ref().map(|m| m.model_code.as_str())
}
pub fn image_dimension(&self) -> Option<usize> {
self.image.as_ref().map(|m| m.dim)
}
pub fn has_image(&self) -> bool {
self.image.is_some()
}
pub fn has_reranker(&self) -> bool {
self.reranker.is_some()
}
pub fn sparse_model_name(&self) -> Option<&str> {
self.sparse.as_ref().map(|s| s.model_name.as_str())
}
pub fn sparse_model_code(&self) -> Option<&str> {
self.sparse.as_ref().map(|s| s.model_code.as_str())
}
pub fn has_sparse(&self) -> bool {
self.sparse.is_some()
}
pub fn reranker_model_code(&self) -> Option<&str> {
self.reranker.as_ref().map(|m| m.model_code.as_str())
}
pub(crate) fn accepts_reranker_model(&self, requested: &str) -> bool {
let Some(ref r) = self.reranker else {
return false;
};
let req = requested.trim();
if req.is_empty() || req.eq_ignore_ascii_case("default") {
return true;
}
req.eq_ignore_ascii_case(&r.model_name)
|| req.eq_ignore_ascii_case(&r.model_code)
|| short_alias_matches(req, &r.model_code)
|| is_reranker_alias(req)
}
pub fn accepts_model(&self, requested: &str) -> bool {
let r = requested.trim();
if r.is_empty() || r.eq_ignore_ascii_case("default") {
return true;
}
if r.eq_ignore_ascii_case(&self.dense.model_name)
|| r.eq_ignore_ascii_case(&self.dense.model_code)
|| short_alias_matches(r, &self.dense.model_code)
{
return true;
}
if let Some(ref sparse) = self.sparse
&& (r.eq_ignore_ascii_case(&sparse.model_name)
|| r.eq_ignore_ascii_case(&sparse.model_code)
|| short_alias_matches(r, &sparse.model_code)
|| is_sparse_alias(r))
{
return true;
}
if let Some(ref multi) = self.multi
&& (r.eq_ignore_ascii_case(&multi.model_name)
|| r.eq_ignore_ascii_case(&multi.model_code)
|| short_alias_matches(r, &multi.model_code)
|| is_multi_alias(r))
{
return true;
}
if let Some(ref image) = self.image
&& (r.eq_ignore_ascii_case(&image.model_name)
|| r.eq_ignore_ascii_case(&image.model_code)
|| short_alias_matches(r, &image.model_code)
|| is_image_alias(r))
{
return true;
}
false
}
pub(crate) fn accepts_image_model(&self, requested: &str) -> bool {
let Some(ref image) = self.image else {
return false;
};
let r = requested.trim();
if r.is_empty() || r.eq_ignore_ascii_case("default") {
return true;
}
r.eq_ignore_ascii_case(&image.model_name)
|| r.eq_ignore_ascii_case(&image.model_code)
|| short_alias_matches(r, &image.model_code)
|| is_image_alias(r)
}
pub(crate) fn accepts_dense_model(&self, requested: &str) -> bool {
let r = requested.trim();
if r.is_empty() || r.eq_ignore_ascii_case("default") {
return true;
}
r.eq_ignore_ascii_case(&self.dense.model_name)
|| r.eq_ignore_ascii_case(&self.dense.model_code)
|| short_alias_matches(r, &self.dense.model_code)
}
pub(crate) fn accepts_sparse_model(&self, requested: &str) -> bool {
let Some(ref sparse) = self.sparse else {
return false;
};
let r = requested.trim();
if r.is_empty() || r.eq_ignore_ascii_case("default") {
return true;
}
r.eq_ignore_ascii_case(&sparse.model_name)
|| r.eq_ignore_ascii_case(&sparse.model_code)
|| short_alias_matches(r, &sparse.model_code)
|| is_sparse_alias(r)
}
pub(crate) fn accepts_multi_model(&self, requested: &str) -> bool {
let Some(ref multi) = self.multi else {
return false;
};
let r = requested.trim();
if r.is_empty() || r.eq_ignore_ascii_case("default") {
return true;
}
r.eq_ignore_ascii_case(&multi.model_name)
|| r.eq_ignore_ascii_case(&multi.model_code)
|| short_alias_matches(r, &multi.model_code)
|| is_multi_alias(r)
}
}
impl std::fmt::Debug for FastEmbedder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("FastEmbedder")
.field("model_name", &self.dense.model_name)
.field("model_code", &self.dense.model_code)
.field("dim", &self.dense.dim)
.field(
"sparse_model",
&self.sparse.as_ref().map(|m| m.model_code.as_str()),
)
.field(
"multi_model",
&self.multi.as_ref().map(|m| m.model_code.as_str()),
)
.field("multi_dim", &self.multi.as_ref().map(|m| m.dim))
.field(
"image_model",
&self.image.as_ref().map(|m| m.model_code.as_str()),
)
.field("image_dim", &self.image.as_ref().map(|m| m.dim))
.finish()
}
}