[#29] Extend Range to support operators

Author: opatrascoiu

README.md

@@ -19,7 +19,7 @@
 
 ### How to run tests
 
-```> tox -e py310``` 
+```> tox -e py312``` 
 or
 ```> python -m pytest --cov=jdmn tests/``` 
 

ci/ci_requirements.txt

@@ -1,7 +1,7 @@
 -r ../requirements.txt
 -r ../requirements.testing.txt
 
-tox>=3.25.1 # Command line driven CI frontend and development task automation tool
+tox>=4.11.3 # Command line driven CI frontend and development task automation tool
 setuptools >= 40.0.4 # build dist
 setuptools_scm >= 2.0.0 # build dist
 wheel >= 0.37.1 # build dist

ci_build.bat

@@ -1,4 +1,4 @@
 call ci/make_env.bat .venv
 
-tox -e py310
+tox -e py312
 tox -e linters

src/jdmn/feel/lib/BaseStandardFEELLib.py

@@ -554,7 +554,7 @@ def is_(self, value1: Any, value2: Any) -> BOOLEAN:
         try:
             if value1 is None or value2 is None:
                 return value1 == value2
-            elif type(value1) != type(value2):
+            elif type(value1) is not type(value2):
                 # Different kind
                 return False
             elif self.isNumber(value1):

src/jdmn/feel/lib/type/ComparableComparator.py

@@ -11,12 +11,13 @@
 # specific language governing permissions and limitations under the License.
 #
 import datetime
+import decimal
 from typing import Union
 
 from jdmn.feel.lib.Types import BOOLEAN
 from jdmn.feel.lib.type.RelationalComparator import RelationalComparator
 
-comparable = Union[float, str, datetime.date, datetime.time, datetime.datetime]
+comparable = Union[decimal.Decimal, str, datetime.date, datetime.time, datetime.datetime, datetime.timedelta]
 
 
 class ComparableComparator(RelationalComparator):

src/jdmn/runtime/Range.py

@@ -10,15 +10,86 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations under the License.
 #
+import datetime
+import decimal
+import typing
 from typing import Any
 
+import isodate
+from jdmn.runtime.DMNRuntimeException import DMNRuntimeException
+
+comparable = typing.Optional[typing.Union[decimal.Decimal, str, datetime.date, datetime.time, datetime.datetime, datetime.timedelta, isodate.Duration]]
+
 
 class Range:
-    def __init__(self, startIncluded: bool, start: Any, endIncluded: bool, end: Any):
-        self.startIncluded = startIncluded
-        self.start = start
-        self.endIncluded = endIncluded
-        self.end = end
+    def __init__(self, *args):
+        if len(args) == 0:
+            self.startIncluded = False
+            self.start = None
+            self.endIncluded = False
+            self.end = None
+            self.operator = None
+        elif len(args) == 4:
+            self.startIncluded = args[0]
+            self.start = args[1]
+            self.endIncluded = args[2]
+            self.end = args[3]
+            self.operator = None
+            # Check if both ends are comparable types
+            if not isinstance(self.start, comparable) or not isinstance(self.end, comparable):
+                raise DMNRuntimeException("Invalid range: start type {} and type {} must be comparable.".format(type(self.start), type(self.end)))
+            if self.start is not None and self.end is not None:
+                # Check if endpoints have same type
+                if type(self.start) is not type(self.end):
+                    raise DMNRuntimeException("Invalid range: start type {} and type {} must be the same.".format(type(self.start), type(self.end)))
+                # Check if start <= end; Duration does not support relational operators
+                if not isinstance(self.start, isodate.Duration) and self.start > self.end:
+                    raise DMNRuntimeException("Invalid range: start {} cannot be greater than end {}.".format(self.start, self.end))
+
+        elif len(args) == 2:
+            self.operator = args[0]
+            if self.operator is None:
+                self.operator = "="
+            if len(self.operator.strip()) == 0:
+                self.operator = "="
+            endpoint = args[1]
+            match self.operator:
+                case "=":
+                    self.startIncluded = True
+                    self.start = endpoint
+                    self.end = endpoint
+                    self.endIncluded = True
+                case "!=":
+                    self.startIncluded = False
+                    self.start = None
+                    self.end = None
+                    self.endIncluded = False
+                case "<":
+                    self.startIncluded = False
+                    self.start = None
+                    self.end = endpoint
+                    self.endIncluded = False
+                case "<=":
+                    self.startIncluded = False
+                    self.start = None
+                    self.end = endpoint
+                    self.endIncluded = True
+                case ">":
+                    self.startIncluded = False
+                    self.start = endpoint
+                    self.end = None
+                    self.endIncluded = False
+                case ">=":
+                    self.startIncluded = True
+                    self.start = endpoint
+                    self.end = None
+                    self.endIncluded = False
+                case _:
+                    raise DMNRuntimeException("Illegal operator '{}'".format(self.operator))
+            if not isinstance(self.start, comparable):
+                raise DMNRuntimeException("Invalid range: endpoint most be comparable {}.".format(type(endpoint)))
+        else:
+            raise DMNRuntimeException("Illegal Range constructor '{}'".format(*args))
 
     def isStartIncluded(self) -> bool:
         return self.startIncluded
@@ -32,6 +103,9 @@ def isEndIncluded(self) -> bool:
     def getEnd(self) -> Any:
         return self.end
 
+    def getOperator(self) -> str:
+        return self.end
+
     def __eq__(self, other: Any) -> bool:
         if self is other:
             return True
@@ -46,6 +120,8 @@ def __eq__(self, other: Any) -> bool:
             return False
         if self.end != other.end:
             return False
+        if self.operator != other.operator:
+            return False
         return True
 
     def __hash__(self):
@@ -54,7 +130,8 @@ def __hash__(self):
         result = 31 * result + (0 if self.start is None else hash(self.start))
         result = 31 * result + (0 if self.endIncluded is None else hash(self.endIncluded))
         result = 31 * result + (0 if self.end is None else hash(self.end))
+        result = 31 * result + (0 if self.operator is None else hash(self.operator))
         return result
 
     def __str__(self):
-        return f"Range({self.startIncluded},{self.start},{self.end},{self.endIncluded})"
+        return "Range({},{},{},{},{})".format(self.startIncluded, self.start, self.end, self.endIncluded, self.operator)

tests/jdmn/feel/lib/FEELOperatorsTest.py

@@ -44,7 +44,7 @@ def testIsNumeric(self):
         self.assertFalse(self.getLib().isNumber(self.getLib().duration("P1Y1M")))
         self.assertFalse(self.getLib().isNumber(self.getLib().asList("a")))
         self.assertFalse(self.getLib().isNumber(Context()))
-        self.assertFalse(self.getLib().isNumber(Range(True, 0, True, 1)))
+        self.assertFalse(self.getLib().isNumber(Range(True, self.makeNumber("0"), True, self.makeNumber("1"))))
 
     def testNumericValue(self):
         self.assertIsNone(self.getLib().numericValue(None))
@@ -175,7 +175,7 @@ def testIsBoolean(self):
         self.assertFalse(self.getLib().isBoolean(self.getLib().duration("P1Y1M")))
         self.assertFalse(self.getLib().isBoolean(self.getLib().asList("a")))
         self.assertFalse(self.getLib().isBoolean(Context()))
-        self.assertFalse(self.getLib().isBoolean(Range(True, 0, True, 1)))
+        self.assertFalse(self.getLib().isBoolean(Range(True, self.makeNumber("0"), True, self.makeNumber("1"))))
 
     def testBooleanValue(self):
         self.assertIsNone(self.getLib().booleanValue(None))
@@ -310,7 +310,7 @@ def testIsString(self):
         self.assertFalse(self.getLib().isString(self.getLib().duration("P1Y1M")))
         self.assertFalse(self.getLib().isString(self.getLib().asList("a")))
         self.assertFalse(self.getLib().isString(Context()))
-        self.assertFalse(self.getLib().isString(Range(True, 0, True, 1)))
+        self.assertFalse(self.getLib().isString(Range(True, "0", True, "1")))
 
     def testStringValue(self):
         self.assertIsNone(self.getLib().stringValue(None))
@@ -362,7 +362,7 @@ def testIsDate(self):
         self.assertFalse(self.getLib().isDate(self.getLib().duration("P1Y1M")))
         self.assertFalse(self.getLib().isDate(self.getLib().asList("a")))
         self.assertFalse(self.getLib().isDate(Context()))
-        self.assertFalse(self.getLib().isDate(Range(True, 0, True, 1)))
+        self.assertFalse(self.getLib().isDate(Range(True, self.makeNumber("0"), True, self.makeNumber("1"))))
 
     def testDateValue(self):
         self.assertIsNone(self.getLib().dateValue(None))
@@ -471,7 +471,7 @@ def testIsTime(self):
         self.assertFalse(self.getLib().isTime(self.getLib().duration("P1Y1M")))
         self.assertFalse(self.getLib().isTime(self.getLib().asList("a")))
         self.assertFalse(self.getLib().isTime(Context()))
-        self.assertFalse(self.getLib().isTime(Range(True, 0, True, 1)))
+        self.assertFalse(self.getLib().isTime(Range(True, self.makeNumber("0"), True, self.makeNumber("1"))))
 
     def testTimeValue(self):
         self.assertIsNone(self.getLib().timeValue(None))
@@ -627,7 +627,7 @@ def testIsDateTime(self):
         self.assertFalse(self.getLib().isDateTime(self.getLib().duration("P1Y1M")))
         self.assertFalse(self.getLib().isDateTime(self.getLib().asList("a")))
         self.assertFalse(self.getLib().isDateTime(Context()))
-        self.assertFalse(self.getLib().isDateTime(Range(True, 0, True, 1)))
+        self.assertFalse(self.getLib().isDateTime(Range(True, self.makeNumber("0"), True, self.makeNumber("1"))))
 
     def testDateTimeValue(self):
         self.assertIsNone(self.getLib().dateTimeValue(None))
@@ -988,7 +988,7 @@ def testIsList(self):
         self.assertFalse(self.getLib().isList(self.getLib().duration("P1Y1M")))
         self.assertTrue(self.getLib().isList(self.getLib().asList("a")))
         self.assertFalse(self.getLib().isList(Context()))
-        self.assertFalse(self.getLib().isList(Range(True, 0, True, 1)))
+        self.assertFalse(self.getLib().isList(Range(True, self.makeNumber("0"), True, self.makeNumber("1"))))
 
     def testListIs(self):
         self.assertTrue(self.getLib().listIs(None, None))
@@ -1028,7 +1028,7 @@ def testIsContext(self):
         self.assertFalse(self.getLib().isContext(self.getLib().duration("P1Y1M")))
         self.assertFalse(self.getLib().isContext(self.getLib().asList("a")))
         self.assertTrue(self.getLib().isContext(Context()))
-        self.assertFalse(self.getLib().isContext(Range(True, 0, True, 1)))
+        self.assertFalse(self.getLib().isContext(Range(True, self.makeNumber("0"), True, self.makeNumber("1"))))
 
     def testContextValue(self):
         c1 = Context()
@@ -1088,7 +1088,7 @@ def testIsRange(self):
         self.assertFalse(self.getLib().isRange(self.getLib().duration("P1Y1M")))
         self.assertFalse(self.getLib().isRange(self.getLib().asList("a")))
         self.assertFalse(self.getLib().isRange(Context()))
-        self.assertTrue(self.getLib().isRange(Range(True, 0, True, 1)))
+        self.assertTrue(self.getLib().isRange(Range(True, self.makeNumber("0"), True, self.makeNumber("1"))))
 
     def testRangeValue(self):
         r1 = Range(True, self.getLib().number("1"), True, self.getLib().number("2"))
@@ -1148,7 +1148,7 @@ def testIsFunction(self):
         self.assertFalse(self.getLib().isFunction(self.getLib().duration("P1Y1M")))
         self.assertFalse(self.getLib().isFunction(self.getLib().asList("a")))
         self.assertFalse(self.getLib().isFunction(Context()))
-        self.assertFalse(self.getLib().isFunction(Range(True, 0, True, 1)))
+        self.assertFalse(self.getLib().isFunction(Range(True, self.makeNumber("0"), True, self.makeNumber("1"))))
 
     def testFunctionValue(self):
         self.assertIsNone(self.getLib().functionValue(None))

tests/jdmn/feel/type/range/RangeTest.py

@@ -0,0 +1,121 @@
+#
+# Copyright 2016 Goldman Sachs.
+#
+# Licensed under the Apache License, Version 2.0 (the "License") you may not use this file except in compliance with the License.
+#
+# You may obtain a copy of the License at
+#     http:#www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations under the License.
+#
+from unittest import TestCase
+
+from jdmn.runtime.Range import Range
+
+from jdmn.runtime.DMNRuntimeException import DMNRuntimeException
+
+from src.jdmn.feel.lib.type.numeric.DefaultNumericLib import DefaultNumericLib
+
+
+class RangeTest(TestCase):
+    """
+    Base test class for Range
+    """
+
+    def testDefaultConstructor(self):
+        r = Range()
+        self.assertFalse(r.startIncluded)
+        self.assertIsNone(r.start)
+        self.assertFalse(r.endIncluded)
+        self.assertIsNone(r.end)
+        self.assertIsNone(r.operator)
+
+    def testConstructorWithEndpoints(self):
+        r = Range(True, self.makeNumber(3), False, self.makeNumber(4))
+        self.assertTrue(r.startIncluded)
+        self.assertEqual(3, r.start)
+        self.assertFalse(r.endIncluded)
+        self.assertEqual(4, r.end)
+        self.assertIsNone(r.operator)
+
+    def testConstructorWithEqualOperator(self):
+        r = Range("=", self.makeNumber(4))
+        self.assertTrue(r.startIncluded)
+        self.assertEqual(4, r.start)
+        self.assertTrue(r.endIncluded)
+        self.assertEqual(4, r.end)
+        self.assertEqual("=", r.operator)
+
+    def testConstructorWithNullOperator(self):
+        r = Range(None, self.makeNumber(4))
+        self.assertTrue(r.startIncluded)
+        self.assertEqual(4, r.start)
+        self.assertTrue(r.endIncluded)
+        self.assertEqual(4, r.end)
+        self.assertEqual("=", r.operator)
+
+    def testConstructorWithEmptyOperator(self):
+        r = Range("  ", self.makeNumber(4))
+        self.assertTrue(r.startIncluded)
+        self.assertEqual(4, r.start)
+        self.assertTrue(r.endIncluded)
+        self.assertEqual(4, r.end)
+        self.assertEqual("=", r.operator)
+
+    def testConstructorWithNotEqualOperator(self):
+        r = Range("!=", self.makeNumber(4))
+        self.assertFalse(r.startIncluded)
+        self.assertIsNone(r.start)
+        self.assertFalse(r.endIncluded)
+        self.assertIsNone(r.end)
+        self.assertEqual("!=", r.operator)
+
+    def testConstructorWithLessOperator(self):
+        r = Range("<", self.makeNumber(4))
+        self.assertFalse(r.startIncluded)
+        self.assertIsNone(r.start)
+        self.assertFalse(r.endIncluded)
+        self.assertEqual(4, r.end)
+        self.assertEqual("<", r.operator)
+
+    def testConstructorWithLessEqualOperator(self):
+        r = Range("<=", self.makeNumber(4))
+        self.assertFalse(r.startIncluded)
+        self.assertIsNone(r.start)
+        self.assertTrue(r.endIncluded)
+        self.assertEqual(4, r.end)
+        self.assertEqual("<=", r.operator)
+
+    def testConstructorWithGreaterOperator(self):
+        r = Range(">", self.makeNumber(4))
+        self.assertFalse(r.startIncluded)
+        self.assertEqual(4, r.start)
+        self.assertFalse(r.endIncluded)
+        self.assertIsNone(r.end)
+        self.assertEqual(">", r.operator)
+
+    def testConstructorWithGreaterEqualOperator(self):
+        r = Range(">=", self.makeNumber(4))
+        self.assertTrue(r.startIncluded)
+        self.assertEqual(4, r.start)
+        self.assertFalse(r.endIncluded)
+        self.assertIsNone(r.end)
+        self.assertEqual(">=", r.operator)
+
+    def testConstructorWithIncorrectEndpoints(self):
+        with self.assertRaises(DMNRuntimeException):
+            Range(True, self.makeNumber(4), False, self.makeNumber(3))
+
+    def testConstructorWithIncorrectOperator(self):
+        with self.assertRaises(DMNRuntimeException):
+            Range("abc", 4)
+
+    def testConstructorWithIncorrectEndpointOperator(self):
+        with self.assertRaises(DMNRuntimeException):
+            Range("=", 4)
+
+    @staticmethod
+    def makeNumber(number: int):
+        return DefaultNumericLib.number(str(number))

tox.ini

@@ -1,12 +1,12 @@
 [tox]
-minversion = 3.25.0
-envlist = py{310}, pylint, flake8, linters
+minversion = 4.11.3
+envlist = py{312}, pylint, flake8, linters
 isolated_build = True
 
 [testenv]
 deps =
-    -Ur{toxinidir}/requirements.txt
-    -Ur{toxinidir}/requirements.testing.txt
+    -r{toxinidir}/requirements.txt
+    -r{toxinidir}/requirements.testing.txt
 commands =
     coverage run -m pytest {posargs}
     coverage report --include src/* --show-missing --fail-under 70