Merge branch 'develop' into use-pytest-fixtures

Author: quinn-dougherty

src/penn_chime/parameters.py

@@ -8,6 +8,9 @@
 from datetime import date
 from typing import Optional
 
+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
@@ -64,30 +67,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.max_y_axis = max_y_axis
-        self.n_days = n_days
-        self.recovered = recovered
+        self.current_date = Date(value=current_date)
+       
+        self.date_first_hospitalized = OptionalDate(value=date_first_hospitalized)
+        self.doubling_time = OptionalStrictlyPositive(value=doubling_time)
+
+        self.infectious_days = StrictlyPositive(value=infectious_days)
+        self.market_share = Rate(value=market_share)
+        self.max_y_axis = OptionalStrictlyPositive(value=max_y_axis)
+        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,14 @@
+"""the callable validator design pattern"""
+
+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
+# # rolling a custom validator for doubling time in case DS wants to add upper bound
+# DoublingTime = OptionalBounded(lower_bound=0-EPSILON, upper_bound=None)

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,69 @@
+"""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,
+            upper_bound: Optional[float] = None) -> None:
+        assert lower_bound is not None or upper_bound is not None, "Do not use this object to create an unbounded validator."
+        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}",
+        }
+
+    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]).")
+
+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)