Fix typing

Author: bonjourmauko

openfisca_core/periods/_config.py

@@ -6,4 +6,4 @@
 
 # Matches "2015", "2015-01", "2015-01-01"
 # Does not match "2015-13", "2015-12-32"
-INSTANT_PATTERN: Pattern = re.compile(r"^\d{4}(-(0[1-9]|1[012]))?(-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01]))?$")
+INSTANT_PATTERN: Pattern[str] = re.compile(r"^\d{4}(-(0[1-9]|1[012]))?(-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01]))?$")

openfisca_core/periods/_funcs.py

@@ -59,28 +59,25 @@ def build_instant(value: Any) -> Optional[types.Instant]:
     if isinstance(value, Instant):
         return value
 
-    if isinstance(value, str):
-        if not INSTANT_PATTERN.match(value):
-            raise InstantFormatError(value)
+    if isinstance(value, Period):
+        return value.start
 
-        instant = Instant(
-            int(fragment)
-            for fragment in value.split('-', 2)[:3]
-            )
+    if isinstance(value, str) and not INSTANT_PATTERN.match(value):
+        raise InstantFormatError(value)
+
+    if isinstance(value, str):
+        instant = tuple(int(fragment) for fragment in value.split('-', 2)[:3])
 
     elif isinstance(value, datetime.date):
-        instant = Instant((value.year, value.month, value.day))
+        instant = value.year, value.month, value.day
 
     elif isinstance(value, int):
-        instant = (value,)
+        instant = value,
 
     elif isinstance(value, list):
         assert 1 <= len(value) <= 3
         instant = tuple(value)
 
-    elif isinstance(value, Period):
-        instant = value.start
-
     else:
         assert isinstance(value, tuple), value
         assert 1 <= len(value) <= 3
@@ -226,7 +223,7 @@ def key_period_size(period: types.Period) -> str:
 
     """
 
-    unit, start, size = period
+    unit, _start, size = period
 
     return f"{UNIT_WEIGHTS[unit]}_{size}"
 

openfisca_core/periods/instant_.py

@@ -5,13 +5,11 @@
 import calendar
 import datetime
 
-from openfisca_core import types
-
 from ._errors import DateUnitValueError, InstantTypeError, OffsetTypeError
 from ._units import DAY, MONTH, YEAR
 
 
-class Instant(tuple):
+class Instant(tuple[int, int, int]):
     """An instant in time (``year``, ``month``, ``day``).
 
     An ``Instant`` represents the most atomic and indivisible
@@ -85,7 +83,7 @@ def __str__(self) -> str:
         return str(self)
 
     @staticmethod
-    def to_date(value: Optional[types.Instant]) -> Optional[datetime.date]:
+    def to_date(value: Optional[Instant]) -> Optional[datetime.date]:
         """Returns the date representation of an ``Instant``.
 
         Args:
@@ -108,7 +106,7 @@ def to_date(value: Optional[types.Instant]) -> Optional[datetime.date]:
         if value is None:
             return None
 
-        if isinstance(value, types.Instant):
+        if isinstance(value, Instant):
             return value.date
 
         raise InstantTypeError(value)
@@ -184,7 +182,7 @@ def date(self) -> datetime.date:
 
         return self.date
 
-    def offset(self, offset: Union[str, int], unit: str) -> types.Instant:
+    def offset(self, offset: Union[str, int], unit: str) -> Instant:
         """Increments/decrements the given instant with offset units.
 
         Args:

openfisca_core/periods/period_.py

@@ -5,13 +5,12 @@
 import calendar
 import datetime
 
-from openfisca_core import types
-
+from ._errors import DateUnitValueError
 from ._units import DAY, MONTH, YEAR, ETERNITY, UNIT_WEIGHTS
 from .instant_ import Instant
 
 
-class Period(tuple):
+class Period(tuple[str, Instant, int]):
     """Toolbox to handle date intervals.
 
     A ``Period`` is a triple (``unit``, ``start``, ``size``).
@@ -121,28 +120,28 @@ def __str__(self) -> str:
         year, month, day = start_instant
 
         # 1 year long period
-        if (unit == MONTH and size == 12 or unit == YEAR and size == 1):
+        if unit == MONTH and size == 12 or unit == YEAR and size == 1:
             if month == 1:
                 # civil year starting from january
                 return str(year)
             else:
                 # rolling year
-                return '{}:{}-{:02d}'.format(YEAR, year, month)
+                return f'{YEAR}:{year}-{month:02d}'
         # simple month
         if unit == MONTH and size == 1:
-            return '{}-{:02d}'.format(year, month)
+            return f'{year}-{month:02d}'
         # several civil years
         if unit == YEAR and month == 1:
-            return '{}:{}:{}'.format(unit, year, size)
+            return f'{unit}:{year}:{size}'
 
         if unit == DAY:
             if size == 1:
-                return '{}-{:02d}-{:02d}'.format(year, month, day)
+                return f'{year}-{month:02d}-{day:02d}'
             else:
-                return '{}:{}-{:02d}-{:02d}:{}'.format(unit, year, month, day, size)
+                return f'{unit}:{year}-{month:02d}-{day:02d}:{size}'
 
         # complex period
-        return '{}:{}-{:02d}:{}'.format(unit, year, month, size)
+        return f'{unit}:{year}-{month:02d}:{size}'
 
     def __contains__(self, other: object) -> bool:
         """Checks if a ``period`` contains another one.
