ver Jan23rdv2

added read_cell_value function to load the real value of an exact excel
  cell exactly by the coordinate

desktop_env/evaluators/metrics/utils.py

@@ -34,6 +34,7 @@ _xlsx_namespaces = [ ("oo", "http://schemas.openxmlformats.org/spreadsheetml/200
                    ]
 _xlsx_ns_mapping = dict(_xlsx_namespaces)
 _xlsx_ns_imapping = dict(map(lambda itm: (itm[1], itm[0]), _xlsx_namespaces))
+_xlsx_ns_imapping["http://schemas.openxmlformats.org/spreadsheetml/2006/main"] = None
 _sheet_name_selector = lxml.cssselect.CSSSelector("oo|sheets>oo|sheet", namespaces=_xlsx_ns_mapping)
 _sparklines_selector = lxml.cssselect.CSSSelector("x14|sparkline", namespaces=_xlsx_ns_mapping)
 def load_sparklines(xlsx_file: str, sheet_name: str) -> Dict[str, str]:
@@ -154,6 +155,48 @@ def load_charts(xlsx_file: Workbook, sheet_name: str, **options) -> Dict[str, An
     return chart_set
     #  }}} function load_charts # 
 
+_shared_str_selector = lxml.cssselect.CSSSelector("oo|sst>oo|si>oo|t", namespaces=_xlsx_ns_mapping)
+def read_cell_value(xlsx_file: str, sheet_name: str, coordinate: str) -> Any:
+    #  read_cell_value {{{ # 
+    with zipfile.ZipFile(xlsx_file, "r") as z_f:
+        try:
+            with z_f.open("xl/sharedStrings.xml") as f:
+                shared_str_xml: _Element = lxml.etree.fromstring(f.read())
+                str_elements: List[_Element] = _shared_str_selector(shared_str_xml)
+                shared_strs: List[str] = [elm.text for elm in str_elements]
+        except:
+            logger.debug("Read shared strings error: %s", xlsx_file)
+
+        with z_f.open("xl/workbook.xml") as f:
+            workbook_database: _Element = lxml.etree.fromstring(f.read())
+            sheets: List[_Element] = _sheet_name_selector(workbook_database)
+            sheet_names: Dict[str, str] = {sh.get("name"): sh.get("sheetId") for sh in sheets}
+
+        with z_f.open("xl/worksheets/sheet{:}.xml".format(sheet_names[sheet_name])) as f:
+            sheet: _Element = lxml.etree.fromstring(f.read())
+            cells: List[_Element] =\
+                    lxml.cssselect.CSSSelector( 'oo|row>oo|c[r="{:}"]'.format(coordinate)
+                                              , namespaces=_xlsx_ns_mapping
+                                              )(sheet)
+            if len(cells)==0:
+                return None
+            cell: _Element = cells[0]
+
+    cell: Dict[str, str] = xmltodict.parse( lxml.etree.tostring(cell, encoding="unicode")
+                                          , process_namespaces=True
+                                          , namespaces=_xlsx_ns_imapping
+                                          )
+    logger.debug("%s.%s[%s]: %s", xlsx_file, sheet_name, coordinate, repr(cell))
+    if "@t" not in cell["c"]:
+        return None
+    if cell["c"]["@t"] == "s":
+        return shared_strs[int(cell["c"]["v"])]
+    if cell["c"]["@t"] == "n":
+        return float(cell["c"]["v"])
+    if cell["c"]["@t"] == "str":
+        return cell["c"]["v"]
+    #  }}} read_cell_value # 
+
 # Supported Styles:
 # number_format
 # font_name - str
@@ -311,6 +354,15 @@ def _match_value_to_rule(value: V, rule: Dict[str, Union[str, V]]) -> bool:
                          , "ge", "gt"
                          }:
         return getattr(operator, rule["method"])(value, rule["ref"])
+    if rule["method"].startswith("approx"):
+        threshold: float = float(rule["method"].split(":")[1])
+        logger.debug("Approx: TH%f, REF%f, VAL%s", threshold, rule["ref"], repr(value))
+        try:
+            value = float(value)
+        except (ValueError, TypeError):
+            return False
+        else:
+            return abs(value-rule["ref"])<=threshold
     if rule["method"] == "spreadsheet_range":
         subset_limit = MultiCellRange(rule["ref"][0])
         superset_limit = MultiCellRange(rule["ref"][1])