Merge branch 'develop' into feature/sqlalchemy

docs/changelog/fragments/+conversion.feature.rst

@@ -1,2 +1,4 @@
 New major feature is out!
-Added support for model conversion! See :ref:`conversion tutorial <conversion-tutorial>` for details.
+Added support for model conversion!
+Now, you can generate boilerplate converter function by adaptix.
+See :ref:`conversion tutorial <conversion-tutorial>` for details.

docs/changelog/fragments/+load_error_rename.deprecation.rst

@@ -0,0 +1,23 @@
+Standardize names inside :mod:`adaptix.load_error`. Import of old names will emit ``DeprecationWarning``.
+
+.. list-table::
+   :header-rows: 1
+
+   * - Old name
+     - New name
+   * - ``MsgError``
+     - ``MsgLoadError``
+   * - ``ExtraFieldsError``
+     - ``ExtraFieldsLoadError``
+   * - ``ExtraItemsError``
+     - ``ExtraItemsLoadError``
+   * - ``NoRequiredFieldsError``
+     - ``NoRequiredFieldsLoadError``
+   * - ``NoRequiredItemsError``
+     - ``NoRequiredItemsLoadError``
+   * - ``ValidationError``
+     - ``ValidationLoadError``
+   * - ``BadVariantError``
+     - ``BadVariantLoadError``
+   * - ``DatetimeFormatMismatch``
+     - ``FormatMismatchLoadError``

docs/examples/loading-and-dumping/extended_usage/unknown_fields_processing/on_loading_extra_forbid.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
 from adaptix import ExtraForbid, Retort, name_mapping
-from adaptix.load_error import AggregateLoadError, ExtraFieldsError
+from adaptix.load_error import AggregateLoadError, ExtraFieldsLoadError
 
 
 @dataclass
@@ -27,5 +27,5 @@ class Book:
     retort.load(data, Book)
 except AggregateLoadError as e:
     assert len(e.exceptions) == 1
-    assert isinstance(e.exceptions[0], ExtraFieldsError)
+    assert isinstance(e.exceptions[0], ExtraFieldsLoadError)
     assert set(e.exceptions[0].fields) == {"unknown1", "unknown2"}

docs/examples/loading-and-dumping/tutorial/validators.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
 from adaptix import P, Retort, validator
-from adaptix.load_error import AggregateLoadError, LoadError, ValidationError
+from adaptix.load_error import AggregateLoadError, LoadError, ValidationLoadError
 
 
 @dataclass
@@ -25,7 +25,7 @@ class Book:
     retort.load(data, Book)
 except AggregateLoadError as e:
     assert len(e.exceptions) == 1
-    assert isinstance(e.exceptions[0], ValidationError)
+    assert isinstance(e.exceptions[0], ValidationLoadError)
     assert e.exceptions[0].msg == "value must be greater or equal 0"
 
 

examples/api_division/retort.py

@@ -5,7 +5,7 @@
 from phonenumbers import PhoneNumber
 
 from adaptix import Chain, ExtraForbid, ExtraSkip, P, Retort, dumper, enum_by_name, loader, name_mapping, validator
-from adaptix.load_error import ExtraFieldsError, ValueLoadError
+from adaptix.load_error import ExtraFieldsLoadError, ValueLoadError
 
 from .models import Receipt, ReceiptType, RecItem
 from .money import Money, TooPreciseAmount
@@ -51,7 +51,7 @@ def money_loader(data):
 
 def forbid_version_key(data):
     if isinstance(data, dict) and 'version' in data:
-        raise ExtraFieldsError(['version'], data)
+        raise ExtraFieldsLoadError(['version'], data)
     return data
 
 

examples/api_division/test_example.py

@@ -7,11 +7,11 @@
 
 from adaptix.load_error import (
     AggregateLoadError,
-    BadVariantError,
-    ExtraFieldsError,
+    BadVariantLoadError,
+    ExtraFieldsLoadError,
     TypeLoadError,
     UnionLoadError,
-    ValidationError,
+    ValidationLoadError,
     ValueLoadError,
 )
 