@@ -162,7 +161,7 @@ def __contains__(self, other: object) -> bool:
 
         """
 
-        if isinstance(other, types.Period):
+        if isinstance(other, Period):
             return self.start <= other.start and self.stop >= other.stop
 
         return super().__contains__(other)
@@ -273,10 +272,10 @@ def size_in_months(self) -> int:
 
         """
 
-        if (self[0] == MONTH):
+        if self[0] == MONTH:
             return self[2]
 
-        if(self[0] == YEAR):
+        if self[0] == YEAR:
             return self[2] * 12
 
         raise ValueError(f"Cannot calculate number of months in {self[0]}.")
@@ -315,7 +314,7 @@ def size_in_days(self) -> int:
         raise ValueError(f"Cannot calculate number of days in {unit}")
 
     @property
-    def start(self) -> types.Instant:
+    def start(self) -> Instant:
         """The ``Instant`` at which the ``Period`` starts.
 
         Returns:
@@ -332,7 +331,7 @@ def start(self) -> types.Instant:
         return self[1]
 
     @property
-    def stop(self) -> types.Instant:
+    def stop(self) -> Instant:
         """Last day of the ``Period`` as an ``Instant``.
 
         Returns:
@@ -354,7 +353,7 @@ def stop(self) -> types.Instant:
         year, month, day = start_instant
 
         if unit == ETERNITY:
-            return Instant((float("inf"), float("inf"), float("inf")))
+            return Instant((1, 1, 1))
 
         if unit == 'day':
             if size > 1:
@@ -375,7 +374,7 @@ def stop(self) -> types.Instant:
                     year += 1
                     month -= 12
             else:
-                assert unit == 'year', 'Invalid unit: {} of type {}'.format(unit, type(unit))
+                assert unit == 'year', f'Invalid unit: {unit} of type {type(unit)}'
                 year += size
             day -= 1
             if day < 1:
@@ -396,7 +395,7 @@ def stop(self) -> types.Instant:
         return Instant((year, month, day))
 
     @property
-    def last_month(self) -> types.Period:
+    def last_month(self) -> Period:
         """Last month of the ``Period``.
 
         Returns:
@@ -407,79 +406,80 @@ def last_month(self) -> types.Period:
         return self.first_month.offset(-1)
 
     @property
-    def last_3_months(self) -> types.Period:
+    def last_3_months(self) -> Period:
         """Last 3 months of the ``Period``.
 
         Returns:
             A Period.
 
         """
 
-        start: types.Instant = self.first_month.start
-        return self.__class__((MONTH, start, 3)).offset(-3)
+        start: Instant = self.first_month.start
+        return Period((MONTH, start, 3)).offset(-3)
 
     @property
-    def last_year(self) -> types.Period:
+    def last_year(self) -> Period:
         """Last year of the ``Period``."""
-        start: types.Instant = self.start.offset("first-of", YEAR)
-        return self.__class__((YEAR, start, 1)).offset(-1)
+        start: Instant = self.start.offset("first-of", YEAR)
+        return Period((YEAR, start, 1)).offset(-1)
 
     @property
-    def n_2(self) -> types.Period:
+    def n_2(self) -> Period:
         """Last 2 years of the ``Period``.
 
         Returns:
             A Period.
 
         """
 
-        start: types.Instant = self.start.offset("first-of", YEAR)
-        return self.__class__((YEAR, start, 1)).offset(-2)
+        start: Instant = self.start.offset("first-of", YEAR)
+        return Period((YEAR, start, 1)).offset(-2)
 
     @property
-    def this_year(self) -> types.Period:
+    def this_year(self) -> Period:
         """A new year ``Period`` starting at the beginning of the year.
 
         Returns:
             A Period.
 
         """
 
-        start: types.Instant = self.start.offset("first-of", YEAR)
-        return self.__class__((YEAR, start, 1))
+        start: Instant = self.start.offset("first-of", YEAR)
+        return Period((YEAR, start, 1))
 
     @property
-    def first_month(self) -> types.Period:
+    def first_month(self) -> Period:
         """A new month ``Period`` starting at the first of the month.
 
         Returns:
             A Period.
 
         """
 
-        start: types.Instant = self.start.offset("first-of", MONTH)
-        return self.__class__((MONTH, start, 1))
+        start: Instant = self.start.offset("first-of", MONTH)
+        return Period((MONTH, start, 1))
 
     @property
-    def first_day(self) -> types.Period:
+    def first_day(self) -> Period:
         """A new day ``Period``.
 
         Returns:
             A Period.
 
         """
-        return self.__class__((DAY, self.start, 1))
+        return Period((DAY, self.start, 1))
 
-    def get_subperiods(self, unit: str) -> Sequence[types.Period]:
+    def get_subperiods(self, unit: str) -> Sequence[Period]:
         """Return the list of all the periods of unit ``unit``.
 
         Args:
             unit: A string representing period's ``unit``.
 
         Returns:
