feat(tests): fix corner cases

Author: bonjourmauko

openfisca_core/indexed_enums/enum_array.py

@@ -21,6 +21,11 @@ class EnumArray(numpy.ndarray):
     # Subclassing ndarray is a little tricky.
     # To read more about the two following methods, see:
     # https://docs.scipy.org/doc/numpy-1.13.0/user/basics.subclassing.html#slightly-more-realistic-example-attribute-added-to-existing-array.
+
+    @property
+    def dtype(self) -> t.ArrayEnum:
+        return super().dtype
+
     def __new__(
         cls,
         input_array: t.Array[t.ArrayEnum],
@@ -84,7 +89,7 @@ def decode(self) -> numpy.object_:
             list(self.possible_values),
         )
 
-    def decode_to_str(self) -> numpy.str_:
+    def decode_to_str(self) -> t.Array[t.ArrayStr]:
         """
         Return the array of string identifiers corresponding to self.
 

openfisca_core/indexed_enums/types.py

@@ -1,3 +1,3 @@
-from openfisca_core.types import Array, ArrayBytes, ArrayEnum
+from openfisca_core.types import Array, ArrayBytes, ArrayEnum, ArrayStr
 
-__all__ = ["Array", "ArrayBytes", "ArrayEnum"]
+__all__ = ["Array", "ArrayBytes", "ArrayEnum", "ArrayStr"]

openfisca_core/tools/test_runner.py

@@ -35,9 +35,9 @@ class Options(TypedDict, total=False):
 
 @dataclasses.dataclass(frozen=True)
 class ErrorMargin:
-    __root__: Dict[Union[str, Literal["default"]], Optional[float]]
+    __root__: Dict[Union[str, Literal["default"]], float]
 
-    def __getitem__(self, key: str) -> Optional[float]:
+    def __getitem__(self, key: str) -> float:
         if key in self.__root__:
             return self.__root__[key]
 
@@ -66,7 +66,7 @@ def build_test(params: Dict[str, Any]) -> Test:
         value = params.get(key)
 
         if value is None:
-            value = {"default": None}
+            value = {"default": 0}
 
         elif isinstance(value, (float, int, str)):
             value = {"default": float(value)}
@@ -326,9 +326,9 @@ def check_variable(
         return assert_near(
             actual_value,
             expected_value,
-            self.test.absolute_error_margin[variable_name],
-            f"{variable_name}@{period}: ",
-            self.test.relative_error_margin[variable_name],
+            message=f"{variable_name}@{period}: ",
+            absolute_error_margin=self.test.absolute_error_margin[variable_name],
+            relative_error_margin=self.test.relative_error_margin[variable_name],
         )
 
     def should_ignore_variable(self, variable_name: str):

openfisca_core/variables/config.py

@@ -27,7 +27,7 @@
         "is_period_size_independent": False,
     },
     str: {
-        "dtype": t.ArrayBytes,
+        "dtype": t.ArrayStr,
         "default": "",
         "json_type": "string",
         "formatted_value_type": "String",

openfisca_core/variables/types.py

@@ -5,6 +5,8 @@
     ArrayEnum,
     ArrayFloat,
     ArrayInt,
+    ArrayObject,
+    ArrayStr,
 )
 
 __any__ = [
@@ -14,4 +16,6 @@
     ArrayEnum,
     ArrayFloat,
     ArrayInt,
+    ArrayObject,
+    ArrayStr,
 ]

openfisca_core/variables/variable.py

@@ -469,7 +469,10 @@ def check_set_value(self, value):
         return value
 
     def default_array(self, array_size):
-        array = numpy.empty(array_size, dtype=self.dtype)
+        if numpy.issubdtype(self.dtype, numpy.datetime64):
+            array = numpy.empty(array_size, dtype="datetime64[D]")
+        else:
+            array = numpy.empty(array_size, dtype=self.dtype)
         if self.value_type == Enum:
             array.fill(self.default_value.index)
             return EnumArray(array, self.possible_values)

openfisca_tasks/lint.mk

@@ -20,7 +20,6 @@ check-style: $(shell git ls-files "*.py" "*.pyi")
 lint-doc: \
 	lint-doc-commons \
 	lint-doc-entities \
-	lint-doc-types \
 	;
 
 ## Run linters to check for syntax and style errors in the doc.
@@ -32,14 +31,22 @@ lint-doc-%:
 	@## able to integrate documentation improvements progresively.
 	@##
 	@$(call print_help,$(subst $*,%,$@:))
-	@flake8 --select=D101,D102,D103,DAR openfisca_core/$* openfisca_test
-	@pylint openfisca_core/$* openfisca_test
+	@flake8 \
+		--select=D101,D102,D103,DAR \
+		openfisca_core/$* \
+		openfisca_core/types.py \
+		openfisca_test \
+		stubs
+	@pylint openfisca_core/$* \
+		openfisca_core/$* \
+		openfisca_core/types.py \
+		openfisca_test \
+		stubs
 	@$(call print_pass,$@:)
 
 ## Run static type checkers for type errors.
 check-types:
 	@$(call print_help,$@:)
-	@command -v pyright && pyright
 	@mypy \
 		openfisca_core/commons \
 		openfisca_core/entities \

openfisca_test/_assertions.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from typing import NoReturn
+
+import numpy
+
+from . import types as t
+from ._parsers import parse
+
+
+def assert_near(
+    actual: object,
+    expected: object,
+    /,
+    message: str = "",
+    *,
+    absolute_error_margin: float = 0,
+    relative_error_margin: float = 0,
+) -> None | NoReturn:
+    """Assert that two values are near each other.
+
+    Args:
+        actual: Value returned by the test.
+        expected: Value that the test should return to pass.
+        message: Error message to be displayed if the test fails.
+        absolute_error_margin: Absolute error margin authorized.
+        relative_error_margin: Relative error margin authorized.
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If the error margin is negative.
+        AssertionError: If the two values are not near each other.
+        NotImplementedError: If the data type is not supported.
+
+    Note:
+        This function cannot be used to assert near periods.
+
+    Examples:
+        >>> actual = numpy.array([1.0, 2.0, 3.0])
+        >>> expected = numpy.array([1.0, 2.0, 2.9])
+        >>> assert_near(actual, expected, absolute_error_margin=0.2)
+
+        >>> expected = numpy.array([1.0, 2.0, 2.95])
+        >>> assert_near(actual, expected, absolute_error_margin=0.1)
+
+        >>> assert_near(actual, expected, relative_error_margin=0.05)
+
+        >>> assert_near(True, [True])
+
+    """
+
+    # Validate absolute_error_margin.
+    if absolute_error_margin < 0:
+        raise ValueError("The absolute error margin must be positive.")
+
+    # Validate relative_error_margin.
+    if relative_error_margin < 0:
+        raise ValueError("The relative error margin must be positive.")
+
+    # Parse the actual value.
+    actual = parse(actual)
+
+    # Parse the expected value.
+    expected = parse(expected)
+
+    # Get the common data type.
+    try:
+        common_dtype = numpy.promote_types(actual.dtype, expected.dtype)
+
+    except TypeError:
+        raise AssertionError(
+            f"Incompatible types: {actual.dtype} and {expected.dtype}."
+        )
+
+    if numpy.issubdtype(common_dtype, numpy.datetime64):
+        actual = actual.astype(t.ArrayDate)
+        expected = expected.astype(t.ArrayDate)
+        assert (actual == expected).all(), f"{message}{actual} differs from {expected}."
+        return None
+
+    if numpy.issubdtype(common_dtype, numpy.bool_):
+        actual = actual.astype(t.ArrayBool)
+        expected = expected.astype(t.ArrayBool)
+        assert (actual == expected).all(), f"{message}{actual} differs from {expected}."
+        return None
+
+    if numpy.issubdtype(common_dtype, numpy.bytes_):
+        actual = actual.astype(t.ArrayBytes)
+        expected = expected.astype(t.ArrayBytes)
+        assert (actual == expected).all(), f"{message}{actual} differs from {expected}."
+        return None
+
+    if numpy.issubdtype(common_dtype, numpy.str_):
+        actual = actual.astype(t.ArrayStr)
+        expected = expected.astype(t.ArrayStr)
+        assert (actual == expected).all(), f"{message}{actual} differs from {expected}."
+        return None
+
+    if numpy.issubdtype(common_dtype, numpy.int32) or numpy.issubdtype(
+        common_dtype, numpy.int64
+    ):
+        actual = actual.astype(t.ArrayInt)
+        expected = expected.astype(t.ArrayInt)
+        diff = abs(expected - actual)
+        assert (
+            diff == 0
+        ).all(), f"{message}{actual} differs from {expected} by {diff}."
+        return None
+
+    if numpy.issubdtype(common_dtype, numpy.float32) or numpy.issubdtype(
+        common_dtype, numpy.float64
+    ):
+        actual = actual.astype(t.ArrayFloat)
+        expected = expected.astype(t.ArrayFloat)
+        diff = abs(expected - actual)
+        if absolute_error_margin > 0:
+            assert (diff <= absolute_error_margin).all(), (
+                f"{message}{actual} differs from {expected} with an absolute margin "
+                f"{diff} > {absolute_error_margin}"
+            )
+            return None
+        if relative_error_margin > 0:
+            assert (diff <= abs(relative_error_margin * expected)).all(), (
+                f"{message}{actual} differs from {expected} with a relative margin "
+                f"{diff} > {abs(relative_error_margin * expected)}"
+            )
+            return None
+        assert (
+            actual == expected
+        ).all(), f"{message}{actual} differs from {expected} by {diff}."
+        return None
+
+    raise NotImplementedError
+
+
+__all__ = ["assert_near"]