Merge pull request #887 from cordada/deploy/v0.56.0

Deploy release v0.56.0

Author: jtrobles-cdd

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.55.0
+current_version = 0.56.0
 commit = True
 tag = False
 message = chore: Bump version from {current_version} to {new_version}

HISTORY.md

@@ -1,5 +1,12 @@
 # History
 
+## 0.56.0 (2025-09-10)
+
+- (PR #883, 2025-09-10) extras: Add more tests for Django form field for `Rut`
+- (PR #884, 2025-09-10) extras: Improve Django filters `FILTER_FOR_DBFIELD_DEFAULTS`
+- (PR #882, 2025-09-10) extras: Django model field `RutField` does not validate DV of `Rut`
+- (PR #885, 2025-09-10) deps: Update `cryptography` from 45.0.4 to 45.0.7
+
 ## 0.55.0 (2025-09-10)
 
 - (PR #878, 2025-09-10) extras: Improve Django filter for `Rut`

requirements-dev.txt

@@ -42,7 +42,7 @@ colorama==0.4.6
     # via tox
 coverage==7.10.6
     # via -r requirements-dev.in
-cryptography==45.0.4
+cryptography==45.0.7
     # via
     #   -c requirements.txt
     #   secretstorage

requirements.in

@@ -6,7 +6,7 @@
 #   git+https://github.com/example/example.git@example-vcs-ref#egg=example-pkg[foo,bar]==1.42.3
 
 backports-zoneinfo==0.2.1 ; python_version < "3.9" # Used by `djangorestframework`.
-cryptography==45.0.4
+cryptography==45.0.7
 defusedxml==0.7.1
 django-filter>=24.2
 Django>=4.2

requirements.txt

@@ -16,7 +16,7 @@ certifi==2024.7.4
     # via signxml
 cffi==1.16.0
     # via cryptography
-cryptography==45.0.4
+cryptography==45.0.7
     # via
     #   -r requirements.in
     #   pyopenssl

src/cl_sii/__init__.py

@@ -4,4 +4,4 @@
 
 """
 
-__version__ = '0.55.0'
+__version__ = '0.56.0'

src/cl_sii/extras/dj_filters.py

@@ -23,8 +23,7 @@
 import cl_sii.extras.dj_model_fields
 
 
-FILTER_FOR_DBFIELD_DEFAULTS: Mapping[Type[django.db.models.Field], Mapping[str, object]]
-FILTER_FOR_DBFIELD_DEFAULTS = deepcopy(django_filters.filterset.FILTER_FOR_DBFIELD_DEFAULTS)
+FILTER_FOR_DBFIELD_DEFAULTS: Mapping[Type[django.db.models.Field], Mapping[str, object]] = {}
 
 
 class RutFilter(django_filters.filters.CharFilter):
@@ -90,4 +89,7 @@ class SiiFilterSet(django_filters.filterset.FilterSet):
     """
 
     FILTER_DEFAULTS: ClassVar[Mapping[Type[django.db.models.Field], Mapping[str, object]]]
-    FILTER_DEFAULTS = FILTER_FOR_DBFIELD_DEFAULTS
+    FILTER_DEFAULTS = {
+        **deepcopy(django_filters.FilterSet.FILTER_DEFAULTS),
+        **FILTER_FOR_DBFIELD_DEFAULTS,
+    }

src/cl_sii/extras/dj_model_fields.py

@@ -153,29 +153,37 @@ def to_python(self, value: Optional[object]) -> Optional[Rut]:
             if the data can't be converted
 
         """
-        if value is None or isinstance(value, Rut):
+        if value is None:
             converted_value = value
-        else:
-            try:
-                converted_value = Rut(value, validate_dv=self.validate_dv)  # type: ignore
-            except (AttributeError, TypeError, ValueError) as exc:
-                if (
-                    isinstance(exc, ValueError)
-                    and exc.args
-                    and exc.args[0] == Rut.INVALID_DV_ERROR_MESSAGE
-                ):
-                    raise django.core.exceptions.ValidationError(
-                        self.error_messages['invalid_dv'],
-                        code='invalid_dv',
-                        params={'value': value},
-                    )
-
+            return converted_value
+        elif isinstance(value, Rut):
+            if not self.validate_dv:
+                converted_value = value
+                return converted_value
+            elif self.validate_dv and value.validate_dv(raise_exception=False):
+                converted_value = value
+                return converted_value
+
+        try:
+            converted_value = Rut(value, validate_dv=self.validate_dv)  # type: ignore
+        except (AttributeError, TypeError, ValueError) as exc:
+            if (
+                isinstance(exc, ValueError)
+                and exc.args
+                and exc.args[0] == Rut.INVALID_DV_ERROR_MESSAGE
+            ):
                 raise django.core.exceptions.ValidationError(
-                    self.error_messages['invalid'],
-                    code='invalid',
+                    self.error_messages['invalid_dv'],
+                    code='invalid_dv',
                     params={'value': value},
                 )
 
+            raise django.core.exceptions.ValidationError(
+                self.error_messages['invalid'],
+                code='invalid',
+                params={'value': value},
+            )
+
         return converted_value
 
     def value_to_string(self, obj: django.db.models.Model) -> str:

src/tests/test_extras_dj_form_fields.py

@@ -19,6 +19,7 @@ def setUpClass(cls) -> None:
         cls.valid_rut_canonical_instance_with_invalid_dv = Rut(
             cls.valid_rut_canonical_with_invalid_dv
         )
+        assert not cls.valid_rut_canonical_instance_with_invalid_dv.validate_dv()
         cls.valid_rut_verbose_leading_zero_lowercase = '060.803.000-k'
 
     def test_clean_value_of_invalid_canonical_str(self) -> None:
@@ -57,6 +58,18 @@ def test_clean_value_of_rut_str_with_invalid_dv_if_not_validated(self) -> None:
         self.assertIsInstance(cleaned_value, Rut)
         self.assertEqual(cleaned_value.canonical, self.valid_rut_canonical_with_invalid_dv)
 
+    def test_clean_value_of_rut_instance_with_invalid_dv_if_validated(self) -> None:
+        rut_field = RutField(validate_dv=True)
+        with self.assertRaises(django.core.exceptions.ValidationError) as cm:
+            rut_field.clean(self.valid_rut_canonical_instance_with_invalid_dv)
+        self.assertEqual(cm.exception.code, 'invalid_dv')
+
+    def test_clean_value_of_rut_instance_with_invalid_dv_if_not_validated(self) -> None:
+        rut_field = RutField(validate_dv=False)
+        cleaned_value = rut_field.clean(self.valid_rut_canonical_instance_with_invalid_dv)
+        self.assertIsInstance(cleaned_value, Rut)
+        self.assertEqual(cleaned_value, self.valid_rut_canonical_instance_with_invalid_dv)
+
     def test_clean_of_empty_value_if_not_required(self) -> None:
         rut_field = RutField(required=False)
         for value in RutField.empty_values:

src/tests/test_extras_dj_model_fields.py

@@ -11,6 +11,7 @@ class RutFieldTest(unittest.TestCase):
     valid_rut_canonical: str
     valid_rut_instance: Rut
     valid_rut_canonical_with_invalid_dv: str
+    valid_rut_canonical_instance_with_invalid_dv: Rut
     valid_rut_verbose_leading_zero_lowercase: str
     mock_model_instance: django.db.models.Model
 
@@ -19,6 +20,10 @@ def setUpClass(cls) -> None:
         cls.valid_rut_canonical = '60803000-K'
         cls.valid_rut_instance = Rut(cls.valid_rut_canonical)
         cls.valid_rut_canonical_with_invalid_dv = '60803000-0'
+        cls.valid_rut_canonical_instance_with_invalid_dv = Rut(
+            cls.valid_rut_canonical_with_invalid_dv
+        )
+        assert not cls.valid_rut_canonical_instance_with_invalid_dv.validate_dv()
         cls.valid_rut_verbose_leading_zero_lowercase = '060.803.000-k'
         cls.mock_model_instance = unittest.mock.create_autospec(
             django.db.models.Model, instance=True
@@ -43,6 +48,14 @@ def test_get_prep_value_of_None(self) -> None:
         prepared_value = RutField().get_prep_value(None)
         self.assertIsNone(prepared_value)
 
+    def test_clean_value_with_invalid_type(self) -> None:
+        for value_with_invalid_type in [12345678, 12.34, [], {}, object()]:
+            with self.subTest(value=value_with_invalid_type):
+                rut_field = RutField()
+                with self.assertRaises(django.core.exceptions.ValidationError) as cm:
+                    rut_field.clean(value_with_invalid_type, self.mock_model_instance)
+                self.assertEqual(cm.exception.code, 'invalid')
+
     def test_clean_value_of_rut_str_with_invalid_dv_if_validated(self) -> None:
         rut_field = RutField(validate_dv=True)
         with self.assertRaises(django.core.exceptions.ValidationError) as cm:
@@ -57,6 +70,30 @@ def test_clean_value_of_rut_str_with_invalid_dv_if_not_validated(self) -> None:
         self.assertIsInstance(cleaned_value, Rut)
         self.assertEqual(cleaned_value.canonical, self.valid_rut_canonical_with_invalid_dv)
 
+    def test_clean_value_of_rut_instance_with_valid_dv(self) -> None:
+        for validate_dv in [True, False]:
+            with self.subTest(validate_dv=validate_dv):
+                rut_field = RutField(validate_dv=validate_dv)
+                cleaned_value = rut_field.clean(self.valid_rut_instance, self.mock_model_instance)
+                self.assertIsInstance(cleaned_value, Rut)
+                self.assertEqual(cleaned_value, self.valid_rut_instance)
+
+    def test_clean_value_of_rut_instance_with_invalid_dv_if_validated(self) -> None:
+        rut_field = RutField(validate_dv=True)
+        with self.assertRaises(django.core.exceptions.ValidationError) as cm:
+            rut_field.clean(
+                self.valid_rut_canonical_instance_with_invalid_dv, self.mock_model_instance
+            )
+        self.assertEqual(cm.exception.code, 'invalid_dv')
+
+    def test_clean_value_of_rut_instance_with_invalid_dv_if_not_validated(self) -> None:
+        rut_field = RutField(validate_dv=False)
+        cleaned_value = rut_field.clean(
+            self.valid_rut_canonical_instance_with_invalid_dv, self.mock_model_instance
+        )
+        self.assertIsInstance(cleaned_value, Rut)
+        self.assertEqual(cleaned_value, self.valid_rut_canonical_instance_with_invalid_dv)
+
     def test_deconstruct_without_options(self) -> None:
         name, path, args, kwargs = RutField().deconstruct()
         self.assertEqual(path, 'cl_sii.extras.dj_model_fields.RutField')