formatting conditional statements and list comprehensions

Author: vumichien

python/cocoindex/convert.py

@@ -33,28 +33,38 @@ def _is_ktable_dict(value: dict[Any, Any]) -> bool:
 def encode_engine_value_with_type(value: Any, target_type: Any = None) -> Any:
     """Encode a Python value to an engine value with optional type awareness."""
     # Handle dict-to-struct conversion when target type is a struct
-    if (isinstance(value, dict) and 
-        target_type is not None and 
-        not _is_ktable_dict(value)):
-        
+    if (
+        isinstance(value, dict)
+        and target_type is not None
+        and not _is_ktable_dict(value)
+    ):
         from .typing import analyze_type_info
+
         try:
             type_info = analyze_type_info(target_type)
             if type_info.kind == "Struct" and type_info.struct_type:
                 # Convert dict to struct format
                 if dataclasses.is_dataclass(type_info.struct_type):
                     # Extract values in dataclass field order
                     fields = dataclasses.fields(type_info.struct_type)
-                    return [encode_engine_value_with_type(value.get(f.name), f.type) for f in fields]
+                    return [
+                        encode_engine_value_with_type(value.get(f.name), f.type)
+                        for f in fields
+                    ]
                 elif is_namedtuple_type(type_info.struct_type):
                     # Extract values in namedtuple field order
                     field_names = getattr(type_info.struct_type, "_fields", ())
-                    return [encode_engine_value_with_type(value.get(name), 
-                           type_info.struct_type.__annotations__.get(name)) for name in field_names]
+                    return [
+                        encode_engine_value_with_type(
+                            value.get(name),
+                            type_info.struct_type.__annotations__.get(name),
+                        )
+                        for name in field_names
+                    ]
         except:
             # If type analysis fails, fall back to regular encoding
             pass
-    
+
     return encode_engine_value(value)
 
 
@@ -75,8 +85,7 @@ def encode_engine_value(value: Any) -> Any:
         return [encode_engine_value(v) for v in value]
     if isinstance(value, dict) and _is_ktable_dict(value):
         return [
-            [encode_engine_value(k)] + encode_engine_value(v)
-            for k, v in value.items()
+            [encode_engine_value(k)] + encode_engine_value(v) for k, v in value.items()
         ]
     return value
 
@@ -289,8 +298,10 @@ def _make_engine_struct_value_decoder(
             )
             for name in fields
         }
