renamed generic to flagGeneric to make naming room for a future

generic processinf function

docs/GenericFunctions.md

@@ -8,7 +8,7 @@ Generic funtions are used in the same manner as their
 [non-generic counterparts](docs/FunctionDescriptions.md). The basic 
 signature looks like that:
 ```sh
-generic(func=<expression>, flag=<flagging_constant>)
+flagGeneric(func=<expression>, flag=<flagging_constant>)
 ```
 where `<expression>` is composed of the [supported constructs](#supported-constructs)
 and `<flag_constant>` is either one of the predefined
@@ -24,9 +24,9 @@ Flag all values of variable `x` when variable `y` falls below a certain threasho
 
 #### Configuration file
 
-| varname | test                  |
-|---------|-----------------------|
-| `x`     | `generic(func=y < 0)` |
+| varname | test                      |
+|---------|---------------------------|
+| `x`     | `flagGeneric(func=y < 0)` |
 
 ### Calculations
 
@@ -35,9 +35,9 @@ Flag all values of variable `x` that exceed 3 standard deviations of variable `y
 
 #### Configuration file
 
-| varname | test                              |
-|---------|-----------------------------------|
-| `x`     | `generic(func=this > std(y) * 3)` |
+| varname | test                                  |
+|---------|---------------------------------------|
+| `x`     | `flagGeneric(func=this > std(y) * 3)` |
 
 ### Special functions
 
@@ -46,9 +46,9 @@ Flag variable `x` where variable `y` is flagged and variable `x` has missing val
 
 #### Configuration file
 
-| varname | test                                              |
-|---------|---------------------------------------------------|
-| `x`     | `generic(func=this > isflagged(y) & ismissing(z)` |
+| varname | test                                                  |
+|---------|-------------------------------------------------------|
+| `x`     | `flagGeneric(func=this > isflagged(y) & ismissing(z)` |
 
 
 ## Variable References
@@ -57,9 +57,9 @@ arbitrary cross references are possible. The variable of intereset
 is furthermore available with the special reference `this`, so the second 
 [example](#calculations) could be rewritten as: 
 
-| varname | test                           |
-|---------|--------------------------------|
-| `x`     | `generic(func=x > std(y) * 3)` |
+| varname | test                               |
+|---------|------------------------------------|
+| `x`     | `flagGeneric(func=x > std(y) * 3)` |
 
 When referencing other variables, their flags will be respected during evaluation
 of the generic expression. So, in the example above only previously

docs/GettingStarted.md

@@ -179,7 +179,7 @@ series. Also, you can write your own tests using a python-based
 
 	varname;test;plot
 	SM2;harmonize_shift2Grid(freq="15Min");False
-	SM2;generic(func=(SM2 < 30));True
+	SM2;flagGeneric(func=(SM2 < 30));True
 
 The above executes an internal framework that harmonizes the timestamps of SM2
 to a 15min-grid (see data below). Further information about this routine can be

saqc/core/config.py

@@ -12,5 +12,5 @@ class Fields:
 
 
 class Params:
-    GENERIC = "generic"
+    FLAG_GENERIC = "flagGeneric"
     FUNC = "func"

saqc/core/evaluator.py

@@ -142,7 +142,7 @@ class ConfigTransformer(ast.NodeTransformer):
 
     def visit_keyword(self, node):
         key, value = node.arg, node.value
-        if self.func_name == Params.GENERIC and key == Params.FUNC:
+        if self.func_name == Params.FLAG_GENERIC and key == Params.FUNC:
             node = ast.keyword(arg=key, value=self.dsl_transformer.visit(value))
             return node
 
@@ -159,8 +159,6 @@ class ConfigTransformer(ast.NodeTransformer):
                 f"unknown variable: {value.id}"
             )
 
-
-
         return self.generic_visit(node)
 
     def generic_visit(self, node):
@@ -200,6 +198,6 @@ def evalExpression(expr, data, field, flagger, nodata=np.nan):
     local_env, code = compileExpression(expr, data_in, field, flagger, nodata)
     data_result, flagger_result = evalCode(code, FUNC_MAP, local_env)
     # NOTE:
-    # reinject the original values, as we don't want to throw away values
+    # reinject the original values, as we don't want to loose them
     data_result[mask] = data[mask]
     return data_result, flagger_result

saqc/funcs/functions.py

@@ -9,7 +9,7 @@ from saqc.lib.tools import sesonalMask, flagWindow
 from saqc.funcs.register import register
 
 
-@register("generic")
+@register("flagGeneric")
 def flagGeneric(data, field, flagger, func, **kwargs):
     # NOTE:
     # - The naming of the func parameter is pretty confusing

test/funcs/test_generic_functions.py

@@ -41,7 +41,7 @@ def test_flagPropagation(data, flagger):
     var2_flags = flagger.isFlagged(var2)
     var2_data = data[var2].mask(var2_flags)
     data, flagger_result = evalExpression(
-        "generic(func=var2 < mean(var2))", data, this, flagger, np.nan
+        "flagGeneric(func=var2 < mean(var2))", data, this, flagger, np.nan
     )
 
     expected = var2_flags | (var2_data < var2_data.mean())
@@ -54,8 +54,8 @@ def test_missingIdentifier(data, flagger):
 
     flagger = flagger.initFlags(data)
     tests = [
-        "generic(func=fff(var2) < 5)",
-        "generic(func=var3 != NODATA)"
+        "flagGeneric(func=fff(var2) < 5)",
+        "flagGeneric(func=var3 != NODATA)"
     ]
     for expr in tests:
         with pytest.raises(NameError):
@@ -80,12 +80,37 @@ def test_comparisonOperators(data, flagger):
     # check within the usually enclosing scope
     for expr, mask in tests:
         _, result_flagger = evalExpression(
-            f"generic(func={expr})", data, this, flagger, np.nan
+            f"flagGeneric(func={expr})", data, this, flagger, np.nan
         )
         expected_flagger = flagger.setFlags(this, loc=mask, test="generic")
         assert np.all(result_flagger.isFlagged() == expected_flagger.isFlagged())
 
 
+# @pytest.mark.parametrize("flagger", TESTFLAGGER)
+# def test_arithmeticOperators(data, flagger):
+#     flagger = flagger.initFlags(data)
+#     var1, *_ = data.columns
+#     this = var1
+
+#     tests = [
+#         ("this + 100", data[this] + 100),
+#         ("this - 100", data[this] - 100),
+#         ("this * 100", data[this] * 100),
+#         ("this / 100", data[this] / 100),
+#         ("this // 2", data[this] // 2),
+#         ("this % 2", data[this] % 2),
+#         ("this ** 2", data[this] ** 2),
+#     ]
+
+#     # check within the usually enclosing scope
+#     for expr, mask in tests:
+#         _, result_flagger = evalExpression(
+#             f"flagGeneric(func={expr})", data, this, flagger, np.nan
+#         )
+#         # expected_flagger = flagger.setFlags(this, loc=mask, test="generic")
+#         # assert np.all(result_flagger.isFlagged() == expected_flagger.isFlagged())
+
+
 @pytest.mark.parametrize("flagger", TESTFLAGGER)
 def test_nonReduncingBuiltins(data, flagger):
     flagger = flagger.initFlags(data)
@@ -155,13 +180,13 @@ def test_bitOps(data, flagger, nodata):
     flagger = flagger.initFlags(data)
 
     tests = [
-        (f"generic(func=~(this > mean(this)))", ~(data[this] > np.nanmean(data[this]))),
+        (f"flagGeneric(func=~(this > mean(this)))", ~(data[this] > np.nanmean(data[this]))),
         (
-            f"generic(func=(this <= 0) | (0 < {var1}))",
+            f"flagGeneric(func=(this <= 0) | (0 < {var1}))",
             (data[this] <= 0) | (0 < data[var1]),
         ),
         (
-            f"generic(func=({var2} >= 0) & (0 > this))",
+            f"flagGeneric(func=({var2} >= 0) & (0 > this))",
             (data[var2] >= 0) & (0 > data[this]),
         ),
     ]