ver Jan11th

finally set up a simple task, or which should be simple

desktop_env/evaluators/metrics/__init__.py

@@ -7,3 +7,4 @@ from .pdf import check_pdf_pages
 from .libreoffice import check_libre_locale
 from .vlc import is_vlc_playing, is_vlc_recordings_folder
 from .general import check_csv, check_accessibility_tree, check_list
+from .thunderbird import check_thunderbird_prefs

desktop_env/evaluators/metrics/general.py

@@ -13,7 +13,7 @@ from rapidfuzz import fuzz
 import functools
 import re
 
-def _match_record(pattern: Dict[str, str], item: Dict[str, str]) -> float:
+def _match_record(pattern: Dict[str, str], item: Dict[str, str]) -> bool:
     return all(k in item and item[k]==val for k, val in pattern.items())
 
 def check_csv(result: str, rules: Dict[str, List[Dict[str, str]]]) -> float:

desktop_env/evaluators/metrics/thunderbird.py

@@ -1,43 +1,91 @@
-#from playwright.sync_api import sync_playwright, Browser
-#from marionette_driver.marionette import Marionette
-#import marionette
-#import pyatspi
+from typing import List, Pattern, Dict, Match
+from typing import Union, Any, Optional, Iterable, TypeVar
 
-import lxml.etree
-from lxml.cssselect import CSSSelector
-from lxml.etree import _Element
+import re
+import functools
+import operator
+import json
 
-from typing import List
+import logging
+logger = logging.getLogger("desktopenv.metric.thunderbird")
+
+V = TypeVar("Value")
+
+def _match_pref(value: Any, rule: Dict[str, Union[str, Any]]) -> bool:
+    #  function _match_pref {{{ # 
+    if rule["method"].startswith("re"):
+        flags: List[str] = rule["method"].split(".")[1:]
+        flags: Iterable[re.RegexFlag] = (getattr(re, fl) for fl in flags)
+        flag: re.RegexFlag = functools.reduce(operator.or_, flags, re.RegexFlag(0))
+        logger.debug("REFLAG: %s", repr(flag))
+
+        match_: Optional[Match[str]] = re.search(rule["ref"], value, flag)
+        return match_ is not None
+    if rule["method"] in { "eq", "ne"
+                         , "le", "lt"
+                         , "ge", "gt"
+                         }:
+        return getattr(operator, rule["method"])(value, rule["ref"])
+    raise NotImplementedError()
+    #  }}} function _match_pref # 
+
+_pref_pattern: Pattern[str] = re.compile(r'^user_pref\("(?P<key>(?:[^"]|\\")+)\", (?P<val>.+)\);$');
+def check_thunderbird_prefs(result: str, rule: Dict[str, Dict[str, Dict[str, Any]]]):
+    """
+    Args:
+        result (str): path to result file
+        rule (Dict[str, Dict[str, Dict[str, Any]]]): dict like
+          {
+            "expect": {
+                str: {
+                    "method": str
+                    "ref": something
+                }
+            }
+            "unexpect": {
+                str: {
+                    "method": str
+                    "ref": something
+                }
+            }
+          }
+
+    Returns:
+        float
+    """
+
+    if result is None:
+        return 0.
+
+    expect_rules = rule.get("expect", {})
+    unexpect_rules = rule.get("unexpect", {})
+
+    expect_metrics = {k: False for k in expect_rules}
+    unexpect_metric = True
+    with open(result) as f:
+        for l in f:
+            match_: Match[str] = _pref_pattern.match(l.strip())
+            if match_ is None:
+                continue
+
+            key: str = match_.group("key")
+            #value: str = match_.group("val")
+            #if value in {"true", "false"}:
+                #value = value.title()
+            #value: V = eval(value)
+            value = json.loads(match_.group("val"))
+            if key in expect_rules:
+                logger.debug("K: %s, V: %s", key, repr(value))
+                expect_metrics[key] = _match_pref(value, expect_rules[key])
+            elif key in unexpect_rules:
+                unexpect_metric = unexpect_metric and not _match_pref(value, unexpect_rules[key])
+
+    return float(all(expect_metrics.values()) and unexpect_metric)
 
 if __name__ == "__main__":
-    #with sync_playwright() as plwr:
-        #while True:
-            ##try:
-            #thunderbird: Browser = plwr.firefox.connect("http://127.0.0.1:6000", timeout=60)
-            #break
-            ##except:
-                ##pass
-        #for ctx in thunderbird.contexts:
-            #for p in ctx.pages:
-                #print(p.url)
-
-    #thunderbird = Marionette()
-    #print(thunderbird.start_session())
-    #print(thunderbird.chrome_window_handles)
-    #print(thunderbird.window_handles)
-    #print(thunderbird.current_chrome_window_handle)
-    #thunderbird.set_context(Marionette.CONTEXT_CONTENT)
-    #print(thunderbird.current_window_handle)
-    #thunderbird.switch_to_window(thunderbird.chrome_window_handles[0])
-    #thunderbird.switch_to_default_content()
-    #thunderbird.switch_to_frame()
-    #print(thunderbird.get_url())
-    #print(thunderbird.get_window_type())
-    #thunderbird.fullscreen()
-    #print(thunderbird.close())
-
-    #registry = pyatspi.Registry.get_default()
-    #registry
+    import lxml.etree
+    from lxml.cssselect import CSSSelector
+    from lxml.etree import _Element
 
     #xml = "../../任务数据/Thunderbird/vertical-card-view.xml"
     xml = "../../任务数据/Thunderbird/vertical-table-view.xml"