-    elif dst_struct_type is dict or (hasattr(dst_struct_type, "__origin__") and 
-                                    getattr(dst_struct_type, "__origin__") is dict):
+    elif dst_struct_type is dict or (
+        hasattr(dst_struct_type, "__origin__")
+        and getattr(dst_struct_type, "__origin__") is dict
+    ):
         parameters = {
             f["name"]: inspect.Parameter(
                 name=f["name"],
@@ -330,13 +341,17 @@ def make_closure_for_value(
     field_value_decoder = [
         make_closure_for_value(name, param) for (name, param) in parameters.items()
     ]
-    if dst_struct_type is dict or (hasattr(dst_struct_type, "__origin__") and 
-                                  getattr(dst_struct_type, "__origin__") is dict):
+    if dst_struct_type is dict or (
+        hasattr(dst_struct_type, "__origin__")
+        and getattr(dst_struct_type, "__origin__") is dict
+    ):
+
         def dict_decoder(values: list[Any]) -> dict[str, Any]:
             return {
                 name: decoder(values)
                 for (name, _), decoder in zip(parameters.items(), field_value_decoder)
             }
+
         return dict_decoder
     else:
         return lambda values: dst_struct_type(

python/cocoindex/tests/test_convert.py

@@ -1235,6 +1235,7 @@ def test_dict_struct_encoding() -> None:
     # Test encoding dict as struct - this should only happen in type-aware context
     # For generic encoding, dict is passed through as-is
     from cocoindex.convert import encode_engine_value
+
     dict_value = {"name": "Alice", "age": 30, "city": "New York"}
     result = encode_engine_value(dict_value)
     assert result == {"name": "Alice", "age": 30, "city": "New York"}  # Dict preserved
@@ -1244,13 +1245,13 @@ def test_dict_struct_decoding() -> None:
     # Test decoding to dict as struct
     from cocoindex.convert import _make_engine_struct_value_decoder
     from typing import Dict, Any
-    
+
     src_fields = [
         {"name": "name", "type": {"kind": "Str"}},
         {"name": "age", "type": {"kind": "Int64"}},
         {"name": "city", "type": {"kind": "Str"}},
     ]
-    
+
     decoder = _make_engine_struct_value_decoder([], src_fields, Dict[str, Any])
     result = decoder(["Alice", 30, "New York"])
     assert result == {"name": "Alice", "age": 30, "city": "New York"}
@@ -1259,13 +1260,13 @@ def test_dict_struct_decoding() -> None:
 def test_dict_untyped_struct_decoding() -> None:
     # Test decoding to untyped dict as struct
     from cocoindex.convert import _make_engine_struct_value_decoder
-    
+
     src_fields = [
         {"name": "name", "type": {"kind": "Str"}},
         {"name": "age", "type": {"kind": "Int64"}},
         {"name": "city", "type": {"kind": "Str"}},
     ]
-    
+
     decoder = _make_engine_struct_value_decoder([], src_fields, dict)
     result = decoder(["Alice", 30, "New York"])
     assert result == {"name": "Alice", "age": 30, "city": "New York"}
@@ -1274,19 +1275,19 @@ def test_dict_untyped_struct_decoding() -> None:
 def test_dict_struct_vs_ktable() -> None:
     # Test that dict-as-struct and dict-as-KTable are handled differently
     from cocoindex.convert import encode_engine_value, _is_ktable_dict
-    
+
     # Dict as struct (simple values) - should be passed through in generic encoding
     dict_struct = {"name": "Alice", "age": 30}
     assert not _is_ktable_dict(dict_struct)
     struct_result = encode_engine_value(dict_struct)
     assert struct_result == {"name": "Alice", "age": 30}  # Preserved as dict
-    
+
     # Dict as KTable (struct values)
     @dataclass
     class Person:
         name: str
         age: int
-    
+
     dict_ktable = {"p1": Person("Alice", 30), "p2": Person("Bob", 25)}
     assert _is_ktable_dict(dict_ktable)
     ktable_result = encode_engine_value(dict_ktable)
@@ -1297,15 +1298,15 @@ def test_dict_to_struct_conversion() -> None:
     # Test dict to struct conversion with existing struct types
     from cocoindex.convert import encode_engine_value_with_type
     from dataclasses import dataclass
-    
+
     @dataclass
     class Person:
         name: str
         age: int
         city: str
-    
+
     dict_value = {"name": "Alice", "age": 30, "city": "New York"}
-    
+
     # Test encoding dict as struct
     result = encode_engine_value_with_type(dict_value, Person)
     assert result == ["Alice", 30, "New York"]
@@ -1316,24 +1317,24 @@ def test_struct_to_dict_conversion() -> None:
     from cocoindex.convert import _make_engine_struct_value_decoder
     from dataclasses import dataclass
     from typing import Dict, Any
-    
+
     @dataclass
     class Person:
         name: str
         age: int
         city: str
-    
+
     src_fields = [
         {"name": "name", "type": {"kind": "Str"}},
-        {"name": "age", "type": {"kind": "Int64"}}, 
+        {"name": "age", "type": {"kind": "Int64"}},
         {"name": "city", "type": {"kind": "Str"}},
     ]
-    
+
     # Test decoding struct to dict
     decoder = _make_engine_struct_value_decoder([], src_fields, Dict[str, Any])
     result = decoder(["Alice", 30, "New York"])
     assert result == {"name": "Alice", "age": 30, "city": "New York"}
-    
+
     # Test decoding struct to untyped dict
     decoder = _make_engine_struct_value_decoder([], src_fields, dict)
     result = decoder(["Alice", 30, "New York"])