-            A list of Periods.
+            A list of periods.
 
         Raises:
+            DateUnitValueError: If the ``unit`` is not a valid date unit.
             ValueError: If the period's unit is smaller than the given unit.
 
         Examples:
@@ -494,7 +494,7 @@ def get_subperiods(self, unit: str) -> Sequence[types.Period]:
         """
 
         if UNIT_WEIGHTS[self.unit] < UNIT_WEIGHTS[unit]:
-            raise ValueError('Cannot subdivide {0} into {1}'.format(self.unit, unit))
+            raise ValueError(f"Cannot subdivide {self.unit} into {unit}")
 
         if unit == YEAR:
             return [self.this_year.offset(i, YEAR) for i in range(self.size)]
@@ -505,11 +505,13 @@ def get_subperiods(self, unit: str) -> Sequence[types.Period]:
         if unit == DAY:
             return [self.first_day.offset(i, DAY) for i in range(self.size_in_days)]
 
+        raise DateUnitValueError(unit)
+
     def offset(
             self,
             offset: Union[str, int],
             unit: Optional[str] = None,
-            ) -> types.Period:
+            ) -> Period:
         """Increment (or decrement) the given period with offset units.
 
         Args:
@@ -534,4 +536,4 @@ def offset(
 
         """
 
-        return self.__class__((self[0], self[1].offset(offset, self[0] if unit is None else unit), self[2]))
+        return Period((self[0], self[1].offset(offset, self[0] if unit is None else unit), self[2]))

openfisca_core/taxbenefitsystems/tax_benefit_system.py

@@ -14,14 +14,13 @@
 import traceback
 import typing
 
-from openfisca_core import commons, periods, variables
+from openfisca_core import commons, periods, types, variables
 from openfisca_core.entities import Entity
 from openfisca_core.errors import VariableNameConflictError, VariableNotFoundError
 from openfisca_core.parameters import ParameterNode
 from openfisca_core.periods import Instant, Period
 from openfisca_core.populations import Population, GroupPopulation
 from openfisca_core.simulations import SimulationBuilder
-from openfisca_core.types import ParameterNodeAtInstant
 from openfisca_core.variables import Variable
 
 log = logging.getLogger(__name__)
@@ -43,7 +42,7 @@ class TaxBenefitSystem:
     person_entity: Entity
 
     _base_tax_benefit_system = None
-    _parameters_at_instant_cache: Dict[Instant, ParameterNodeAtInstant] = {}
+    _parameters_at_instant_cache: Dict[Instant, types.ParameterNodeAtInstant] = {}
     person_key_plural = None
     preprocess_parameters = None
     baseline = None  # Baseline tax-benefit system. Used only by reforms. Note: Reforms can be chained.
@@ -385,8 +384,8 @@ def _get_baseline_parameters_at_instant(self, instant):
     @functools.lru_cache()
     def get_parameters_at_instant(
             self,
-            instant: Union[str, int, Period, Instant],
-            ) -> Optional[ParameterNodeAtInstant]:
+            instant: Union[str, int, types.Period, types.Instant],
+            ) -> Optional[types.ParameterNodeAtInstant]:
         """Get the parameters of the legislation at a given instant
 
         Args:
@@ -397,7 +396,7 @@ def get_parameters_at_instant(
 
         """
 
-        key: Instant
+        key: Optional[types.Instant]
         msg: str
 
         if isinstance(instant, Instant):
@@ -410,7 +409,7 @@ def get_parameters_at_instant(
             key = periods.build_instant(instant)
 
         else:
-            msg = f"Expected an Instant (e.g. Instant((2017, 1, 1)) ). Got: {key}."
+            msg = f"Expected an Instant (e.g. Instant((2017, 1, 1)) ). Got: {instant}."
             raise AssertionError(msg)
 
         if self.parameters is None: