Optional validators and date validators

Author: quinn-dougherty

src/penn_chime/parameters.py

@@ -8,7 +8,9 @@
 from datetime import date
 from typing import Optional
 
-from .validators import Positive, StrictlyPositive, Rate
+from .validators import (
+    Positive, OptionalStrictlyPositive, StrictlyPositive, Rate, Date, OptionalDate
+    )
 
 # Parameters for each disposition (hospitalized, icu, ventilated)
 #   The rate of disposition within the population of infected
@@ -85,14 +87,14 @@ def __init__(
         else:
             raise AssertionError('population or regions must be provided.')
 
-        self.current_date = current_date
+        self.current_date = Date(value=current_date)
 
-        self.date_first_hospitalized = date_first_hospitalized
+        self.date_first_hospitalized = OptionalDate(value=date_first_hospitalized)
         self.doubling_time = doubling_time
 
         self.infectious_days = StrictlyPositive(value=infectious_days)
         self.market_share = Rate(value=market_share)
-        self.max_y_axis = max_y_axis
+        self.max_y_axis = OptionalStrictlyPositive(value=max_y_axis)
         self.n_days = StrictlyPositive(value=n_days)
         self.recovered = Positive(value=recovered)
 

src/penn_chime/validators/__init__.py

@@ -1,9 +1,12 @@
 """the callable validator design pattern"""
 
-from .validators import Bounded, Rate
+from .validators import Bounded, OptionalBounded, Rate, Date, OptionalDate
 
 EPSILON = 1.e-7
 
+OptionalStrictlyPositive = OptionalBounded(lower_bound=EPSILON)
 StrictlyPositive = Bounded(lower_bound=EPSILON)
 Positive = Bounded(lower_bound=-EPSILON)
 Rate = Rate()  # type: ignore
+Date = Date()  # type: ignore
+OptionalDate = OptionalDate()  # type: ignore

src/penn_chime/validators/validators.py

@@ -1,12 +1,13 @@
 """design pattern via https://youtu.be/S_ipdVNSFlo?t=2153"""
 
 from typing import Optional
+from datetime import date, datetime
 
 from .base import Validator
 
 
 class Bounded(Validator):
-
+    """A bounded number."""
     def __init__(
             self,
             lower_bound: Optional[float] = None,
@@ -21,16 +22,48 @@ def __init__(
         }
 
     def validate(self, value):
+        """This method implicitly validates isinstance(value, (float, int)) because it will throw a TypeError on comparison"""
         if (self.upper_bound is not None and value > self.upper_bound) \
            or (self.lower_bound is not None and value < self.lower_bound):
             raise ValueError(f"{value} needs to be {self.message[(self.lower_bound, self.upper_bound)]}.")
 
 
+class OptionalBounded(Bounded):
+    """a bounded number or a None."""
+    def __init__(
+            self,
+            lower_bound: Optional[float] = None,
+            upper_bound: Optional[float] = None) -> None:
+        super().__init__(lower_bound=lower_bound, upper_bound=upper_bound)
+
+    def validate(self, value):
+        if value is None:
+            return None
+        super().validate(value)
+
 class Rate(Validator):
+    """A rate in [0,1]."""
     def __init__(self) -> None:
         pass
 
     def validate(self, value):
         if 0 >= value or value >= 1:
-            raise ValueError(f"{value} needs to be a rate (i.e. in [0,1])")
+            raise ValueError(f"{value} needs to be a rate (i.e. in [0,1]).")
 
+class Date(Validator):
+    """A date of some sort."""
+    def __init__(self) -> None:
+        pass
+
+    def validate(self, value):
+        if not isinstance(value, (date, datetime)):
+            raise (ValueError(f"{value} must be a date or datetime object."))
+
+class OptionalDate(Date):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def validate(self, value):
+        if value is None:
+            return None
+        super().validate(value)