Move type errors to the errors.py module; Change errors interface a…

… bit
pydantic · samuelcolvin · May 31, 2018 · May 26, 2018 · May 27, 2018 · May 27, 2018
commit 8a25c51e92c68c8f82371acd4b534b5e3e99892f
diff --git a/pydantic/errors.py b/pydantic/errors.py
@@ -0,0 +1,91 @@
+__all__ = (
+    'PydanticErrorMixin',
+    'PydanticTypeError',
+    'PydanticValueError',
+
+    'ConfigError',
+
+    'MissingError',
+    'ExtraError',
+
+    'DecimalError',
+    'DecimalIsNotFiniteError',
+    'DecimalMaxDigitsError',
+    'DecimalMaxPlacesError',
+    'DecimalWholeDigitsError',
+
+    'UUIDError',
+    'UUIDVersionError',
+)
+
+
+class PydanticErrorMixin:
+    msg_template: str
+
+    def __init__(self, **ctx):
+        self.ctx = ctx or None
+
+    def __str__(self) -> str:
+        return self.msg_template.format(**self.ctx or {})
+
+
+class PydanticTypeError(PydanticErrorMixin,
+                        TypeError):
+    pass
+
+
+class PydanticValueError(PydanticErrorMixin,
+                         ValueError):
+    pass
+
+
+class ConfigError(RuntimeError):
+    pass
+
+
+class MissingError(PydanticValueError):
+    msg_template = 'field required'
+
+
+class ExtraError(PydanticValueError):
+    msg_template = 'extra fields not permitted'
+
+
+class DecimalError(PydanticTypeError):
+    msg_template = 'value is not a valid decimal'
+
+
+class DecimalIsNotFiniteError(PydanticValueError):
+    msg_template = 'value is not a valid decimal'
+
+
+class DecimalMaxDigitsError(PydanticValueError):
+    msg_template = 'ensure that there are no more than {max_digits} digits in total'
+
+    def __init__(self, *, max_digits: int) -> None:
+        super().__init__(max_digits=max_digits)
+
+
+class DecimalMaxPlacesError(PydanticValueError):
+    msg_template = 'ensure that there are no more than {decimal_places} decimal places'
+
+    def __init__(self, *, decimal_places: int) -> None:
+        super().__init__(decimal_places=decimal_places)
+
+
+class DecimalWholeDigitsError(PydanticValueError):
+    msg_template = 'ensure that there are no more than {whole_digits} digits before the decimal point'
+
+    def __init__(self, *, whole_digits: int) -> None:
+        super().__init__(whole_digits=whole_digits)
+
+
+class UUIDError(PydanticTypeError):
+    msg_template = 'value is not a valid uuid'
+
+
+class UUIDVersionError(PydanticValueError):
+    msg_template = 'uuid version {required_version} expected'
+
+    def __init__(self, *, required_version: int) -> None:
+        super().__init__(required_version=required_version)
diff --git a/pydantic/exceptions.py b/pydantic/exceptions.py
@@ -1,27 +1,13 @@
 import json
+from functools import lru_cache
 from typing import Iterable, Type
 
+from .errors import PydanticErrorMixin, PydanticTypeError, PydanticValueError
 from .utils import to_snake_case
 
 __all__ = (
     'Error',
     'ValidationError',
-    'ConfigError',
-
-    'ValueError_',
-    'TypeError_',
-
-    'MissingError',
-    'ExtraError',
-
-    'DecimalError',
-    'DecimalIsNotFiniteError',
-    'DecimalMaxDigitsError',
-    'DecimalMaxPlacesError',
-    'DecimalWholeDigitsError',
-
-    'UUIDError',
-    'UUIDVersionError',
 )
 
 
@@ -78,89 +64,6 @@ def json(self, *, indent=2):
         return json.dumps(self.flatten_errors(), indent=indent, sort_keys=True)
 
 