@@ -72,7 +72,7 @@ def test_outer_loading_no_rec_items():
             f'while loading model {Receipt}',
             [
                 with_trail(
-                    ValidationError('At least one item must be presented', []),
+                    ValidationLoadError('At least one item must be presented', []),
                     ['items'],
                 )
             ]
@@ -119,7 +119,7 @@ def test_outer_loading_bad_phone():
                                                     f'while loading model {NotifyEmail}',
                                                     [
                                                         with_trail(
-                                                            BadVariantError({'email'}, 'phone'),
+                                                            BadVariantLoadError({'email'}, 'phone'),
                                                             ['type']
                                                         )
                                                     ]
@@ -155,7 +155,7 @@ def test_outer_loading_bad_receipt_type():
     raises_exc(
         AggregateLoadError(
             f'while loading model {Receipt}',
-            [with_trail(BadVariantError(['INCOME', 'INCOME_REFUND'], 'BAD_TYPE'), ['type'])]
+            [with_trail(BadVariantLoadError(['INCOME', 'INCOME_REFUND'], 'BAD_TYPE'), ['type'])]
         ),
         lambda: outer_receipt_loader(bad_receipt_type_data),
     )
@@ -165,7 +165,7 @@ def test_outer_loading_with_version_tag():
     with_version_data = change(outer_sample_data, ["version"], 1)
 
     raises_exc(
-        ExtraFieldsError(['version'], with_version_data),
+        ExtraFieldsLoadError(['version'], with_version_data),
         lambda: outer_receipt_loader(with_version_data),
     )
 
@@ -186,7 +186,7 @@ def test_outer_loading_bad_item_quantity():
                                     f'while loading model {RecItem!r}',
                                     [
                                         with_trail(
-                                            ValidationError('Value must be > 0', 0),
+                                            ValidationLoadError('Value must be > 0', 0),
                                             ['quantity'],
                                         ),
                                     ]
@@ -219,7 +219,7 @@ def test_outer_loading_bad_item_price():
                                     f'while loading model {RecItem}',
                                     [
                                         with_trail(
-                                            ValidationError('Value must be >= 0', rubles(-10)),
+                                            ValidationLoadError('Value must be >= 0', rubles(-10)),
                                             ['price'],
                                         )
                                     ]

src/adaptix/_internal/conversion/facade/retort.py

@@ -43,7 +43,7 @@ class FilledConversionRetort(OperatingRetort):
 
 
 class AdornedConversionRetort(OperatingRetort):
-    def _calculate_derived(self):
+    def _calculate_derived(self) -> None:
         super()._calculate_derived()
         self._simple_converter_cache: Dict[Tuple[TypeHint, TypeHint, Optional[str]], Converter] = {}
 

src/adaptix/_internal/morphing/concrete_provider.py

@@ -16,7 +16,7 @@
 from ..provider.request_cls import LocatedRequest, StrictCoercionRequest, TypeHintLoc, find_owner_with_field
 from ..provider.static_provider import static_provision_action
 from ..special_cases_optimization import as_is_stub
-from .load_error import DatetimeFormatMismatch, TypeLoadError, ValueLoadError
+from .load_error import FormatMismatchLoadError, TypeLoadError, ValueLoadError
 from .provider_template import DumperProvider, LoaderProvider, ProviderWithAttachableLSC
 from .request_cls import DumperRequest, LoaderRequest
 
@@ -59,7 +59,7 @@ def datetime_format_loader(data):
             try:
                 return datetime.strptime(data, fmt)
             except ValueError:
-                raise DatetimeFormatMismatch(fmt, data)
+                raise FormatMismatchLoadError(fmt, data)
             except TypeError:
                 raise TypeLoadError(str, data)
 

src/adaptix/_internal/morphing/constant_length_tuple_provider.py

@@ -21,9 +21,9 @@
 from .load_error import (
     AggregateLoadError,
     ExcludedTypeLoadError,
-    ExtraItemsError,
+    ExtraItemsLoadError,
     LoadError,
-    NoRequiredItemsError,
+    NoRequiredItemsLoadError,
     TypeLoadError,
 )
 from .provider_template import DumperProvider, LoaderProvider
