Merge pull request #212 from launchdarkly/eb/sc-181822/preprocess-values

preprocess clause values for time/regex/semver operators

Author: eli-darkly

ldclient/impl/evaluator.py

@@ -202,10 +202,8 @@ def _rule_matches_context(self, rule: FlagRule, context: Context, state: EvalRes
         return True
 
     def _clause_matches_context(self, clause: Clause, context: Context, state: EvalResult) -> bool:
-        op = clause.op
-        clause_values = clause.values
-        if op == 'segmentMatch':
-            for seg_key in clause_values:
+        if clause.op == 'segmentMatch':
+            for seg_key in clause.values:
                 segment = self.__get_segment(seg_key)
                 if segment is not None and self._segment_matches_context(segment, context, state):
                     return _maybe_negate(clause, True)
@@ -226,10 +224,10 @@ def _clause_matches_context(self, clause: Clause, context: Context, state: EvalR
         # is the attr an array?
         if isinstance(context_value, (list, tuple)):
             for v in context_value:
-                if _match_single_context_value(op, v, clause_values):
+                if _match_single_context_value(clause, v):
                     return _maybe_negate(clause, True)
             return _maybe_negate(clause, False)
-        return _maybe_negate(clause, _match_single_context_value(op, context_value, clause_values))
+        return _maybe_negate(clause, _match_single_context_value(clause, context_value))
 
     def _segment_matches_context(self, segment: Segment, context: Context, state: EvalResult) -> bool:
         if state.segment_stack is not None and segment.key in state.segment_stack:
@@ -447,23 +445,24 @@ def _get_context_value_by_attr_ref(context: Context, attr: AttributeRef) -> Any:
         i += 1
     return value
 
-def _match_single_context_value(op: str, context_value: Any, values: List[Any]) -> bool:
-    op_fn = operators.ops.get(op)
+def _match_single_context_value(clause: Clause, context_value: Any) -> bool:
+    op_fn = operators.ops.get(clause.op)
     if op_fn is None:
         return False
-    for v in values:
-        if op_fn(context_value, v):
+    values_preprocessed = clause.values_preprocessed
+    for i, v in enumerate(clause.values):
+        preprocessed = None if values_preprocessed is None else values_preprocessed[i]
+        if op_fn(context_value, v, preprocessed):
             return True
     return False
 
 def _match_clause_by_kind(clause: Clause, context: Context) -> bool:
     # If attribute is "kind", then we treat operator and values as a match expression against a list
     # of all individual kinds in the context. That is, for a multi-kind context with kinds of "org"
     # and "user", it is a match if either of those strings is a match with Operator and Values.
-    op = clause.op
     for i in range(context.individual_context_count):
         c = context.get_individual_context(i)
-        if c is not None and _match_single_context_value(op, c.kind, clause.values):
+        if c is not None and _match_single_context_value(clause, c.kind):
             return True
     return False
 

ldclient/impl/model/clause.py

@@ -1,17 +1,52 @@
+from re import Pattern
+from semver import VersionInfo
 from typing import Any, List, Optional
 
 from ldclient.impl.model.attribute_ref import AttributeRef, req_attr_ref_with_opt_context_kind
 from ldclient.impl.model.entity import *
+from ldclient.impl.model.value_parsing import parse_regex, parse_semver, parse_time
 
+class ClausePreprocessedValue:
+    __slots__ = ['_as_time', '_as_regex', '_as_semver']
+
+    def __init__(self, as_time: Optional[float]=None, as_regex: Optional[Pattern]=None, as_semver: Optional[VersionInfo]=None):
+        self._as_time = as_time
+        self._as_regex = as_regex
+        self._as_semver = as_semver
+    
+    @property
+    def as_time(self) -> Optional[float]:
+        return self._as_time
+    
+    @property
+    def as_regex(self) -> Optional[Pattern]:
+        return self._as_regex
+    
+    @property
+    def as_semver(self) -> Optional[VersionInfo]:
+        return self._as_semver
+
+
+def _preprocess_clause_values(op: str, values: List[Any]) -> Optional[List[ClausePreprocessedValue]]:
+    if op == 'matches':
+        return list(ClausePreprocessedValue(as_regex=parse_regex(value)) for value in values)
+    if op == 'before' or op == 'after':
+        return list(ClausePreprocessedValue(as_time=parse_time(value)) for value in values)
+    if op == 'semVerEqual' or op == 'semVerGreaterThan' or op == 'semVerLessThan':
+        return list(ClausePreprocessedValue(as_semver=parse_semver(value)) for value in values)
+    return None
+
+    
 class Clause:
-    __slots__ = ['_context_kind', '_attribute', '_op', '_values', '_negate']
+    __slots__ = ['_context_kind', '_attribute', '_op', '_negate', '_values', '_values_preprocessed']
 
     def __init__(self, data: dict):
         self._context_kind = opt_str(data, 'contextKind')
         self._attribute = req_attr_ref_with_opt_context_kind(req_str(data, 'attribute'), self._context_kind)
         self._negate = opt_bool(data, 'negate')
         self._op = req_str(data, 'op')
         self._values = req_list(data, 'values')
+        self._values_preprocessed = _preprocess_clause_values(self._op, self._values)
 
     @property
     def attribute(self) -> AttributeRef:
@@ -32,3 +67,7 @@ def op(self) -> str:
     @property
     def values(self) -> List[Any]:
         return self._values
+
+    @property
+    def values_preprocessed(self) -> Optional[List[ClausePreprocessedValue]]:
+        return self._values_preprocessed

ldclient/impl/model/value_parsing.py

@@ -0,0 +1,85 @@
+import re
+from re import Pattern
+from semver import VersionInfo
+from datetime import tzinfo, timedelta, datetime
+from numbers import Number
+from typing import Any, Optional
+
+import pyrfc3339
+
+_ZERO = timedelta(0)
+
+# A UTC class.
+
+class _UTC(tzinfo):
+    """UTC"""
+
+    def utcoffset(self, dt):
+        return _ZERO
+
+    def tzname(self, dt):
+        return "UTC"
+
+    def dst(self, dt):
+        return _ZERO
+
+_epoch = datetime.utcfromtimestamp(0).replace(tzinfo=_UTC())
+
+
+def is_number(input: Any) -> bool:
+    # bool is a subtype of int, and we don't want to try and treat it as a number.
+    return isinstance(input, Number) and not isinstance(input, bool)
+
+
+def parse_regex(input: Any) -> Optional[Pattern]:
+    if isinstance(input, str):
+        try:
+            return re.compile(input)
+        except Exception:
+            return None
+    return None
+
+
+def parse_time(input: Any) -> Optional[float]:
+    """
+    :param input: Either a number as milliseconds since Unix Epoch, or a string as a valid RFC3339 timestamp
+    :return: milliseconds since Unix epoch, or None if input was invalid.
+    """
+
+    if is_number(input):
+        return float(input)
+
+    if isinstance(input, str):
+        try:
+            parsed_time = pyrfc3339.parse(input)
+            timestamp = (parsed_time - _epoch).total_seconds()
+            return timestamp * 1000.0
+        except Exception as e:
+            return None
+
+    return None
+
+def parse_semver(input: Any) -> Optional[VersionInfo]:
+    if not isinstance(input, str):
+        return None
+    try:
+        return VersionInfo.parse(input)
+    except TypeError:
+        return None
+    except ValueError as e:
+        try:
+            input = _add_zero_version_component(input)
+            return VersionInfo.parse(input)
+        except ValueError as e:
+            try:
+                input = _add_zero_version_component(input)
+                return VersionInfo.parse(input)
+                return input
+            except ValueError as e:
+                return None
+
+def _add_zero_version_component(input):
+    m = re.search("^([0-9.]*)(.*)", input)
+    if m is None:
+        return input + ".0"
+    return m.group(1) + ".0" + m.group(2)