the callable validator design pattern

Author: quinn-dougherty

src/penn_chime/parameters.py

@@ -8,6 +8,7 @@
 from datetime import date
 from typing import Optional
 
+from .validators import Positive, StrictlyPositive, Rate
 
 # Parameters for each disposition (hospitalized, icu, ventilated)
 #   The rate of disposition within the population of infected
@@ -64,30 +65,36 @@ def __init__(
         recovered: int = 0,
         region: Optional[Regions] = None,
     ):
-        self.current_hospitalized = current_hospitalized
-        self.relative_contact_rate = relative_contact_rate
+        self.current_hospitalized = StrictlyPositive(value=current_hospitalized)
+        self.relative_contact_rate = Rate(value=relative_contact_rate)
+
+        Rate(value=hospitalized.rate), Rate(value=icu.rate), Rate(value=ventilated.rate)
+        StrictlyPositive(value=hospitalized.days), StrictlyPositive(value=icu.days),
+        StrictlyPositive(value=ventilated.days)
 
         self.hospitalized = hospitalized
         self.icu = icu
         self.ventilated = ventilated
 
         if region is not None and population is None:
             self.region = region
-            self.population = region.population
+            self.population = StrictlyPositive(value=region.population)
         elif population is not None:
             self.region = None
-            self.population = population
+            self.population = StrictlyPositive(value=population)
         else:
             raise AssertionError('population or regions must be provided.')
 
         self.current_date = current_date
+       
         self.date_first_hospitalized = date_first_hospitalized
         self.doubling_time = doubling_time
-        self.infectious_days = infectious_days
-        self.market_share = market_share
+
+        self.infectious_days = StrictlyPositive(value=infectious_days)
+        self.market_share = Rate(value=market_share)
         self.max_y_axis = max_y_axis
-        self.n_days = n_days
-        self.recovered = recovered
+        self.n_days = StrictlyPositive(value=n_days)
+        self.recovered = Positive(value=recovered)
 
         self.labels = {
             "hospitalized": "Hospitalized",

src/penn_chime/validators/__init__.py

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

src/penn_chime/validators/base.py

@@ -0,0 +1,15 @@
+"""design pattern via https://youtu.be/S_ipdVNSFlo?t=2153, modified such that validators are _callable_"""
+
+from abc import ABC, abstractmethod
+
+class Validator(ABC):
+    def __set_name__(self, owner, name):
+        self.private_name = f"_{name}"
+
+    def __call__(self, *, value):
+        self.validate(value)
+        return value
+
+    @abstractmethod
+    def validate(self, value):
+        pass

src/penn_chime/validators/validators.py

@@ -0,0 +1,36 @@
+"""design pattern via https://youtu.be/S_ipdVNSFlo?t=2153"""
+
+from typing import Optional
+
+from .base import Validator
+
+
+class Bounded(Validator):
+
+    def __init__(
+            self,
+            lower_bound: Optional[float] = None,
+            upper_bound: Optional[float] = None) -> None:
+        self.lower_bound = lower_bound
+        self.upper_bound = upper_bound
+        self.message = {
+            (lower_bound, upper_bound): f"in ({self.lower_bound}, {self.upper_bound})",
+            (None, upper_bound): f"less than {self.upper_bound}",
+            (lower_bound, None): f"greater than {self.lower_bound}",
+            (None, None): "ACTUALLY the value is unbounded"
+        }
+
+    def validate(self, value):
+        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 Rate(Validator):
+    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])")
+