@@ -114,9 +114,9 @@ def dt_all_loader(data):  # noqa: CCR001
 
             if data_len != loaders_len:
                 if data_len > loaders_len:
-                    raise ExtraItemsError(loaders_len, data)
+                    raise ExtraItemsLoadError(loaders_len, data)
                 if loaders_len > data_len:
-                    raise NoRequiredItemsError(loaders_len, data)
+                    raise NoRequiredItemsLoadError(loaders_len, data)
 
             idx = 0
             errors = []
@@ -156,9 +156,9 @@ def dt_first_loader(data):
 
             if data_len != loaders_len:
                 if data_len > loaders_len:
-                    raise ExtraItemsError(loaders_len, data)
+                    raise ExtraItemsLoadError(loaders_len, data)
                 if loaders_len > data_len:
-                    raise NoRequiredItemsError(loaders_len, data)
+                    raise NoRequiredItemsLoadError(loaders_len, data)
 
             idx = 0
             for loader, field in zip(loaders, data):
@@ -182,9 +182,9 @@ def dt_disable_non_sc_loader(data):
 
             if data_len != loaders_len:
                 if data_len > loaders_len:
-                    raise ExtraItemsError(loaders_len, data)
+                    raise ExtraItemsLoadError(loaders_len, data)
                 if loaders_len > data_len:
