pre-commit pass

Author: belloibrahv

pyproject.toml

@@ -84,3 +84,11 @@ strict = true
 files = "python/cocoindex"
 exclude = "(\\.venv|site-packages)"
 disable_error_code = ["unused-ignore"]
+[[tool.mypy.overrides]]
+module = [
+    "sentence_transformers",
+    "torch",
+    "colpali_engine",
+    "PIL",
+]
+ignore_missing_imports = true

python/cocoindex/tests/test_convert.py

@@ -1724,21 +1724,24 @@ def test_pydantic_field_descriptions() -> None:
 
     class UserWithDescriptions(BaseModel):
         """A user model with field descriptions."""
+
         name: str = Field(description="The user's full name")
         age: int = Field(description="The user's age in years", ge=0, le=150)
         email: str = Field(description="The user's email address")
-        is_active: bool = Field(description="Whether the user account is active", default=True)
+        is_active: bool = Field(
+            description="Whether the user account is active", default=True
+        )
 
     # Test that field descriptions are extracted
     encoded_schema = dump_engine_object(UserWithDescriptions)
-    
+
     # Check that the schema contains field descriptions
     assert "fields" in encoded_schema["type"]
     fields = encoded_schema["type"]["fields"]
-    
+
     # Find fields by name and check descriptions
     field_descriptions = {field["name"]: field.get("description") for field in fields}
-    
+
     assert field_descriptions["name"] == "The user's full name"
     assert field_descriptions["age"] == "The user's age in years"
     assert field_descriptions["email"] == "The user's email address"
@@ -1752,17 +1755,18 @@ def test_pydantic_field_descriptions_without_field() -> None:
 
     class UserWithoutDescriptions(BaseModel):
         """A user model without field descriptions."""
+
         name: str
         age: int
         email: str
 
     # Test that the schema works without descriptions
     encoded_schema = dump_engine_object(UserWithoutDescriptions)
-    
+
     # Check that the schema contains fields but no descriptions
     assert "fields" in encoded_schema["type"]
     fields = encoded_schema["type"]["fields"]
-    
+
     # Verify no descriptions are present
     for field in fields:
         assert "description" not in field or field["description"] is None
@@ -1775,20 +1779,21 @@ def test_pydantic_mixed_descriptions() -> None:
 
     class MixedDescriptions(BaseModel):
         """A model with mixed field descriptions."""
+
         name: str = Field(description="The name field")
         age: int  # No description
         email: str = Field(description="The email field")
         active: bool  # No description
 
     # Test that only fields with descriptions have them in the schema
     encoded_schema = dump_engine_object(MixedDescriptions)
-    
+
     assert "fields" in encoded_schema["type"]
     fields = encoded_schema["type"]["fields"]
-    
+
     # Find fields by name and check descriptions
     field_descriptions = {field["name"]: field.get("description") for field in fields}
-    
+
     assert field_descriptions["name"] == "The name field"
     assert field_descriptions["age"] is None
     assert field_descriptions["email"] == "The email field"

python/cocoindex/typing.py

@@ -359,7 +359,9 @@ def _encode_struct_schema(
 ) -> tuple[dict[str, Any], int | None]:
     fields = []
 
-    def add_field(name: str, analyzed_type: AnalyzedTypeInfo, description: str | None = None) -> None:
+    def add_field(
+        name: str, analyzed_type: AnalyzedTypeInfo, description: str | None = None
+    ) -> None:
         try:
             type_info = encode_enriched_type_info(analyzed_type)
         except ValueError as e:
@@ -387,7 +389,7 @@ def add_fields_from_struct(struct_type: type) -> None:
                     # Get the annotation from the field info
                     field_type = field_info.annotation
                     # Extract description from Pydantic field info
-                    description = getattr(field_info, 'description', None)
+                    description = getattr(field_info, "description", None)
                     add_field(name, analyze_type_info(field_type), description)
             else:
                 raise ValueError(f"Invalid Pydantic model: {struct_type}")
@@ -633,9 +635,9 @@ class FieldSchema:
     @staticmethod
     def decode(obj: dict[str, Any]) -> "FieldSchema":
         return FieldSchema(
-            name=obj["name"], 
+            name=obj["name"],
             value_type=EnrichedValueType.decode(obj),
-            description=obj.get("description")
+            description=obj.get("description"),
         )
 
     def encode(self) -> dict[str, Any]:

src/base/json_schema.rs

