Add 2 new functions: get_custom_props and set_custom_props

- Update unit tests
- Made functions set_row, set_sheet_col and set_sheet_row function accept float data type value
- Rename CodeQL config

Author: xuri

.github/workflows/codeql-analysis.yml .github/workflows/codeql.yml.github/workflows/codeql-analysis.yml renamed to .github/workflows/codeql.yml

@@ -21,6 +21,7 @@
     c_char,
     c_double,
     c_int,
+    c_int32,
     c_longlong,
     c_ubyte,
     cast,
@@ -452,19 +453,48 @@ def py_value_to_c_interface(py_value):
     """
     type_mappings = {
         int: lambda: Interface(type=1, integer=py_value),
-        str: lambda: Interface(type=2, string=py_value),
-        float: lambda: Interface(type=3, float64=py_value),
-        bool: lambda: Interface(type=4, boolean=py_value),
-        datetime: lambda: Interface(type=5, integer=int(py_value.timestamp())),
+        str: lambda: Interface(type=3, string=py_value),
+        float: lambda: Interface(type=4, float64=py_value),
+        bool: lambda: Interface(type=5, boolean=py_value),
+        datetime: lambda: Interface(type=6, integer=int(py_value.timestamp())),
         date: lambda: Interface(
-            type=5,
+            type=6,
             integer=int(datetime.combine(py_value, time.min).timestamp()),
         ),
     }
     interface = type_mappings.get(type(py_value), Interface)()
     return py_value_to_c(interface, types_go._Interface())
 
 
+def c_value_to_py_interface(c_value):
+    """
+    Converts a C value to a Python interface representation.
+
+    Args:
+        c_value: The C value to be converted.
+
+    Returns:
+        An Interface object representing the C value in a Python-compatible format.
+
+    Raises:
+        TypeError: If the type of c_value is not supported.
+    """
+    if c_value is None:
+        return None
+    type_mappings = {
+        1: lambda: c_value.Integer,
+        2: lambda: c_value.Integer32,
+        3: lambda: c_value.String.decode(ENCODE) if c_value.String else "",
+        4: lambda: c_value.Float64,
+        5: lambda: c_value.Boolean,
+        6: lambda: datetime.fromtimestamp(c_value.Integer),
+    }
+    converter = type_mappings.get(c_value.Type)
+    if converter:
+        return converter()
+    raise TypeError(f"unsupported interface type code: {c_value.Type}")
+
+
 def prepare_args(args: List, types: List[argsRule]):
     """
     Validate arguments against expected types.
@@ -785,7 +815,7 @@ def set_panes(self, opts: Panes) -> None:
     def set_row(
         self,
         cell: str,
-        values: List[Union[None, int, str, bool, datetime, date]],
+        values: List[Union[bool, float, int, str, date, datetime, None]],
     ) -> None:
         """
         Writes an array to stream rows by giving starting cell reference and a
@@ -794,8 +824,8 @@ def set_row(
 
         Args:
             cell (str): The cell reference
-            values (List[Union[None, int, str, bool, datetime, date]]): The cell
-            values
+            values (List[Union[bool, float, int, str, date, datetime, None]]):
+            The cell values
 
         Returns:
             None: Return None if no error occurred, otherwise raise a
@@ -3054,6 +3084,30 @@ def get_comments(self, sheet: str) -> List[Comment]:
                 raise RuntimeError(err)
         return result.comments if result and result.comments else []
 
+    def get_custom_props(self) -> List[CustomProperty]:
+        """
+        Get custom file properties
+
+        Returns:
+            List[CustomProperty]: Return the custom file properties if no error
+            occurred, otherwise raise a RuntimeError with the message.
+        """
+        lib.GetCustomProps.restype = types_go._GetCustomPropsResult
+        res = lib.GetCustomProps(self.file_index)
+        err = res.Err.decode(ENCODE)
+        if err == "":
+            arr = []
+            if res.CustomProps:
+                for i in range(res.CustomPropsLen):
+                    arr.append(
+                        CustomProperty(
+                            name=res.CustomProps[i].Name.decode(ENCODE),
+                            value=c_value_to_py_interface(res.CustomProps[i].Value),
+                        )
+                    )
+            return arr
+        raise RuntimeError(err)
+
     def get_default_font(self) -> str:
         """
         Get the default font name currently set in the workbook. The spreadsheet