-                    raise NoRequiredItemsError(loaders_len, data)
+                    raise NoRequiredItemsLoadError(loaders_len, data)
 
             return tuple(
                 loader(field)
@@ -209,9 +209,9 @@ def dt_disable_sc_loader(data):
 
             if data_len != loaders_len:
                 if data_len > loaders_len:
-                    raise ExtraItemsError(loaders_len, data)
+                    raise ExtraItemsLoadError(loaders_len, data)
                 if loaders_len > data_len:
-                    raise NoRequiredItemsError(loaders_len, data)
+                    raise NoRequiredItemsLoadError(loaders_len, data)
 
             return tuple(
                 loader(field)
@@ -267,9 +267,9 @@ def dt_all_dumper(data):
 
             if data_len != dumpers_len:
                 if data_len > dumpers_len:
-                    raise ExtraItemsError(dumpers_len, data)
+                    raise ExtraItemsLoadError(dumpers_len, data)
                 if dumpers_len > data_len:
-                    raise NoRequiredItemsError(dumpers_len, data)
+                    raise NoRequiredItemsLoadError(dumpers_len, data)
 
             idx = 0
             errors = []
@@ -300,9 +300,9 @@ def dt_first_dumper(data):
 
             if data_len != dumpers_len:
                 if data_len > dumpers_len:
-                    raise ExtraItemsError(dumpers_len, data)
+                    raise ExtraItemsLoadError(dumpers_len, data)
                 if dumpers_len > data_len:
-                    raise NoRequiredItemsError(dumpers_len, data)
+                    raise NoRequiredItemsLoadError(dumpers_len, data)
 
             idx = 0
             for dumper, field in zip(dumpers, data):
@@ -332,9 +332,9 @@ def tuple_dumper(data):
 
             if data_len != dumpers_len:
                 if data_len > dumpers_len:
-                    raise ExtraItemsError(dumpers_len, data)
+                    raise ExtraItemsLoadError(dumpers_len, data)
                 if dumpers_len > data_len:
-                    raise NoRequiredItemsError(dumpers_len, data)
+                    raise NoRequiredItemsLoadError(dumpers_len, data)
 
             return tuple(
                 dumper(field)

src/adaptix/_internal/morphing/enum_provider.py

@@ -15,12 +15,12 @@
 from ..provider.request_cls import LocMap, StrictCoercionRequest, TypeHintLoc, get_type_from_request
 from ..type_tools import is_subclass_soft, normalize_type
 from .load_error import (
-    BadVariantError,
-    DuplicatedValues,
+    BadVariantLoadError,
+    DuplicatedValuesLoadError,
     ExcludedTypeLoadError,
-    MsgError,
-    MultipleBadVariant,
-    OutOfRange,
+    MsgLoadError,
+    MultipleBadVariantLoadError,
+    OutOfRangeLoadError,
     TypeLoadError,
 )
 from .request_cls import DumperRequest, LoaderRequest
@@ -116,9 +116,9 @@ def enum_loader(data):
             try:
                 return mapping[data]
             except KeyError:
-                raise BadVariantError(variants, data) from None
+                raise BadVariantLoadError(variants, data) from None
             except TypeError:
-                raise BadVariantError(variants, data)
+                raise BadVariantLoadError(variants, data)
 
         return enum_loader
 
@@ -153,7 +153,7 @@ def enum_loader(data):
             try:
                 return enum(loaded_value)
             except ValueError:
-                raise MsgError("Bad enum value", data)
+                raise MsgLoadError("Bad enum value", data)
 
         return enum_loader
 
@@ -194,22 +194,22 @@ def _make_loader(self, enum):
             def enum_exact_loader(data):
                 # since MyEnum(MyEnum.MY_CASE) == MyEnum.MY_CASE
                 if type(data) is enum:  # pylint: disable=unidiomatic-typecheck
-                    raise BadVariantError(variants, data)
+                    raise BadVariantLoadError(variants, data)
 
                 try:
                     return enum(data)
                 except ValueError:
-                    raise BadVariantError(variants, data) from None
+                    raise BadVariantLoadError(variants, data) from None
 
             return enum_exact_loader
 
         def enum_exact_loader_v2m(data):
             try:
                 return value_to_member[data]
             except KeyError:
-                raise BadVariantError(variants, data) from None
+                raise BadVariantLoadError(variants, data) from None
             except TypeError:
-                raise BadVariantError(variants, data)
+                raise BadVariantLoadError(variants, data)
 
         return enum_exact_loader_v2m
 
@@ -254,7 +254,7 @@ def flag_loader(data):
                 raise TypeLoadError(int, data)
 
             if data < 0 or data > flag_mask:
-                raise OutOfRange(0, flag_mask, data)
+                raise OutOfRangeLoadError(0, flag_mask, data)
 
             # data already has been validated for all edge cases
             # so enum lookup cannot raise an error
@@ -318,7 +318,7 @@ def flag_loader(data) -> Flag:  # noqa: CCR001
 
             if not allow_duplicates:
                 if len(process_data) != len(set(process_data)):
-                    raise DuplicatedValues(data)
+                    raise DuplicatedValuesLoadError(data)
 
             bad_variants = []
             result = zero_case
@@ -329,7 +329,7 @@ def flag_loader(data) -> Flag:  # noqa: CCR001
                 result |= mapping[item]
 
             if bad_variants:
-                raise MultipleBadVariant(
+                raise MultipleBadVariantLoadError(
                     allowed_values=variants,
                     invalid_values=bad_variants,
                     input_value=data,

src/adaptix/_internal/morphing/facade/provider.py

@@ -33,7 +33,7 @@
     FlagByExactValueProvider,
     FlagByListProvider,
 )
-from ..load_error import LoadError, ValidationError
+from ..load_error import LoadError, ValidationLoadError
 from ..model.loader_provider import InlinedShapeModelLoaderProvider
 from ..name_layout.base import ExtraIn, ExtraOut
 from ..name_layout.component import ExtraMoveAndPoliciesOverlay, SievesOverlay, StructureOverlay
@@ -389,7 +389,7 @@ def flag_by_member_names(
     :param allow_single_value: Allows calling the loader with a single value.
         If this is allowed, singlular values are treated as one element list.
     :param allow_duplicates: Allows calling the loader with a list containing non-unique elements.
-        Unless this is allowed, loader will raise :exc:`.DuplicatedValues` in that case.
+        Unless this is allowed, loader will raise :exc:`.DuplicatedValuesLoadError` in that case.
     :param allow_compound: Allows the loader to accept names of compound members
         (e.g. ``WHITE = RED | GREEN | BLUE``) and the dumper to return names of compound members.
         If this is allowed, dumper will use compound members names to serialize value.
@@ -419,7 +419,7 @@ def validator(
 ) -> Provider:
     # pylint: disable=C3001
     exception_factory = (
-        (lambda x: ValidationError(error, x))
+        (lambda x: ValidationLoadError(error, x))
         if error is None or isinstance(error, str) else
         error
     )