cleanup mod and fix a few things (#107)

* cleanup mod and fix a few things

* tweak order

* linting

* improve coverage

Author: samuelcolvin

pydantic_core/_pydantic_core.pyi

@@ -14,7 +14,7 @@ class SchemaError(ValueError):
     pass
 
 class ValidationError(ValueError):
-    model_name: str
+    title: str
 
     def error_count(self) -> int: ...
     def errors(self) -> List[Dict[str, Any]]: ...

src/build_tools.rs

@@ -1,7 +1,10 @@
-use pyo3::exceptions::{PyKeyError, PyTypeError};
+use std::error::Error;
+use std::fmt;
+
+use pyo3::exceptions::{PyException, PyKeyError, PyTypeError};
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
-use pyo3::FromPyObject;
+use pyo3::{FromPyObject, PyErrArguments};
 
 pub trait SchemaDict<'py> {
     fn get_as<T>(&'py self, key: &str) -> PyResult<Option<T>>
@@ -80,12 +83,63 @@ pub fn is_strict(schema: &PyDict, config: Option<&PyDict>) -> PyResult<bool> {
     Ok(schema_or_config(schema, config, "strict", "strict")?.unwrap_or(false))
 }
 
+// we could perhaps do clever things here to store each schema error, or have different types for the top
+// level error group, and other errors, we could perhaps also support error groups!?
+#[pyclass(extends=PyException, module="pydantic_core._pydantic_core")]
+pub struct SchemaError {
+    message: String,
+}
+
+impl fmt::Debug for SchemaError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "SchemaError({:?})", self.message)
+    }
+}
+
+impl fmt::Display for SchemaError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl Error for SchemaError {
+    #[cfg_attr(has_no_coverage, no_coverage)]
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        None
+    }
+}
+
+impl SchemaError {
+    pub fn new_err<A>(args: A) -> PyErr
+    where
+        A: PyErrArguments + Send + Sync + 'static,
+    {
+        PyErr::new::<SchemaError, A>(args)
+    }
+}
+
+#[pymethods]
+impl SchemaError {
+    #[new]
+    fn py_new(message: String) -> Self {
+        Self { message }
+    }
+
+    fn __repr__(&self) -> String {
+        format!("{:?}", self)
+    }
+
+    fn __str__(&self) -> String {
+        self.to_string()
+    }
+}
+
 macro_rules! py_error {
     ($msg:expr) => {
-        crate::build_tools::py_error!(crate::SchemaError; $msg)
+        crate::build_tools::py_error!(crate::build_tools::SchemaError; $msg)
     };
     ($msg:expr, $( $msg_args:expr ),+ ) => {
-        crate::build_tools::py_error!(crate::SchemaError; $msg, $( $msg_args ),+)
+        crate::build_tools::py_error!(crate::build_tools::SchemaError; $msg, $( $msg_args ),+)
     };
 
     ($error_type:ty; $msg:expr) => {

src/errors/validation_exception.rs

@@ -14,7 +14,7 @@ use super::line_error::{Context, LocItem, Location, ValLineError};
 
 use super::ValError;
 
-#[pyclass(extends=PyValueError)]
+#[pyclass(extends=PyValueError, module="pydantic_core._pydantic_core")]
 #[derive(Debug)]
 pub struct ValidationError {
     line_errors: Vec<PyLineError>,
@@ -32,13 +32,13 @@ pub fn as_validation_err(py: Python, model_name: &str, error: ValError) -> PyErr
 }
 
 impl fmt::Display for ValidationError {
+    #[cfg_attr(has_no_coverage, no_coverage)]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.display(None))
     }
 }
 
 impl ValidationError {
-    #[inline]
     pub fn new_err<A>(args: A) -> PyErr
     where
         A: PyErrArguments + Send + Sync + 'static,
@@ -64,6 +64,7 @@ impl ValidationError {
 }
 
 impl Error for ValidationError {
+    #[cfg_attr(has_no_coverage, no_coverage)]
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         // we could in theory set self.source as `ValError::LineErrors(line_errors.clone())`, then return that here
         // source is not used, and I can't imagine why it would be

src/lib.rs

@@ -1,8 +1,6 @@
 #![cfg_attr(has_no_coverage, feature(no_coverage))]
 #![allow(clippy::borrow_deref_ref)]
 
-use pyo3::create_exception;
-use pyo3::exceptions::PyException;
 use pyo3::prelude::*;
 
 #[cfg(feature = "mimalloc")]
@@ -15,22 +13,25 @@ mod input;
 mod validators;
 
 // required for benchmarks
+pub use build_tools::SchemaError;
+pub use errors::ValidationError;
 pub use validators::SchemaValidator;
 
-create_exception!(_pydantic_core, SchemaError, PyException);
-
-#[pymodule]
-fn _pydantic_core(py: Python, m: &PyModule) -> PyResult<()> {
-    let mut version = env!("CARGO_PKG_VERSION").to_string();
+pub fn get_version() -> String {
+    let version = env!("CARGO_PKG_VERSION").to_string();
     // cargo uses "1.0-alpha1" etc. while python uses "1.0.0a1", this is not full compatibility,
     // but it's good enough for now
     // see https://docs.rs/semver/1.0.9/semver/struct.Version.html#method.parse for rust spec
     // see https://peps.python.org/pep-0440/ for python spec
     // it seems the dot after "alpha/beta" e.g. "-alpha.1" is not necessary, hence why this works
-    version = version.replace("-alpha", "a").replace("-beta", "b");
-    m.add("__version__", version)?;
-    m.add("ValidationError", py.get_type::<errors::ValidationError>())?;
-    m.add("SchemaError", py.get_type::<SchemaError>())?;
+    version.replace("-alpha", "a").replace("-beta", "b")
+}
+
+#[pymodule]
+fn _pydantic_core(_py: Python, m: &PyModule) -> PyResult<()> {
+    m.add("__version__", get_version())?;
     m.add_class::<SchemaValidator>()?;
+    m.add_class::<ValidationError>()?;
+    m.add_class::<SchemaError>()?;
     Ok(())
 }

src/validators/mod.rs

@@ -7,10 +7,9 @@ use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyDict};
 use serde_json::from_str as parse_json;
 
-use crate::build_tools::{py_error, SchemaDict};
+use crate::build_tools::{py_error, SchemaDict, SchemaError};
 use crate::errors::{as_validation_err, val_line_error, ErrorKind, ValError, ValResult};
 use crate::input::{Input, JsonInput};
-use crate::SchemaError;
 
 mod any;
 mod bool;
@@ -140,7 +139,7 @@ macro_rules! validator_match {
                 <$validator>::EXPECTED_TYPE => {
                     $build_context.incr_check_depth()?;
                     let val = <$validator>::build($dict, $config, $build_context).map_err(|err| {
-                        crate::SchemaError::new_err(format!("Error building \"{}\" validator:\n  {}", $type, err))
+                        SchemaError::new_err(format!("Error building \"{}\" validator:\n  {}", $type, err))
                     })?;
                     $build_context.decr_depth();
                     Ok((val, $dict))

tests/test_misc.py

@@ -0,0 +1,76 @@
+import pytest
+
+from pydantic_core._pydantic_core import SchemaError, SchemaValidator, ValidationError, __version__
+
+
+@pytest.mark.parametrize('obj', [ValidationError, SchemaValidator, SchemaError])
+def test_module(obj):
+    assert obj.__module__ == 'pydantic_core._pydantic_core'
+
+
+def test_version():
+    assert isinstance(__version__, str)
+    assert '.' in __version__
+
+
+def test_schema_error():
+    err = SchemaError('test')
+    assert isinstance(err, Exception)
+    assert str(err) == 'test'
+    assert repr(err) == 'SchemaError("test")'
+
+
+def test_validation_error():
+    v = SchemaValidator('int')
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python(1.5)
+
+    assert exc_info.value.title == 'int'
+    assert exc_info.value.error_count() == 1
+
+
+def test_validation_error_multiple():
+    class MyModel:
+        # this is not required, but it avoids `__fields_set__` being included in `__dict__`
+        __slots__ = '__dict__', '__fields_set__'
+        field_a: str
+        field_b: int
+
+    v = SchemaValidator(
+        {
+            'type': 'model-class',
+            'class_type': MyModel,
+            'model': {
+                'type': 'model',
+                'fields': {'x': {'schema': {'type': 'float'}}, 'y': {'schema': {'type': 'int'}}},
+            },
+        }
+    )
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python({'x': 'x' * 60, 'y': 'y'})
+
+    assert exc_info.value.title == 'MyModel'
+    assert exc_info.value.error_count() == 2
+    assert exc_info.value.errors() == [
+        {
+            'kind': 'float_parsing',
+            'loc': ['x'],
+            'message': 'Value must be a valid number, unable to parse string as an number',
+            'input_value': 'x' * 60,
+        },
+        {
+            'kind': 'int_parsing',
+            'loc': ['y'],
+            'message': 'Value must be a valid integer, unable to parse string as an integer',
+            'input_value': 'y',
+        },
+    ]
+    assert repr(exc_info.value) == (
+        '2 validation errors for MyModel\n'
+        'x\n'
+        "  Value must be a valid number, unable to parse string as an number [kind=float_parsing, input_value='xxxxxxx"
+        "xxxxxxxxxxxxxxxxx...xxxxxxxxxxxxxxxxxxxxxxx', input_type=str]\n"
+        'y\n'
+        "  Value must be a valid integer, unable to parse string as an integer [kind=int_parsing, input_value='y', "
+        'input_type=str]'
+    )