Use special exception hook for any exception object that defines a _h…

…andle_() method. Version => 0.1.4

setup.py

@@ -42,6 +42,7 @@
     # Runtime dependencies
     install_requires=[
         "colorama>=0.3",
+        "typesentry==" + version,
     ],
     tests_require=[
         "pytest>=3.0",

tests/test_config.py

@@ -18,12 +18,12 @@ def foo(x):
         foo("just a flesh wound!")
         assert False, "Expected a failure above"
     except TE as e:
-        e.report()
+        e._handle_()
 
 
 def test_custom_exceptions():
     class CustomError(TypeError):
-        def report(self):
+        def _handle_(self):
             pass
 
     conf = typesentry.Config(type_error=CustomError, value_error=CustomError,
@@ -37,7 +37,7 @@ def foo(x):
         foo("bazinga!")
         assert False, "Expected a failure"
     except CustomError as e:
-        e.report()
+        e._handle_()
 
 
 def test_disabled():

typesentry/__version__.py

@@ -15,4 +15,4 @@
 
 """
 
-version = "0.1.3"
+version = "0.1.4"

typesentry/config.py

@@ -14,17 +14,21 @@
 
 
 # Derive from the builtin TypeError
-class TypeError(TypeError):
-    def report(self):
+class TsTypeError(TypeError):
+    def _handle_(self):
         _handle_tc_error(self)
 
 
 # Derive from the builtin ValueError
-class ValueError(ValueError):
-    def report(self):
+class TsValueError(ValueError):
+    def _handle_(self):
         _handle_tc_error(self)
 
 
+TsTypeError.__name__ = "TypeError"
+TsValueError.__name__ = "ValueError"
+
+
 
 class Config(object):
     """
@@ -39,7 +43,7 @@ def foo(x):
 
     """
 
-    def __init__(self, type_error=TypeError, value_error=ValueError,
+    def __init__(self, type_error=TsTypeError, value_error=TsValueError,
                  disabled=False, soft_exceptions=True):
         """
         Create new type-checking configuration.
@@ -51,18 +55,19 @@ def __init__(self, type_error=TypeError, value_error=ValueError,
             error occurs. It is recommended that this class derives from the
             standard ``ValueError``.
         :param disabled: if True, then all type-checking will be disabled.
-        :param soft_exceptions: if True, then exceptions raised by this module
-            will use a custom exception handler (method ``.report()`` on the
-            exception object).
+        :param soft_exceptions: if True, then a custom exceptions handler will
+            be installed at the console level, which will catch any exception
+            with method ``._handle_()`` and use that method to report the
+            error.
         """
         self.TypeError = type_error
         self.ValueError = value_error
         self.typed = self._make_typed(disabled)
         if soft_exceptions:
-            assert callable(getattr(type_error, "report")), \
-                "Class %s missing method .report()" % type_error.__name__
-            assert callable(getattr(value_error, "report")), \
-                "Class %s missing method .report()" % value_error.__name__
+            assert callable(getattr(type_error, "_handle_")), \
+                "Class %s missing method ._handle_()" % type_error.__name__
+            assert callable(getattr(value_error, "_handle_")), \
+                "Class %s missing method ._handle_()" % value_error.__name__
             self._install_exception_hooks()
 
 
@@ -94,8 +99,8 @@ def _install_exception_hooks(self):
         def except_hook(exc_type, exc_value, exc_tb):  # pragma: no cover
             # This function cannot be tested, becauses it can only be executed
             # by the Python's console
-            if isinstance(exc_value, (self.TypeError, self.ValueError)):
-                exc_value.report()
+            if hasattr(exc_value, "_handle_"):
+                exc_value._handle_()
             else:
                 previous_except_hook(exc_type, exc_value, exc_tb)