Replace type guessing with type conversion

Author: chardoncs

python/cocoindex/typing.py

@@ -240,7 +240,7 @@ def _encode_type(type_info: AnalyzedTypeInfo) -> dict[str, Any]:
     elif type_info.kind == 'Union':
         if type_info.elem_type is not types.UnionType:
             raise ValueError("Union type must have a union-typed element type")
-        encoded_type['types'] = [
+        encoded_type['possible_types'] = [
             _encode_type(analyze_type_info(typ)) for typ in type_info.union_variant_types
         ]
 

src/base/value.rs

@@ -934,60 +934,6 @@ impl BasicValue {
                     .collect::<Result<Vec<_>>>()?;
                 BasicValue::Vector(Arc::from(vec))
             }
-            (v, BasicValueType::Union(typ)) => {
-                let types = typ.types();
-
-                match v {
-                    serde_json::Value::Bool(b) if types.contains(&BasicValueType::Bool) => {
-                        BasicValue::Bool(b)
-                    }
-                    serde_json::Value::Number(n) => {
-                        if types.contains(&BasicValueType::Int64) {
-                            match n.as_i64() {
-                                Some(n) => return Ok(BasicValue::Int64(n)),
-                                None => {}
-                            }
-                        }
-
-                        if types.contains(&BasicValueType::Float64) {
-                            match n.as_f64() {
-                                Some(n) => return Ok(BasicValue::Float64(n)),
-                                None => {}
-                            }
-                        }
-
-                        if types.contains(&BasicValueType::Float32) {
-                            match n.as_f64().map(|v| v as f32) {
-                                Some(n) => return Ok(BasicValue::Float32(n)),
-                                None => {}
-                            }
-                        }
-
-                        anyhow::bail!("Invalid number value {n}")
-                    }
-                    serde_json::Value::Object(obj) if types.contains(&BasicValueType::Range) => {
-                        let start = obj.get("start").and_then(|val| val.as_u64());
-                        let end = obj.get("end").and_then(|val| val.as_u64());
-
-                        match (start, end) {
-                            (Some(start), Some(end)) => {
-                                BasicValue::Range(RangeValue::new(start as usize, end as usize))
-                            }
-                            _ => anyhow::bail!("Invalid range value")
-                        }
-                    }
-                    serde_json::Value::String(s) => {
-                        match types.parse_str(&s) {
-                            Ok(val) => return Ok(val),
-                            Err(_) => {}
-                        }
-
-                        anyhow::bail!("Invalid string value \"{s}\"")
-                    }
-
-                    _ => anyhow::bail!("Invalid union value {v}, expect type {}", types.iter().join(" | ")),
-                }
-            }
             (v, t) => {
                 anyhow::bail!("Value and type not matched.\nTarget type {t:?}\nJSON value: {v}\n")
             }
@@ -1120,7 +1066,11 @@ impl Serialize for TypedValue<'_> {
     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match (self.t, self.v) {
             (_, Value::Null) => serializer.serialize_none(),
-            (ValueType::Basic(_), v) => v.serialize(serializer),
+            (ValueType::Basic(typ), v) => match typ {
+                BasicValueType::Union(s) => {
+                }
+                _ => v.serialize(serializer),
+            },
             (ValueType::Struct(s), Value::Struct(field_values)) => TypedFieldsValue {
                 schema: &s.fields,
                 values_iter: field_values.fields.iter(),

src/utils/union.rs

@@ -1,158 +1,50 @@
-use std::{str::FromStr, sync::Arc};
-
 use crate::{base::{schema::BasicValueType, value::BasicValue}, prelude::*};
 
-#[derive(Debug, Clone)]
-pub enum UnionParseResult {
-    Union(UnionType),
-    Single(BasicValueType),
-}
-
 /// Union type helper storing an auto-sorted set of types excluding `Union`
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub struct UnionType {
-    types: BTreeSet<BasicValueType>,
+    possible_types: BTreeSet<BasicValueType>,
 }
 
 impl UnionType {
-    fn new() -> Self {
-        Self { types: BTreeSet::new() }
-    }
-
-    pub fn types(&self) -> &BTreeSet<BasicValueType> {
-        &self.types
-    }
-
-    pub fn insert(&mut self, value: BasicValueType) -> bool {
-        match value {
-            BasicValueType::Union(union_type) => {
-                let mut inserted = false;
-
-                // Unpack nested union
-                for item in union_type.types.into_iter() {
-                    // Recursively insert underlying types
-                    inserted = self.insert(item) || inserted;
+    pub fn possible_types(&self) -> &BTreeSet<BasicValueType> {
+        &self.possible_types
+    }
+
+    pub fn match_type(&self, value: &BasicValue) -> Option<BasicValueType> {
+        // TODO: Use a general converter
+        let typ = match value {
+            BasicValue::Bytes(_) => Some(BasicValueType::Bytes),
+            BasicValue::Str(_) => Some(BasicValueType::Str),
+            BasicValue::Bool(_) => Some(BasicValueType::Bool),
+            BasicValue::Int64(_) => Some(BasicValueType::Int64),
+            BasicValue::Float32(_) => Some(BasicValueType::Float32),
+            BasicValue::Float64(_) => Some(BasicValueType::Float64),
+            BasicValue::Range(_) => Some(BasicValueType::Range),
+            BasicValue::Uuid(_) => Some(BasicValueType::Uuid),
+            BasicValue::Date(_) => Some(BasicValueType::Date),
+            BasicValue::Time(_) => Some(BasicValueType::Time),
+            BasicValue::LocalDateTime(_) => Some(BasicValueType::LocalDateTime),
+            BasicValue::OffsetDateTime(_) => Some(BasicValueType::OffsetDateTime),
+            BasicValue::Json(_) => Some(BasicValueType::Json),
+            BasicValue::Vector(v) => {
+                match v.first() {
+                    Some(first_elem) => self.match_type(first_elem),
+                    None => None,
                 }
-
-                inserted
             }
+        };
 
-            other => self.types.insert(other),
-        }
-    }
-
-    fn resolve(self) -> Result<UnionParseResult> {
-        if self.types().is_empty() {
-            anyhow::bail!("The union is empty");
-        }
-
-        if self.types().len() == 1 {
-            let mut type_tree: BTreeSet<BasicValueType> = self.into();
-            return Ok(UnionParseResult::Single(type_tree.pop_first().unwrap()));
-        }
-
-        Ok(UnionParseResult::Union(self))
-    }
-
-    /// Move an iterable and parse it into a union type.
-    /// If there is only one single unique type, it returns a single `BasicValueType`.
-    pub fn parse_from<T>(
-        input: impl IntoIterator<Item = BasicValueType, IntoIter = T>,
-    ) -> Result<UnionParseResult>
-    where
-        T: Iterator<Item = BasicValueType>,
-    {
-        let mut union = Self::new();
-
-        for typ in input {
-            union.insert(typ);
-        }
-
-        union.resolve()
-    }
-
-    /// Assume the input already contains multiple unique types, panic otherwise.
-    ///
-    /// This method is meant for streamlining the code for test cases.
-    /// Use `parse_from()` instead unless you know the input.
-    pub fn coerce_from<T>(
-        input: impl IntoIterator<Item = BasicValueType, IntoIter = T>,
-    ) -> Self
-    where
-        T: Iterator<Item = BasicValueType>,
-    {
-        match Self::parse_from(input) {
-            Ok(UnionParseResult::Union(union)) => union,
-            _ => panic!("Do not use `coerce_from()` for basic type lists that can possibly be one type."),
-        }
+        typ.and_then(|typ| {
+            self.possible_types()
+                .contains(&typ)
+                .then_some(typ)
+        })
     }
 }
 
-impl Into<BTreeSet<BasicValueType>> for UnionType {
-    fn into(self) -> BTreeSet<BasicValueType> {
-        self.types
-    }
-}
-
-pub trait ParseStr {
-    type Out;
-    type Err;
-
-    fn parse_str(&self, value: &str) -> Result<Self::Out, Self::Err>;
-}
-
-impl ParseStr for BTreeSet<BasicValueType> {
-    type Out = BasicValue;
-    type Err = anyhow::Error;
-
-    /// Try parsing the str value to each possible type, and return the first successful result
-    fn parse_str(&self, value: &str) -> Result<BasicValue> {
-        // Try parsing the value in the reversed order of the enum elements
-        for typ in self.iter().rev() {
-            match typ {
-                BasicValueType::Uuid => {
-                    match value.parse().map(BasicValue::Uuid) {
-                        Ok(ret) => return Ok(ret),
-                        Err(_) => {}
-                    }
-                }
-                BasicValueType::OffsetDateTime => {
-                    match value.parse().map(BasicValue::OffsetDateTime) {
-                        Ok(ret) => return Ok(ret),
-                        Err(_) => {}
-                    }
-                }
-                BasicValueType::LocalDateTime => {
-                    match value.parse().map(BasicValue::LocalDateTime) {
-                        Ok(ret) => return Ok(ret),
-                        Err(_) => {}
-                    }
-                }
-                BasicValueType::Date => {
-                    match value.parse().map(BasicValue::Date) {
-                        Ok(ret) => return Ok(ret),
-                        Err(_) => {}
-                    }
-                }
-                BasicValueType::Time => {
-                    match value.parse().map(BasicValue::Time) {
-                        Ok(ret) => return Ok(ret),
-                        Err(_) => {}
-                    }
-                }
-                BasicValueType::Json => {
-                    match serde_json::Value::from_str(value) {
-                        Ok(ret) => return Ok(BasicValue::Json(ret.into())),
-                        Err(_) => {}
-                    }
-                }
-                BasicValueType::Str => {
-                    return Ok(BasicValue::Str(Arc::from(value)));
-                }
-                _ => {}
-            }
-        }
-
-        anyhow::bail!("Cannot parse \"{}\"", value)
-    }
+#[derive(Debug, Clone, Serialize)]
+pub struct UnionVariant<'a> {
+    pub tag_id: &'a str,
+    pub value: &'a BasicValue,
 }