@@ -5148,6 +5202,37 @@ def set_conditional_format(
         if err != "":
             raise RuntimeError(err)
 
+    def set_custom_props(self, prop: CustomProperty) -> None:
+        """
+        Set custom file properties by given property name and value. If the
+        property name already exists, it will be updated, otherwise a new
+        property will be added. The value can be of type `int`, `float`, `bool`,
+        `str`, `datetime`, `date` and `None`. The property will be delete if the
+        value is `None`. The function returns an error if the property value is
+        not of the correct type.
+
+        Args:
+            prop (CustomProperty): The custom file property
+
+        Returns:
+            None: Return None if no error occurred, otherwise raise a
+            RuntimeError with the message.
+        """
+        prepare_args([prop], [argsRule("prop", [CustomProperty])])
+        lib.SetCustomProps.restype = c_char_p
+        options = types_go._CustomProperty()
+        setattr(options, "Name", (prop.name or "").encode(ENCODE))
+        val = types_go._Interface()
+        if type(prop.value) is int:
+            setattr(val, "Type", c_int(2))
+            setattr(val, "Integer32", c_int32(prop.value))
+        else:
+            val = py_value_to_c_interface(prop.value)
+        setattr(options, "Value", val)
+        err = lib.SetCustomProps(self.file_index, options).decode(ENCODE)
+        if err != "":
+            raise RuntimeError(err)
+
     def set_default_font(self, font_name: str) -> None:
         """
         Set the default font name in the workbook. The spreadsheet generated by
@@ -5216,10 +5301,7 @@ def set_defined_name(self, defined_name: DefinedName) -> None:
             ))
             ```
         """
-        prepare_args(
-            [defined_name],
-            [argsRule("defined_name", [DefinedName])],
-        )
+        prepare_args([defined_name], [argsRule("defined_name", [DefinedName])])
         lib.SetDefinedName.restype = c_char_p
         options = py_value_to_c(defined_name, types_go._DefinedName())
         err = lib.SetDefinedName(self.file_index, byref(options)).decode(ENCODE)
@@ -5645,7 +5727,7 @@ def set_sheet_col(
         self,
         sheet: str,
         cell: str,
-        values: List[Union[None, int, str, bool, datetime, date]],
+        values: List[Union[bool, float, int, str, date, datetime, None]],
     ) -> None:
         """
         Writes cells to column by given worksheet name, starting cell reference
@@ -5654,8 +5736,8 @@ def set_sheet_col(
         Args:
             sheet (str): The worksheet name
             cell (str): The cell reference
-            values (List[Union[None, int, str, bool, datetime, date]]): The cell
-            values
+            values (List[Union[bool, float, int, str, date, datetime, None]):
+            The cell values
 
         Returns:
             None: Return None if no error occurred, otherwise raise a
@@ -5780,7 +5862,7 @@ def set_sheet_row(
         self,
         sheet: str,
         cell: str,
-        values: List[Union[None, int, str, bool, datetime, date]],
+        values: List[Union[bool, float, int, str, date, datetime, None]],
     ) -> None:
         """
         Writes cells to row by given worksheet name, starting cell reference and
@@ -5789,8 +5871,8 @@ def set_sheet_row(
         Args:
             sheet (str): The worksheet name
             cell (str): The cell reference
-            values (List[Union[None, int, str, bool, datetime, date]]): The cell
-            values
+            values (List[Union[bool, float, int, str, date, datetime, None]]):
+            The cell values
 
         Returns:
             None: Return None if no error occurred, otherwise raise a

excelize.py

@@ -45,10 +45,11 @@ type GetRowsResult struct {
 const (
 	Nil     C.int = 0
 	Int     C.int = 1
-	String  C.int = 2
-	Float   C.int = 3
-	Boolean C.int = 4
-	Time    C.int = 5
+	Int32   C.int = 2
+	String  C.int = 3
+	Float   C.int = 4
+	Boolean C.int = 5
+	Time    C.int = 6
 )
 
 var (
@@ -433,6 +434,8 @@ func cInterfaceToGo(val C.struct_Interface) interface{} {
 	switch val.Type {
 	case Int:
 		return int(val.Integer)
+	case Int32:
+		return int32(val.Integer32)
 	case String:
 		return C.GoString(val.String)
 	case Float:
@@ -446,6 +449,26 @@ func cInterfaceToGo(val C.struct_Interface) interface{} {
 	}
 }
 
+// goInterfaceToC convert Go interface to C interface data type value.
+func goInterfaceToC(val interface{}) C.struct_Interface {
+	switch v := val.(type) {
+	case int:
+		return C.struct_Interface{Type: Int, Integer: C.int(v)}
+	case int32:
+		return C.struct_Interface{Type: Int32, Integer32: C.int(v)}
+	case string:
+		return C.struct_Interface{Type: String, String: C.CString(v)}
+	case float64:
+		return C.struct_Interface{Type: Float, Float64: C.double(v)}
+	case bool:
+		return C.struct_Interface{Type: Boolean, Boolean: C._Bool(v)}
+	case time.Time:
+		return C.struct_Interface{Type: Time, Integer: C.int(v.Unix())}
+	default:
+		return C.struct_Interface{Type: Nil}
+	}
+}
+
 // AddChart provides the method to add chart in a sheet by given chart format
 // set (such as offset, scale, aspect ratio setting and print settings) and
 // properties set.
@@ -1240,6 +1263,26 @@ func GetComments(idx int, sheet *C.char) C.struct_GetCommentsResult {
 	return C.struct_GetCommentsResult{CommentsLen: C.int(len(comments)), Comments: (*C.struct_Comment)(cArray), Err: C.CString(emptyString)}
 }
 
+// GetCustomProps provides a function to get custom file properties.
+//
+//export GetCustomProps
+func GetCustomProps(idx int) C.struct_GetCustomPropsResult {
+	f, ok := files.Load(idx)
+	if !ok {
+		return C.struct_GetCustomPropsResult{Err: C.CString(errFilePtr)}
+	}
+	props, err := f.(*excelize.File).GetCustomProps()
+	if err != nil {
+		return C.struct_GetCustomPropsResult{Err: C.CString(err.Error())}
+	}
+	cArray := C.malloc(C.size_t(len(props)) * C.size_t(unsafe.Sizeof(C.struct_CustomProperty{})))
+	for i, prop := range props {
+		cVal := C.struct_CustomProperty{Name: C.CString(prop.Name), Value: goInterfaceToC(prop.Value)}
+		*(*C.struct_CustomProperty)(unsafe.Pointer(uintptr(unsafe.Pointer(cArray)) + uintptr(i)*unsafe.Sizeof(C.struct_CustomProperty{}))) = cVal
+	}
+	return C.struct_GetCustomPropsResult{CustomPropsLen: C.int(len(props)), CustomProps: (*C.struct_CustomProperty)(cArray), Err: C.CString(emptyString)}
+}
+
 // GetDefaultFont provides the default font name currently set in the
 // workbook. The spreadsheet generated by excelize default font is Calibri.
 //
@@ -2585,6 +2628,27 @@ func SetConditionalFormat(idx int, sheet, rangeRef *C.char, opts *C.struct_Condi
 	return C.CString(emptyString)
 }
 
+// SetCustomProps provides a function to set custom file properties by given
+// property name and value. If the property name already exists, it will be
+// updated, otherwise a new property will be added. The value can be of type
+// int32, float64, bool, string, time.Time or nil. The property will be delete
+// if the value is nil. The function returns an error if the property value is
+// not of the correct type.
+//
+//export SetCustomProps
+func SetCustomProps(idx int, prop C.struct_CustomProperty) *C.char {
+	f, ok := files.Load(idx)
+	if !ok {
+		return C.CString(errFilePtr)
+	}
+	if err := f.(*excelize.File).SetCustomProps(excelize.CustomProperty{
+		Name: C.GoString(prop.Name), Value: cInterfaceToGo(prop.Value),
+	}); err != nil {
+		return C.CString(err.Error())
+	}
+	return C.CString(emptyString)
+}
+
 // SetDefaultFont provides the default font name currently set in the
 // workbook. The spreadsheet generated by excelize default font is Calibri.
 //

main.go

@@ -23,6 +23,7 @@
 )
 import os
 import excelize
+import types_go
 from types_py import argsRule
 
 
@@ -920,6 +921,9 @@ def test_none_file_pointer(self):
         with self.assertRaises(RuntimeError) as context:
             f.get_app_props()
         self.assertEqual(str(context.exception), expected)
+        with self.assertRaises(RuntimeError) as context:
+            f.get_custom_props()
+        self.assertEqual(str(context.exception), expected)
         with self.assertRaises(RuntimeError) as context:
             f.get_default_font()
         self.assertEqual(str(context.exception), expected)
@@ -929,6 +933,9 @@ def test_none_file_pointer(self):
         with self.assertRaises(RuntimeError) as context:
             f.get_calc_props()
         self.assertEqual(str(context.exception), expected)
+        with self.assertRaises(RuntimeError) as context:
+            f.set_custom_props(excelize.CustomProperty(name="Prop", value=""))
+        self.assertEqual(str(context.exception), expected)
         with self.assertRaises(RuntimeError) as context:
             f.get_sheet_name(0)
         self.assertEqual(str(context.exception), expected)
@@ -2143,6 +2150,34 @@ def test_column_number_to_name(self):
             "expected type int for argument 'num', but got str",
         )
 
+    def test_custom_props(self):
+        f = excelize.new_file()
+        props = [
+            excelize.CustomProperty(name="Text Prop", value="text"),
+            excelize.CustomProperty(name="Boolean Prop 1", value=True),
+            excelize.CustomProperty(name="Boolean Prop 2", value=False),
+            excelize.CustomProperty(name="Number Prop 1", value=-123.456),
+            excelize.CustomProperty(name="Number Prop 2", value=1),
+            excelize.CustomProperty(
+                name="Date Prop", value=datetime.datetime(2016, 8, 30, 11, 51, 0)
+            ),
+        ]
+        for prop in props:
+            f.set_custom_props(prop)
+        self.assertEqual(props, f.get_custom_props())
+
+        with self.assertRaises(RuntimeError) as context:
+            f.set_custom_props(excelize.CustomProperty(name=None, value=1))
+        self.assertEqual(str(context.exception), "parameter is invalid")
+        with self.assertRaises(TypeError) as context:
+            f.set_custom_props(1)
+        self.assertEqual(
+            str(context.exception),
+            "expected type CustomProperty for argument 'prop', but got int",
+        )
+        self.assertIsNone(f.save_as(os.path.join("test", "TestSetCustomProps.xlsx")))
+        self.assertIsNone(f.close())
+
     def test_add_picture(self):
         f = excelize.new_file()
         self.assertIsNone(f.add_picture("Sheet1", "A1", "chart.png", None))
@@ -2491,3 +2526,12 @@ class T1:
         self.assertEqual(
             excelize.c_value_to_py(excelize.py_value_to_c(t1, _T1()), T1()), t1
         )
+        self.assertIsNone(excelize.c_value_to_py_interface(None))
+        with self.assertRaises(TypeError) as context:
+            val = types_go._Interface()
+            setattr(val, "Type", c_int(-1))
+            excelize.c_value_to_py_interface(val)
+        self.assertEqual(
+            str(context.exception),
+            "unsupported interface type code: -1",
+        )