-    pass
-
-
-class ValueError_(ValueError):
-    def __init__(self, msg_tmpl, **ctx):
-        self.ctx = ctx or None
-        self.msg_tmpl = msg_tmpl
-
-        super().__init__()
-
-    def __str__(self) -> str:
-        return self.msg_tmpl.format(**self.ctx or {})
-
-
-class TypeError_(TypeError):
-    def __init__(self, msg_tmpl, **ctx):
-        self.ctx = ctx or None
-        self.msg_tmpl = msg_tmpl
-
-        super().__init__()
-
-    def __str__(self) -> str:
-        return self.msg_tmpl.format(**self.ctx or {})
-
-
-class MissingError(ValueError_):
-    def __init__(self) -> None:
-        super().__init__('field required')
-
-
-class ExtraError(ValueError_):
-    def __init__(self) -> None:
-        super().__init__('extra fields not permitted')
-
-
-class DecimalError(TypeError_):
-    def __init__(self) -> None:
-        super().__init__('value is not a valid decimal')
-
-
-class DecimalIsNotFiniteError(ValueError_):
-    def __init__(self) -> None:
-        super().__init__('value is not a valid decimal')
-
-
-class DecimalMaxDigitsError(ValueError_):
-    def __init__(self, *, max_digits: int) -> None:
-        super().__init__(
-            'ensure that there are no more than {max_digits} digits in total',
-            max_digits=max_digits
-        )
-
-
-class DecimalMaxPlacesError(ValueError_):
-    def __init__(self, *, decimal_places: int) -> None:
-        super().__init__(
-            'ensure that there are no more than {decimal_places} decimal places',
-            decimal_places=decimal_places
-        )
-
-
-class DecimalWholeDigitsError(ValueError_):
-    def __init__(self, *, whole_digits: int) -> None:
-        super().__init__(
-            'ensure that there are no more than {whole_digits} digits before the decimal point',
-            whole_digits=whole_digits
-        )
-
-
-class UUIDError(TypeError_):
-    def __init__(self):
-        super().__init__('value is not a valid uuid')
-
-
-class UUIDVersionError(ValueError_):
-    def __init__(self, *, required_version: int) -> None:
-        super().__init__(
-            'uuid version {required_version} expected',
-            required_version=required_version
-        )
-
-
 def display_errors(errors):
     return '\n'.join(
         f'{_display_error_loc(e["loc"])}\n  {e["msg"]} (type={e["type"]})'
@@ -185,28 +88,20 @@ def flatten_errors(errors, *, loc=None):
             raise RuntimeError(f'Unknown error object: {error}')
 
 
-_EXC_TYPES = {}
-
-
+@lru_cache()
 def get_exc_type(exc: Exception) -> str:
-    exc = type(exc)
-    if exc in _EXC_TYPES:
-        return _EXC_TYPES[exc]
-
-    bases = tuple(_get_exc_bases(exc))
+    bases = tuple(_get_exc_bases(type(exc)))
     bases = bases[::-1]
 
-    type_ = to_snake_case('.'.join(bases))
-    _EXC_TYPES[exc] = type_
-    return type_
+    return to_snake_case('.'.join(bases))
 
 
 def _get_exc_bases(exc: Type[Exception]) -> Iterable[str]:
     for b in exc.__mro__:
-        if b in (ValueError_, TypeError_,):
+        if b in (PydanticErrorMixin, PydanticTypeError, PydanticValueError):
             continue
 
-        if b in (ValueError, TypeError):
+        if b in (TypeError, ValueError):
             yield b.__name__
             break
 

diff --git a/pydantic/fields.py b/pydantic/fields.py
@@ -2,7 +2,8 @@
 from enum import IntEnum
 from typing import Any, Callable, List, Mapping, NamedTuple, Set, Type, Union
 
-from .exceptions import ConfigError, Error
+from .errors import ConfigError
+from .exceptions import Error
 from .utils import display_as_type
 from .validators import NoneType, dict_validator, find_validators, not_none_validator
 

diff --git a/pydantic/main.py b/pydantic/main.py
@@ -6,7 +6,8 @@
 from types import FunctionType
 from typing import Any, Dict, Set, Type, Union
 
-from .exceptions import ConfigError, Error, ExtraError, MissingError, ValidationError
+from .errors import ConfigError, ExtraError, MissingError
+from .exceptions import Error, ValidationError
 from .fields import Field, Validator
 from .parse import Protocol, load_file, load_str_bytes
 from .types import StrBytes

diff --git a/pydantic/types.py b/pydantic/types.py
@@ -3,7 +3,7 @@
 from typing import Optional, Pattern, Type, Union
 from uuid import UUID
 
-from .exceptions import DecimalIsNotFiniteError, DecimalMaxDigitsError, DecimalMaxPlacesError, DecimalWholeDigitsError
+from . import errors
 from .utils import import_string, make_dsn, validate_email
 from .validators import (anystr_length_validator, anystr_strip_whitespace, decimal_validator, not_none_validator,
                          number_size_validator, str_validator)
@@ -239,7 +239,7 @@ def get_validators(cls):
     def validate(cls, value: Decimal) -> Decimal:
         digit_tuple, exponent = value.as_tuple()[1:]
         if exponent in {'F', 'n', 'N'}:
-            raise DecimalIsNotFiniteError()
+            raise errors.DecimalIsNotFiniteError()
 
         if exponent >= 0:
             # A positive exponent adds that many trailing zeros.
@@ -259,15 +259,15 @@ def validate(cls, value: Decimal) -> Decimal:
         whole_digits = digits - decimals
 
         if cls.max_digits is not None and digits > cls.max_digits:
-            raise DecimalMaxDigitsError(max_digits=cls.max_digits)
+            raise errors.DecimalMaxDigitsError(max_digits=cls.max_digits)
 
         if cls.decimal_places is not None and decimals > cls.decimal_places:
-            raise DecimalMaxPlacesError(decimal_places=cls.decimal_places)
+            raise errors.DecimalMaxPlacesError(decimal_places=cls.decimal_places)
 
         if cls.max_digits is not None and cls.decimal_places is not None:
             expected = cls.max_digits - cls.decimal_places
             if whole_digits > expected:
-                raise DecimalWholeDigitsError(whole_digits=expected)
+                raise errors.DecimalWholeDigitsError(whole_digits=expected)
 
         return value
 

diff --git a/pydantic/validators.py b/pydantic/validators.py
@@ -6,8 +6,8 @@
 from typing import Any
 from uuid import UUID
 
+from . import errors
 from .datetime_parse import parse_date, parse_datetime, parse_duration, parse_time
-from .exceptions import ConfigError, DecimalError, DecimalIsNotFiniteError, UUIDError, UUIDVersionError
 from .utils import display_as_type
 
 NoneType = type(None)
@@ -135,14 +135,14 @@ def uuid_validator(v, field, config, **kwargs) -> UUID:
         elif isinstance(v, (bytes, bytearray)):
             v = UUID(v.decode())
     except ValueError as e:
-        raise UUIDError() from e
+        raise errors.UUIDError() from e
 
     if not isinstance(v, UUID):
-        raise UUIDError()
+        raise errors.UUIDError()
 
     required_version = getattr(field.type_, '_required_version', None)
     if required_version and v.version != required_version:
-        raise UUIDVersionError(required_version=required_version)
+        raise errors.UUIDVersionError(required_version=required_version)
 
     return v
 
@@ -158,10 +158,10 @@ def decimal_validator(v) -> Decimal:
     try:
         v = Decimal(v)
     except DecimalException as e:
-        raise DecimalError() from e
+        raise errors.DecimalError() from e
 
     if not v.is_finite():
-        raise DecimalIsNotFiniteError()
+        raise errors.DecimalIsNotFiniteError()
 
     return v
 
@@ -204,4 +204,4 @@ def find_validators(type_):
         except TypeError as e:
             # TODO: RuntimeError?
             raise TypeError(f'error checking inheritance of {type_!r} (type: {display_as_type(type_)})') from e
-    raise ConfigError(f'no validator found for {type_}')
+    raise errors.ConfigError(f'no validator found for {type_}')