@@ -46,11 +46,14 @@ impl JsonSchemaBuilder {
             let mut fields: Vec<_> = field_path.iter().map(|f| f.as_str()).collect();
             fields.reverse();
             let field_path_str = fields.join(".");
-            
+
             // Check if we already have a description for this field
-            if let Some(existing_description) = self.extra_instructions_per_field.get(&field_path_str) {
+            if let Some(existing_description) =
+                self.extra_instructions_per_field.get(&field_path_str)
+            {
                 // Concatenate descriptions with newline separator
-                let combined_description = format!("{}\n{}", existing_description, description.to_string());
+                let combined_description =
+                    format!("{}\n{}", existing_description, description.to_string());
                 self.extra_instructions_per_field
                     .insert(field_path_str, combined_description);
             } else {
@@ -61,7 +64,8 @@ impl JsonSchemaBuilder {
             let metadata = schema.metadata.get_or_insert_default();
             if let Some(existing_description) = &metadata.description {
                 // Concatenate descriptions with newline separator
-                let combined_description = format!("{}\n{}", existing_description, description.to_string());
+                let combined_description =
+                    format!("{}\n{}", existing_description, description.to_string());
                 metadata.description = Some(combined_description);
             } else {
                 metadata.description = Some(description.to_string());
@@ -378,25 +382,25 @@ pub fn build_json_schema(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::base::schema::{BasicValueType, EnrichedValueType, FieldSchema, StructSchema, ValueType};
+    use crate::base::schema::{
+        BasicValueType, EnrichedValueType, FieldSchema, StructSchema, ValueType,
+    };
     use std::sync::Arc;
 
     #[test]
     fn test_description_concatenation() {
         // Create a struct with a field that has both field-level and type-level descriptions
         let struct_schema = StructSchema {
             description: Some(Arc::from("Test struct description")),
-            fields: Arc::new(vec![
-                FieldSchema {
-                    name: "uuid_field".to_string(),
-                    value_type: EnrichedValueType {
-                        typ: ValueType::Basic(BasicValueType::Uuid),
-                        nullable: false,
-                        attrs: Default::default(),
-                    },
-                    description: Some(Arc::from("This is a field-level description for UUID")),
+            fields: Arc::new(vec![FieldSchema {
+                name: "uuid_field".to_string(),
+                value_type: EnrichedValueType {
+                    typ: ValueType::Basic(BasicValueType::Uuid),
+                    nullable: false,
+                    attrs: Default::default(),
                 },
-            ]),
+                description: Some(Arc::from("This is a field-level description for UUID")),
+            }]),
         };
 
         let enriched_value_type = EnrichedValueType {
@@ -413,21 +417,35 @@ mod tests {
         };
 
         let result = build_json_schema(enriched_value_type, options).unwrap();
-        
+
         // Check if the description contains both field and type descriptions
         if let Some(properties) = &result.schema.object {
             if let Some(uuid_field_schema) = properties.properties.get("uuid_field") {
                 if let Schema::Object(schema_object) = uuid_field_schema {
-                    if let Some(description) = &schema_object.metadata.as_ref().and_then(|m| m.description.as_ref()) {
+                    if let Some(description) = &schema_object
+                        .metadata
+                        .as_ref()
+                        .and_then(|m| m.description.as_ref())
+                    {
                         // Check if both descriptions are present
-                        assert!(description.contains("This is a field-level description for UUID"), 
-                            "Field-level description not found in: {}", description);
-                        assert!(description.contains("A UUID, e.g. 123e4567-e89b-12d3-a456-426614174000"), 
-                            "Type-level description not found in: {}", description);
-                        
+                        assert!(
+                            description.contains("This is a field-level description for UUID"),
+                            "Field-level description not found in: {}",
+                            description
+                        );
+                        assert!(
+                            description
+                                .contains("A UUID, e.g. 123e4567-e89b-12d3-a456-426614174000"),
+                            "Type-level description not found in: {}",
+                            description
+                        );
+
                         // Check that they are separated by a newline
-                        assert!(description.contains("\n"), 
-                            "Descriptions should be separated by newline: {}", description);
+                        assert!(
+                            description.contains("\n"),
+                            "Descriptions should be separated by newline: {}",
+                            description
+                        );
                     } else {
                         panic!("No description found in the schema");
                     }

src/builder/flow_builder.rs

@@ -364,8 +364,11 @@ impl FlowBuilder {
                 .into_py_result()?;
         }
         let result = Self::last_field_to_data_slice(&self.root_op_scope).into_py_result()?;
-        self.direct_input_fields
-            .push(FieldSchema { name, value_type, description: None });
+        self.direct_input_fields.push(FieldSchema {
+            name,
+            value_type,
+            description: None,
+        });
         Ok(result)
     }