Add support for pendulum Duration (#162)

Author: tempookian

pydantic_extra_types/pendulum_dt.py

@@ -6,6 +6,7 @@
 try:
     from pendulum import Date as _Date
     from pendulum import DateTime as _DateTime
+    from pendulum import Duration as _Duration
     from pendulum import parse
 except ModuleNotFoundError:  # pragma: no cover
     raise RuntimeError(
@@ -131,3 +132,61 @@ def _validate(cls, value: Any, handler: core_schema.ValidatorFunctionWrapHandler
         except Exception as exc:
             raise PydanticCustomError('value_error', 'value is not a valid date') from exc
         return handler(data)
+
+
+class Duration(_Duration):
+    """
+    A `pendulum.Duration` object. At runtime, this type decomposes into pendulum.Duration automatically.
+    This type exists because Pydantic throws a fit on unknown types.
+
+    ```python
+    from pydantic import BaseModel
+    from pydantic_extra_types.pendulum_dt import Duration
+
+    class test_model(BaseModel):
+        delta_t: Duration
+
+    print(test_model(delta_t='P1DT25H'))
+
+    #> test_model(delta_t=Duration(days=2, hours=1))
+    ```
+    """
+
+    __slots__: List[str] = []
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source: Type[Any], handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
+        """
+        Return a Pydantic CoreSchema with the Duration validation
+
+        Args:
+            source: The source type to be converted.
+            handler: The handler to get the CoreSchema.
+
+        Returns:
+            A Pydantic CoreSchema with the Duration validation.
+        """
+        return core_schema.no_info_wrap_validator_function(cls._validate, core_schema.timedelta_schema())
+
+    @classmethod
+    def _validate(cls, value: Any, handler: core_schema.ValidatorFunctionWrapHandler) -> Any:
+        """
+        Validate the Duration object and return it.
+
+        Args:
+            value: The value to validate.
+            handler: The handler to get the CoreSchema.
+
+        Returns:
+            The validated value or raises a PydanticCustomError.
+        """
+        # if we are passed an existing instance, pass it straight through.
+        if isinstance(value, _Duration):
+            return handler(value)
+
+        # otherwise, parse it.
+        try:
+            data = parse(value)
+        except Exception as exc:
+            raise PydanticCustomError('value_error', 'value is not a valid duration') from exc
+        return handler(data)

tests/test_pendulum_dt.py

@@ -2,7 +2,7 @@
 import pytest
 from pydantic import BaseModel, ValidationError
 
-from pydantic_extra_types.pendulum_dt import Date, DateTime
+from pydantic_extra_types.pendulum_dt import Date, DateTime, Duration
 
 
 class DtModel(BaseModel):
@@ -13,6 +13,10 @@ class DateModel(BaseModel):
     d: Date
 
 
+class DurationModel(BaseModel):
+    delta_t: Duration
+
+
 def test_pendulum_dt_existing_instance():
     """
     Verifies that constructing a model with an existing pendulum dt doesn't throw.
@@ -31,8 +35,23 @@ def test_pendulum_date_existing_instance():
     assert model.d == today
 
 
+def test_pendulum_duration_existing_instance():
+    """
+    Verifies that constructing a model with an existing pendulum duration doesn't throw.
+    """
+    delta_t = pendulum.duration(days=42, hours=13, minutes=37)
+    model = DurationModel(delta_t=delta_t)
+
+    assert model.delta_t.total_seconds() == delta_t.total_seconds()
+
+
 @pytest.mark.parametrize(
-    'dt', [pendulum.now().to_iso8601_string(), pendulum.now().to_w3c_string(), pendulum.now().to_iso8601_string()]
+    'dt',
+    [
+        pendulum.now().to_iso8601_string(),
+        pendulum.now().to_w3c_string(),
+        pendulum.now().to_iso8601_string(),
+    ],
 )
 def test_pendulum_dt_from_serialized(dt):
     """
@@ -52,6 +71,25 @@ def test_pendulum_date_from_serialized():
     assert model.d == date_actual
 
 
+@pytest.mark.parametrize(
+    'delta_t_str',
+    [
+        'P3.14D',
+        'PT404H',
+        'P1DT25H',
+        'P2W',
+        'P10Y10M10D',
+    ],
+)
+def test_pendulum_duration_from_serialized(delta_t_str):
+    """
+    Verifies that building an instance from serialized, well-formed strings decode properly.
+    """
+    true_delta_t = pendulum.parse(delta_t_str)
+    model = DurationModel(delta_t=delta_t_str)
+    assert model.delta_t == true_delta_t
+
+
 @pytest.mark.parametrize('dt', [None, 'malformed', pendulum.now().to_iso8601_string()[:5], 42])
 def test_pendulum_dt_malformed(dt):
     """
@@ -68,3 +106,15 @@ def test_pendulum_date_malformed(date):
     """
     with pytest.raises(ValidationError):
         DateModel(d=date)
+
+
+@pytest.mark.parametrize(
+    'delta_t',
+    [None, 'malformed', pendulum.today().to_iso8601_string()[:5], 42, '12m'],
+)
+def test_pendulum_duration_malformed(delta_t):
+    """
+    Verifies that the instance fails to validate if malformed durations are passed.
+    """
+    with pytest.raises(ValidationError):
+        DurationModel(delta_t=delta_t)