Add new functions: get_calc_props and set_calc_props

- Update unit tests
- Automating dependabot tasks with GitHub Actions

Author: xuri

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/codeql-analysis.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        language: ['go', 'python']
+        language: ['c-cpp', 'go', 'python']
 
     steps:
     - name: Checkout repository

excelize.py

@@ -2735,6 +2735,21 @@ def get_app_props(self) -> Optional[AppProperties]:
             return c_value_to_py(res.opts, AppProperties())
         raise RuntimeError(err)
 
+    def get_calc_props(self) -> Optional[CalcPropsOptions]:
+        """
+        Gets calculation properties.
+
+        Returns:
+            Optional[CalcPropsOptions]: Return the calculation properties if no
+            error occurred, otherwise raise a RuntimeError with the message.
+        """
+        lib.GetCalcProps.restype = types_go._GetCalcPropsResult
+        res = lib.GetCalcProps(self.file_index)
+        err = res.err.decode(ENCODE)
+        if not err:
+            return c_value_to_py(res.opts, CalcPropsOptions())
+        raise RuntimeError(err)
+
     def get_cell_formula(self, sheet: str, cell: str) -> str:
         """
         Get formula from cell by given worksheet name and cell reference in
@@ -4334,6 +4349,26 @@ def set_app_props(self, app_properties: AppProperties) -> None:
         if err != "":
             raise RuntimeError(err)
 
+    def set_calc_props(self, opts: CalcPropsOptions) -> None:
+        """
+        Sets calculation properties. Optional value of `calc_mode` property is:
+        `manual`, `auto` or `autoNoTable`. Optional value of "ref_mode" property
+        is: `A1` or `R1C1`.
+
+        Args:
+            opts (CalcPropsOptions): The calculation properties
+
+        Returns:
+            None: Return None if no error occurred, otherwise raise a
+            RuntimeError with the message.
+        """
+        prepare_args([opts], [argsRule("opts", [CalcPropsOptions])])
+        lib.SetCalcProps.restype = c_char_p
+        options = py_value_to_c(opts, types_go._CalcPropsOptions())
+        err = lib.SetCalcProps(self.file_index, byref(options)).decode(ENCODE)
+        if err != "":
+            raise RuntimeError(err)
+
     def set_cell_bool(self, sheet: str, cell: str, value: bool) -> None:
         """
         Set bool type value of a cell by given worksheet name, cell reference

main.go

@@ -1032,6 +1032,25 @@ func GetAppProps(idx int) C.struct_GetAppPropsResult {
 	return C.struct_GetAppPropsResult{opts: cVal.Elem().Interface().(C.struct_AppProperties), err: C.CString(emptyString)}
 }
 
+// GetCalcProps provides a function to gets calculation properties.
+//
+//export GetCalcProps
+func GetCalcProps(idx int) C.struct_GetCalcPropsResult {
+	f, ok := files.Load(idx)
+	if !ok {
+		return C.struct_GetCalcPropsResult{err: C.CString(errFilePtr)}
+	}
+	opts, err := f.(*excelize.File).GetCalcProps()
+	if err != nil {
+		return C.struct_GetCalcPropsResult{err: C.CString(err.Error())}
+	}
+	cVal, err := goValueToC(reflect.ValueOf(opts), reflect.ValueOf(&C.struct_CalcPropsOptions{}))
+	if err != nil {
+		return C.struct_GetCalcPropsResult{err: C.CString(err.Error())}
+	}
+	return C.struct_GetCalcPropsResult{opts: cVal.Elem().Interface().(C.struct_CalcPropsOptions), err: C.CString(emptyString)}
+}
+
 // GetCellFormula provides a function to get formula from cell by given
 // worksheet name and cell reference in spreadsheet.
 //
@@ -2285,6 +2304,27 @@ func SetAppProps(idx int, opts *C.struct_AppProperties) *C.char {
 	return C.CString(emptyString)
 }
 
+// SetCalcProps provides a function to sets calculation properties. Optional
+// value of "CalcMode" property is: "manual", "auto" or "autoNoTable". Optional
+// value of "RefMode" property is: "A1" or "R1C1".
+//
+//export SetCalcProps
+func SetCalcProps(idx int, opts *C.struct_CalcPropsOptions) *C.char {
+	f, ok := files.Load(idx)
+	if !ok {
+		return C.CString(errFilePtr)
+	}
+	goVal, err := cValueToGo(reflect.ValueOf(*opts), reflect.TypeOf(excelize.CalcPropsOptions{}))
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	props := goVal.Elem().Interface().(excelize.CalcPropsOptions)
+	if err := f.(*excelize.File).SetCalcProps(&props); err != nil {
+		return C.CString(err.Error())
+	}
+	return C.CString(emptyString)
+}
+
 // SetCellBool provides a function to set bool type value of a cell by given
 // worksheet name, cell reference and cell value.
 //

test_excelize.py

@@ -80,6 +80,31 @@ def test_python_compiler_amd64(
     def test_c_value_to_py(self):
         self.assertIsNone(excelize.c_value_to_py(None, None))
 
+    def test_calc_props(self):
+        f = excelize.new_file()
+        opts = excelize.CalcPropsOptions(
+            full_calc_on_load=True,
+            calc_id=122211,
+            concurrent_manual_count=5,
+            iterate_count=10,
+            concurrent_calc=True,
+        )
+        self.assertIsNone(f.set_calc_props(opts))
+        with self.assertRaises(TypeError) as context:
+            f.set_calc_props(0)
+        self.assertEqual(
+            str(context.exception),
+            "expected type CalcPropsOptions for argument 'opts', but got int",
+        )
+        with self.assertRaises(RuntimeError) as context:
+            f.set_calc_props(excelize.CalcPropsOptions(ref_mode="a1"))
+        self.assertEqual(
+            str(context.exception),
+            'invalid RefMode value "a1", acceptable value should be one of A1, R1C1',
+        )
+        self.assertEqual(opts, f.get_calc_props())
+        self.assertIsNone(f.close())
+
     def test_py_value_to_c(self):
         self.assertIsNone(excelize.py_value_to_c(None, None))
 
@@ -901,6 +926,9 @@ def test_none_file_pointer(self):
         with self.assertRaises(RuntimeError) as context:
             f.get_defined_name()
         self.assertEqual(str(context.exception), expected)
+        with self.assertRaises(RuntimeError) as context:
+            f.get_calc_props()
+        self.assertEqual(str(context.exception), expected)
         with self.assertRaises(RuntimeError) as context:
             f.get_sheet_name(0)
         self.assertEqual(str(context.exception), expected)
@@ -2230,7 +2258,7 @@ def test_doc_props(self):
     def test_join_cell_name(self):
         self.assertEqual(excelize.join_cell_name("A", 1), "A1")
         with self.assertRaises(RuntimeError) as context:
-           excelize.join_cell_name("", 0)
+            excelize.join_cell_name("", 0)
         self.assertEqual(str(context.exception), 'invalid column name ""')
         with self.assertRaises(TypeError) as context:
             excelize.join_cell_name(1, 1)

types_c.h

@@ -86,6 +86,25 @@ struct AppProperties
     char *AppVersion;
 };
 
+// CalcPropsOptions defines the collection of properties the application uses to
+// record calculation status and details.
+struct CalcPropsOptions
+{
+    unsigned int *CalcID;
+    char **CalcMode;
+    bool *FullCalcOnLoad;
+    char **RefMode;
+    bool *Iterate;
+    unsigned int *IterateCount;
+    double *IterateDelta;
+    bool *FullPrecision;
+    bool *CalcCompleted;
+    bool *CalcOnSave;
+    bool *ConcurrentCalc;
+    unsigned int *ConcurrentManualCount;
+    bool *ForceFullCalc;
+};
+
 // Cell can be used directly in StreamWriter.SetRow to specify a style and
 // a value.
 struct Cell
@@ -477,7 +496,8 @@ struct ChartMarker
 
 // ChartDataPoint directly maps the format settings of the chart data point for
 // doughnut, pie and 3D pie charts.
-struct ChartDataPoint {
+struct ChartDataPoint
+{
     int Index;
     struct Fill Fill;
 };
@@ -786,6 +806,12 @@ struct IntStringResult
     char *V;
 };
 
+struct GetCalcPropsResult
+{
+    struct CalcPropsOptions opts;
+    char *err;
+};
+
 struct GetCellHyperLinkResult
 {
     bool link;

types_go.py

@@ -61,6 +61,24 @@ class _AppProperties(Structure):
     ]
 
 
+class _CalcPropsOptions(Structure):
+    _fields_ = [
+        ("CalcID", POINTER(c_uint)),
+        ("CalcMode", POINTER(c_char_p)),
+        ("FullCalcOnLoad", POINTER(c_bool)),
+        ("RefMode", POINTER(c_char_p)),
+        ("Iterate", POINTER(c_bool)),
+        ("IterateCount", POINTER(c_uint)),
+        ("IterateDelta", POINTER(c_double)),
+        ("FullPrecision", POINTER(c_bool)),
+        ("CalcCompleted", POINTER(c_bool)),
+        ("CalcOnSave", POINTER(c_bool)),
+        ("ConcurrentCalc", POINTER(c_bool)),
+        ("ConcurrentManualCount", POINTER(c_uint)),
+        ("ForceFullCalc", POINTER(c_bool)),
+    ]
+
+
 class _Cell(Structure):
     _fields_ = [
         ("StyleID", c_int),
@@ -777,6 +795,12 @@ class _GetAppPropsResult(Structure):
         ("err", c_char_p),
     ]
 
+class _GetCalcPropsResult(Structure):
+    _fields_ = [
+        ("opts", _CalcPropsOptions),
+        ("err", c_char_p),
+    ]
+
 
 class _GetCellHyperLinkResult(Structure):
     _fields_ = [

types_py.py

@@ -242,6 +242,23 @@ class AppProperties:
     app_version: str = ""
 
 
+@dataclass
+class CalcPropsOptions:
+    calc_id: Optional[int] = None
+    calc_mode: Optional[str] = None
+    full_calc_on_load: Optional[bool] = None
+    ref_mode: Optional[str] = None
+    iterate: Optional[bool] = None
+    iterate_count: Optional[int] = None
+    iterate_delta: Optional[float] = None
+    full_precision: Optional[bool] = None
+    calc_completed: Optional[bool] = None
+    calc_on_save: Optional[bool] = None
+    concurrent_calc: Optional[bool] = None
+    concurrent_manual_count: Optional[int] = None
+    force_full_calc: Optional[bool] = None
+
+
 @dataclass
 class Cell:
     style_id: int = 0